]> nv-tegra.nvidia Code Review - linux-3.10.git/blob - drivers/char/agp/sgi-agp.c
Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/agpgart
[linux-3.10.git] / drivers / char / agp / sgi-agp.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (C) 2003-2005 Silicon Graphics, Inc.  All Rights Reserved.
7  */
8
9 /*
10  * SGI TIOCA AGPGART routines.
11  *
12  */
13
14 #include <linux/acpi.h>
15 #include <linux/module.h>
16 #include <linux/pci.h>
17 #include <linux/init.h>
18 #include <linux/agp_backend.h>
19 #include <asm/sn/addrs.h>
20 #include <asm/sn/io.h>
21 #include <asm/sn/pcidev.h>
22 #include <asm/sn/pcibus_provider_defs.h>
23 #include <asm/sn/tioca_provider.h>
24 #include "agp.h"
25
26 extern int agp_memory_reserved;
27 extern uint32_t tioca_gart_found;
28 extern struct list_head tioca_list;
29 static struct agp_bridge_data **sgi_tioca_agp_bridges;
30
31 /*
32  * The aperature size and related information is set up at TIOCA init time.
33  * Values for this table will be extracted and filled in at
34  * sgi_tioca_fetch_size() time.
35  */
36
37 static struct aper_size_info_fixed sgi_tioca_sizes[] = {
38         {0, 0, 0},
39 };
40
41 static void *sgi_tioca_alloc_page(struct agp_bridge_data *bridge)
42 {
43         struct page *page;
44         int nid;
45         struct tioca_kernel *info =
46             (struct tioca_kernel *)bridge->dev_private_data;
47
48         nid = info->ca_closest_node;
49         page = alloc_pages_node(nid, GFP_KERNEL, 0);
50         if (page == NULL) {
51                 return 0;
52         }
53
54         get_page(page);
55         SetPageLocked(page);
56         atomic_inc(&agp_bridge->current_memory_agp);
57         return page_address(page);
58 }
59
60 /*
61  * Flush GART tlb's.  Cannot selectively flush based on memory so the mem
62  * arg is ignored.
63  */
64
65 static void sgi_tioca_tlbflush(struct agp_memory *mem)
66 {
67         tioca_tlbflush(mem->bridge->dev_private_data);
68 }
69
70 /*
71  * Given an address of a host physical page, turn it into a valid gart
72  * entry.
73  */
74 static unsigned long
75 sgi_tioca_mask_memory(struct agp_bridge_data *bridge,
76                       unsigned long addr, int type)
77 {
78         return tioca_physpage_to_gart(addr);
79 }
80
81 static void sgi_tioca_agp_enable(struct agp_bridge_data *bridge, u32 mode)
82 {
83         tioca_fastwrite_enable(bridge->dev_private_data);
84 }
85
86 /*
87  * sgi_tioca_configure() doesn't have anything to do since the base CA driver
88  * has alreay set up the GART.
89  */
90
91 static int sgi_tioca_configure(void)
92 {
93         return 0;
94 }
95
96 /*
97  * Determine gfx aperature size.  This has already been determined by the
98  * CA driver init, so just need to set agp_bridge values accordingly.
99  */
100
101 static int sgi_tioca_fetch_size(void)
102 {
103         struct tioca_kernel *info =
104             (struct tioca_kernel *)agp_bridge->dev_private_data;
105
106         sgi_tioca_sizes[0].size = info->ca_gfxap_size / MB(1);
107         sgi_tioca_sizes[0].num_entries = info->ca_gfxgart_entries;
108
109         return sgi_tioca_sizes[0].size;
110 }
111
112 static int sgi_tioca_create_gatt_table(struct agp_bridge_data *bridge)
113 {
114         struct tioca_kernel *info =
115             (struct tioca_kernel *)bridge->dev_private_data;
116
117         bridge->gatt_table_real = (u32 *) info->ca_gfxgart;
118         bridge->gatt_table = bridge->gatt_table_real;
119         bridge->gatt_bus_addr = info->ca_gfxgart_base;
120
121         return 0;
122 }
123
124 static int sgi_tioca_free_gatt_table(struct agp_bridge_data *bridge)
125 {
126         return 0;
127 }
128
129 static int sgi_tioca_insert_memory(struct agp_memory *mem, off_t pg_start,
130                                    int type)
131 {
132         int num_entries;
133         size_t i;
134         off_t j;
135         void *temp;
136         struct agp_bridge_data *bridge;
137         u64 *table;
138
139         bridge = mem->bridge;
140         if (!bridge)
141                 return -EINVAL;
142
143         table = (u64 *)bridge->gatt_table;
144
145         temp = bridge->current_size;
146
147         switch (bridge->driver->size_type) {
148         case U8_APER_SIZE:
149                 num_entries = A_SIZE_8(temp)->num_entries;
150                 break;
151         case U16_APER_SIZE:
152                 num_entries = A_SIZE_16(temp)->num_entries;
153                 break;
154         case U32_APER_SIZE:
155                 num_entries = A_SIZE_32(temp)->num_entries;
156                 break;
157         case FIXED_APER_SIZE:
158                 num_entries = A_SIZE_FIX(temp)->num_entries;
159                 break;
160         case LVL2_APER_SIZE:
161                 return -EINVAL;
162                 break;
163         default:
164                 num_entries = 0;
165                 break;
166         }
167
168         num_entries -= agp_memory_reserved / PAGE_SIZE;
169         if (num_entries < 0)
170                 num_entries = 0;
171
172         if (type != 0 || mem->type != 0) {
173                 return -EINVAL;
174         }
175
176         if ((pg_start + mem->page_count) > num_entries)
177                 return -EINVAL;
178
179         j = pg_start;
180
181         while (j < (pg_start + mem->page_count)) {
182                 if (table[j])
183                         return -EBUSY;
184                 j++;
185         }
186
187         if (mem->is_flushed == FALSE) {
188                 bridge->driver->cache_flush();
189                 mem->is_flushed = TRUE;
190         }
191
192         for (i = 0, j = pg_start; i < mem->page_count; i++, j++) {
193                 table[j] =
194                     bridge->driver->mask_memory(bridge, mem->memory[i],
195                                                 mem->type);
196         }
197
198         bridge->driver->tlb_flush(mem);
199         return 0;
200 }
201
202 static int sgi_tioca_remove_memory(struct agp_memory *mem, off_t pg_start,
203                                    int type)
204 {
205         size_t i;
206         struct agp_bridge_data *bridge;
207         u64 *table;
208
209         bridge = mem->bridge;
210         if (!bridge)
211                 return -EINVAL;
212
213         if (type != 0 || mem->type != 0) {
214                 return -EINVAL;
215         }
216
217         table = (u64 *)bridge->gatt_table;
218
219         for (i = pg_start; i < (mem->page_count + pg_start); i++) {
220                 table[i] = 0;
221         }
222
223         bridge->driver->tlb_flush(mem);
224         return 0;
225 }
226
227 static void sgi_tioca_cache_flush(void)
228 {
229 }
230
231 /*
232  * Cleanup.  Nothing to do as the CA driver owns the GART.
233  */
234
235 static void sgi_tioca_cleanup(void)
236 {
237 }
238
239 static struct agp_bridge_data *sgi_tioca_find_bridge(struct pci_dev *pdev)
240 {
241         struct agp_bridge_data *bridge;
242
243         list_for_each_entry(bridge, &agp_bridges, list) {
244                 if (bridge->dev->bus == pdev->bus)
245                         break;
246         }
247         return bridge;
248 }
249
250 struct agp_bridge_driver sgi_tioca_driver = {
251         .owner = THIS_MODULE,
252         .size_type = U16_APER_SIZE,
253         .configure = sgi_tioca_configure,
254         .fetch_size = sgi_tioca_fetch_size,
255         .cleanup = sgi_tioca_cleanup,
256         .tlb_flush = sgi_tioca_tlbflush,
257         .mask_memory = sgi_tioca_mask_memory,
258         .agp_enable = sgi_tioca_agp_enable,
259         .cache_flush = sgi_tioca_cache_flush,
260         .create_gatt_table = sgi_tioca_create_gatt_table,
261         .free_gatt_table = sgi_tioca_free_gatt_table,
262         .insert_memory = sgi_tioca_insert_memory,
263         .remove_memory = sgi_tioca_remove_memory,
264         .alloc_by_type = agp_generic_alloc_by_type,
265         .free_by_type = agp_generic_free_by_type,
266         .agp_alloc_page = sgi_tioca_alloc_page,
267         .agp_destroy_page = agp_generic_destroy_page,
268         .cant_use_aperture = 1,
269         .needs_scratch_page = 0,
270         .num_aperture_sizes = 1,
271 };
272
273 static int __devinit agp_sgi_init(void)
274 {
275         unsigned int j;
276         struct tioca_kernel *info;
277         struct pci_dev *pdev = NULL;
278
279         if (tioca_gart_found)
280                 printk(KERN_INFO PFX "SGI TIO CA GART driver initialized.\n");
281         else
282                 return 0;
283
284         sgi_tioca_agp_bridges =
285             (struct agp_bridge_data **)kmalloc(tioca_gart_found *
286                                                sizeof(struct agp_bridge_data *),
287                                                GFP_KERNEL);
288
289         j = 0;
290         list_for_each_entry(info, &tioca_list, ca_list) {
291                 struct list_head *tmp;
292                 if (list_empty(info->ca_devices))
293                         continue;
294                 list_for_each(tmp, info->ca_devices) {
295                         u8 cap_ptr;
296                         pdev = pci_dev_b(tmp);
297                         if (pdev->class != (PCI_CLASS_DISPLAY_VGA << 8))
298                                 continue;
299                         cap_ptr = pci_find_capability(pdev, PCI_CAP_ID_AGP);
300                         if (!cap_ptr)
301                                 continue;
302                 }
303                 sgi_tioca_agp_bridges[j] = agp_alloc_bridge();
304                 printk(KERN_INFO PFX "bridge %d = 0x%p\n", j,
305                        sgi_tioca_agp_bridges[j]);
306                 if (sgi_tioca_agp_bridges[j]) {
307                         sgi_tioca_agp_bridges[j]->dev = pdev;
308                         sgi_tioca_agp_bridges[j]->dev_private_data = info;
309                         sgi_tioca_agp_bridges[j]->driver = &sgi_tioca_driver;
310                         sgi_tioca_agp_bridges[j]->gart_bus_addr =
311                             info->ca_gfxap_base;
312                         sgi_tioca_agp_bridges[j]->mode = (0x7D << 24) | /* 126 requests */
313                             (0x1 << 9) |        /* SBA supported */
314                             (0x1 << 5) |        /* 64-bit addresses supported */
315                             (0x1 << 4) |        /* FW supported */
316                             (0x1 << 3) |        /* AGP 3.0 mode */
317                             0x2;        /* 8x transfer only */
318                         sgi_tioca_agp_bridges[j]->current_size =
319                             sgi_tioca_agp_bridges[j]->previous_size =
320                             (void *)&sgi_tioca_sizes[0];
321                         agp_add_bridge(sgi_tioca_agp_bridges[j]);
322                 }
323                 j++;
324         }
325
326         agp_find_bridge = &sgi_tioca_find_bridge;
327         return 0;
328 }
329
330 static void __devexit agp_sgi_cleanup(void)
331 {
332         if(sgi_tioca_agp_bridges)
333                 kfree(sgi_tioca_agp_bridges);
334         sgi_tioca_agp_bridges=NULL;
335 }
336
337 module_init(agp_sgi_init);
338 module_exit(agp_sgi_cleanup);
339
340 MODULE_LICENSE("GPL and additional rights");