drm/i915: Use stop_machine()
[dragonfly.git] / sys / dev / agp / agp.c
1 /*-
2  * Copyright (c) 2000 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/agp/agp.c,v 1.62 2009/02/06 20:57:10 wkoszek Exp $
27  */
28
29 #include "opt_agp.h"
30
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/device.h>
34 #include <sys/conf.h>
35 #include <sys/malloc.h>
36 #include <sys/kernel.h>
37 #include <sys/bus.h>
38 #include <sys/agpio.h>
39 #include <sys/lock.h>
40 #include <sys/proc.h>
41 #include <sys/rman.h>
42
43 #include <bus/pci/pcivar.h>
44 #include <bus/pci/pcireg.h>
45 #include "agppriv.h"
46 #include "agpvar.h"
47 #include "agpreg.h"
48
49 #include <vm/vm.h>
50 #include <vm/vm_object.h>
51 #include <vm/vm_page.h>
52 #include <vm/vm_pageout.h>
53 #include <vm/pmap.h>
54
55 #include <machine/md_var.h>
56
57 MODULE_VERSION(agp, 1);
58
59 MALLOC_DEFINE(M_AGP, "agp", "AGP data structures");
60
61 static d_open_t agp_open;
62 static d_close_t agp_close;
63 static d_ioctl_t agp_ioctl;
64 static d_mmap_t agp_mmap;
65
66 static struct dev_ops agp_ops = {
67         { "agp", 0, D_TTY },
68         .d_open =       agp_open,
69         .d_close =      agp_close,
70         .d_ioctl =      agp_ioctl,
71         .d_mmap =       agp_mmap,
72 };
73
74 static devclass_t agp_devclass;
75
76 /* Helper functions for implementing chipset mini drivers. */
77
78 void
79 agp_flush_cache(void)
80 {
81 #if defined(__i386__) || defined(__x86_64__)
82         wbinvd();
83 #endif
84 }
85
86 u_int8_t
87 agp_find_caps(device_t dev)
88 {
89         int capreg;
90
91         if (pci_find_extcap(dev, PCIY_AGP, &capreg) != 0)
92                 capreg = 0;
93         return (capreg);
94 }
95
96 /*
97  * Find an AGP display device (if any).
98  */
99 static device_t
100 agp_find_display(void)
101 {
102         devclass_t pci = devclass_find("pci");
103         device_t bus, dev = 0;
104         device_t *kids;
105         int busnum, numkids, i;
106
107         for (busnum = 0; busnum < devclass_get_maxunit(pci); busnum++) {
108                 bus = devclass_get_device(pci, busnum);
109                 if (!bus)
110                         continue;
111                 device_get_children(bus, &kids, &numkids);
112                 for (i = 0; i < numkids; i++) {
113                         dev = kids[i];
114                         if (pci_get_class(dev) == PCIC_DISPLAY)
115                                 if (agp_find_caps(dev)) {
116                                         kfree(kids, M_TEMP);
117                                         return dev;
118                                 }
119                                         
120                 }
121                 kfree(kids, M_TEMP);
122         }
123
124         return 0;
125 }
126
127 struct agp_gatt *
128 agp_alloc_gatt(device_t dev)
129 {
130         u_int32_t apsize = AGP_GET_APERTURE(dev);
131         u_int32_t entries = apsize >> AGP_PAGE_SHIFT;
132         struct agp_gatt *gatt;
133
134         if (bootverbose)
135                 device_printf(dev,
136                               "allocating GATT for aperture of size %dM\n",
137                               apsize / (1024*1024));
138
139         if (entries == 0) {
140                 device_printf(dev, "bad aperture size\n");
141                 return NULL;
142         }
143
144         gatt = kmalloc(sizeof(struct agp_gatt), M_AGP, M_INTWAIT);
145         gatt->ag_entries = entries;
146         gatt->ag_virtual = contigmalloc(entries * sizeof(u_int32_t), M_AGP,
147                                         M_WAITOK|M_ZERO, 0, ~0, PAGE_SIZE, 0);
148         if (!gatt->ag_virtual) {
149                 if (bootverbose)
150                         device_printf(dev, "contiguous allocation failed\n");
151                 kfree(gatt, M_AGP);
152                 return 0;
153         }
154         gatt->ag_physical = vtophys((vm_offset_t) gatt->ag_virtual);
155         agp_flush_cache();
156
157         return gatt;
158 }
159
160 void
161 agp_free_gatt(struct agp_gatt *gatt)
162 {
163         contigfree(gatt->ag_virtual,
164                    gatt->ag_entries * sizeof(u_int32_t), M_AGP);
165         kfree(gatt, M_AGP);
166 }
167
168 static u_int agp_max[][2] = {
169         {0,     0},
170         {32,    4},
171         {64,    28},
172         {128,   96},
173         {256,   204},
174         {512,   440},
175         {1024,  942},
176         {2048,  1920},
177         {4096,  3932}
178 };
179 #define agp_max_size    NELEM(agp_max)
180
181 /**
182  * Sets the PCI resource which represents the AGP aperture.
183  *
184  * If not called, the default AGP aperture resource of AGP_APBASE will
185  * be used.  Must be called before agp_generic_attach().
186  */
187 void
188 agp_set_aperture_resource(device_t dev, int rid)
189 {
190         struct agp_softc *sc = device_get_softc(dev);
191
192         sc->as_aperture_rid = rid;
193 }
194
195 int
196 agp_generic_attach(device_t dev)
197 {
198         struct agp_softc *sc = device_get_softc(dev);
199         int i;
200         u_int memsize;
201
202         /*
203          * Find and map the aperture, RF_SHAREABLE for DRM but not RF_ACTIVE
204          * because the kernel doesn't need to map it.
205          */
206         if (sc->as_aperture_rid == 0)
207                 sc->as_aperture_rid = AGP_APBASE;
208
209         sc->as_aperture = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
210             &sc->as_aperture_rid, RF_SHAREABLE);
211         if (!sc->as_aperture)
212                 return ENOMEM;
213
214         /*
215          * Work out an upper bound for agp memory allocation. This
216          * uses a heurisitc table from the Linux driver.
217          */
218         memsize = ptoa(Maxmem) >> 20;
219         for (i = 0; i < agp_max_size; i++) {
220                 if (memsize <= agp_max[i][0])
221                         break;
222         }
223         if (i == agp_max_size)
224                 i = agp_max_size - 1;
225         sc->as_maxmem = agp_max[i][1] << 20U;
226
227         /*
228          * The lock is used to prevent re-entry to
229          * agp_generic_bind_memory() since that function can sleep.
230          */
231         lockinit(&sc->as_lock, "agplk", 0, 0);
232
233         /*
234          * Initialise stuff for the userland device.
235          */
236         agp_devclass = devclass_find("agp");
237         TAILQ_INIT(&sc->as_memory);
238         sc->as_nextid = 1;
239
240         sc->as_devnode = make_dev(&agp_ops,
241             0, UID_ROOT, GID_WHEEL, 0600, "agpgart");
242         sc->as_devnode->si_drv1 = dev;
243
244         return 0;
245 }
246
247 void
248 agp_free_cdev(device_t dev)
249 {
250         dev_ops_remove_minor(&agp_ops, device_get_unit(dev));
251 }
252
253 void
254 agp_free_res(device_t dev)
255 {
256         struct agp_softc *sc = device_get_softc(dev);
257
258         bus_release_resource(dev, SYS_RES_MEMORY, sc->as_aperture_rid,
259                              sc->as_aperture);
260         agp_flush_cache();
261 }
262
263 int
264 agp_generic_detach(device_t dev)
265 {
266         agp_free_cdev(dev);
267         agp_free_res(dev);
268         return 0;
269 }
270
271 /**
272  * Default AGP aperture size detection which simply returns the size of
273  * the aperture's PCI resource.
274  */
275 u_int32_t
276 agp_generic_get_aperture(device_t dev)
277 {
278         struct agp_softc *sc = device_get_softc(dev);
279
280         return rman_get_size(sc->as_aperture);
281 }
282
283 /**
284  * Default AGP aperture size setting function, which simply doesn't allow
285  * changes to resource size.
286  */
287 int
288 agp_generic_set_aperture(device_t dev, u_int32_t aperture)
289 {
290         u_int32_t current_aperture;
291
292         current_aperture = AGP_GET_APERTURE(dev);
293         if (current_aperture != aperture)
294                 return EINVAL;
295         else
296                 return 0;
297 }
298
299 /*
300  * This does the enable logic for v3, with the same topology
301  * restrictions as in place for v2 -- one bus, one device on the bus.
302  */
303 static int
304 agp_v3_enable(device_t dev, device_t mdev, u_int32_t mode)
305 {
306         u_int32_t tstatus, mstatus;
307         u_int32_t command;
308         int rq, sba, fw, rate, arqsz, cal;
309
310         tstatus = pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4);
311         mstatus = pci_read_config(mdev, agp_find_caps(mdev) + AGP_STATUS, 4);
312
313         /* Set RQ to the min of mode, tstatus and mstatus */
314         rq = AGP_MODE_GET_RQ(mode);
315         if (AGP_MODE_GET_RQ(tstatus) < rq)
316                 rq = AGP_MODE_GET_RQ(tstatus);
317         if (AGP_MODE_GET_RQ(mstatus) < rq)
318                 rq = AGP_MODE_GET_RQ(mstatus);
319
320         /*
321          * ARQSZ - Set the value to the maximum one.
322          * Don't allow the mode register to override values.
323          */
324         arqsz = AGP_MODE_GET_ARQSZ(mode);
325         if (AGP_MODE_GET_ARQSZ(tstatus) > rq)
326                 rq = AGP_MODE_GET_ARQSZ(tstatus);
327         if (AGP_MODE_GET_ARQSZ(mstatus) > rq)
328                 rq = AGP_MODE_GET_ARQSZ(mstatus);
329
330         /* Calibration cycle - don't allow override by mode register */
331         cal = AGP_MODE_GET_CAL(tstatus);
332         if (AGP_MODE_GET_CAL(mstatus) < cal)
333                 cal = AGP_MODE_GET_CAL(mstatus);
334
335         /* SBA must be supported for AGP v3. */
336         sba = 1;
337
338         /* Set FW if all three support it. */
339         fw = (AGP_MODE_GET_FW(tstatus)
340                & AGP_MODE_GET_FW(mstatus)
341                & AGP_MODE_GET_FW(mode));
342         
343         /* Figure out the max rate */
344         rate = (AGP_MODE_GET_RATE(tstatus)
345                 & AGP_MODE_GET_RATE(mstatus)
346                 & AGP_MODE_GET_RATE(mode));
347         if (rate & AGP_MODE_V3_RATE_8x)
348                 rate = AGP_MODE_V3_RATE_8x;
349         else
350                 rate = AGP_MODE_V3_RATE_4x;
351         if (bootverbose)
352                 device_printf(dev, "Setting AGP v3 mode %d\n", rate * 4);
353
354         pci_write_config(dev, agp_find_caps(dev) + AGP_COMMAND, 0, 4);
355
356         /* Construct the new mode word and tell the hardware */
357         command = 0;
358         command = AGP_MODE_SET_RQ(0, rq);
359         command = AGP_MODE_SET_ARQSZ(command, arqsz);
360         command = AGP_MODE_SET_CAL(command, cal);
361         command = AGP_MODE_SET_SBA(command, sba);
362         command = AGP_MODE_SET_FW(command, fw);
363         command = AGP_MODE_SET_RATE(command, rate);
364         command = AGP_MODE_SET_MODE_3(command, 1);
365         command = AGP_MODE_SET_AGP(command, 1);
366         pci_write_config(dev, agp_find_caps(dev) + AGP_COMMAND, command, 4);
367         pci_write_config(mdev, agp_find_caps(mdev) + AGP_COMMAND, command, 4);
368
369         return 0;
370 }
371
372 static int
373 agp_v2_enable(device_t dev, device_t mdev, u_int32_t mode)
374 {
375         u_int32_t tstatus, mstatus;
376         u_int32_t command;
377         int rq, sba, fw, rate;
378
379         tstatus = pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4);
380         mstatus = pci_read_config(mdev, agp_find_caps(mdev) + AGP_STATUS, 4);
381
382         /* Set RQ to the min of mode, tstatus and mstatus */
383         rq = AGP_MODE_GET_RQ(mode);
384         if (AGP_MODE_GET_RQ(tstatus) < rq)
385                 rq = AGP_MODE_GET_RQ(tstatus);
386         if (AGP_MODE_GET_RQ(mstatus) < rq)
387                 rq = AGP_MODE_GET_RQ(mstatus);
388
389         /* Set SBA if all three can deal with SBA */
390         sba = (AGP_MODE_GET_SBA(tstatus)
391                & AGP_MODE_GET_SBA(mstatus)
392                & AGP_MODE_GET_SBA(mode));
393
394         /* Similar for FW */
395         fw = (AGP_MODE_GET_FW(tstatus)
396                & AGP_MODE_GET_FW(mstatus)
397                & AGP_MODE_GET_FW(mode));
398
399         /* Figure out the max rate */
400         rate = (AGP_MODE_GET_RATE(tstatus)
401                 & AGP_MODE_GET_RATE(mstatus)
402                 & AGP_MODE_GET_RATE(mode));
403         if (rate & AGP_MODE_V2_RATE_4x)
404                 rate = AGP_MODE_V2_RATE_4x;
405         else if (rate & AGP_MODE_V2_RATE_2x)
406                 rate = AGP_MODE_V2_RATE_2x;
407         else
408                 rate = AGP_MODE_V2_RATE_1x;
409         if (bootverbose)
410                 device_printf(dev, "Setting AGP v2 mode %d\n", rate);
411
412         /* Construct the new mode word and tell the hardware */
413         command = 0;
414         command = AGP_MODE_SET_RQ(0, rq);
415         command = AGP_MODE_SET_SBA(command, sba);
416         command = AGP_MODE_SET_FW(command, fw);
417         command = AGP_MODE_SET_RATE(command, rate);
418         command = AGP_MODE_SET_AGP(command, 1);
419         pci_write_config(dev, agp_find_caps(dev) + AGP_COMMAND, command, 4);
420         pci_write_config(mdev, agp_find_caps(mdev) + AGP_COMMAND, command, 4);
421
422         return 0;
423 }
424
425 int
426 agp_generic_enable(device_t dev, u_int32_t mode)
427 {
428         device_t mdev = agp_find_display();
429         u_int32_t tstatus, mstatus;
430
431         if (!mdev) {
432                 AGP_DPF("can't find display\n");
433                 return ENXIO;
434         }
435
436         tstatus = pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4);
437         mstatus = pci_read_config(mdev, agp_find_caps(mdev) + AGP_STATUS, 4);
438
439         /*
440          * Check display and bridge for AGP v3 support.  AGP v3 allows
441          * more variety in topology than v2, e.g. multiple AGP devices
442          * attached to one bridge, or multiple AGP bridges in one
443          * system.  This doesn't attempt to address those situations,
444          * but should work fine for a classic single AGP slot system
445          * with AGP v3.
446          */
447         if (AGP_MODE_GET_MODE_3(mode) &&
448             AGP_MODE_GET_MODE_3(tstatus) &&
449             AGP_MODE_GET_MODE_3(mstatus))
450                 return (agp_v3_enable(dev, mdev, mode));
451         else
452                 return (agp_v2_enable(dev, mdev, mode));            
453 }
454
455 struct agp_memory *
456 agp_generic_alloc_memory(device_t dev, int type, vm_size_t size)
457 {
458         struct agp_softc *sc = device_get_softc(dev);
459         struct agp_memory *mem;
460
461         if ((size & (AGP_PAGE_SIZE - 1)) != 0)
462                 return 0;
463
464         if (sc->as_allocated + size > sc->as_maxmem)
465                 return 0;
466
467         if (type != 0) {
468                 kprintf("agp_generic_alloc_memory: unsupported type %d\n",
469                         type);
470                 return 0;
471         }
472
473         mem = kmalloc(sizeof *mem, M_AGP, M_INTWAIT);
474         mem->am_id = sc->as_nextid++;
475         mem->am_size = size;
476         mem->am_type = 0;
477         mem->am_obj = vm_object_allocate(OBJT_DEFAULT, atop(round_page(size)));
478         mem->am_physical = 0;
479         mem->am_offset = 0;
480         mem->am_is_bound = 0;
481         TAILQ_INSERT_TAIL(&sc->as_memory, mem, am_link);
482         sc->as_allocated += size;
483
484         return mem;
485 }
486
487 int
488 agp_generic_free_memory(device_t dev, struct agp_memory *mem)
489 {
490         struct agp_softc *sc = device_get_softc(dev);
491
492         if (mem->am_is_bound)
493                 return EBUSY;
494
495         sc->as_allocated -= mem->am_size;
496         TAILQ_REMOVE(&sc->as_memory, mem, am_link);
497         vm_object_deallocate(mem->am_obj);
498         kfree(mem, M_AGP);
499         return 0;
500 }
501
502 int
503 agp_generic_bind_memory(device_t dev, struct agp_memory *mem,
504                         vm_offset_t offset)
505 {
506         struct agp_softc *sc = device_get_softc(dev);
507         vm_offset_t i, j, k;
508         vm_page_t m;
509         int error;
510
511         lockmgr(&sc->as_lock, LK_EXCLUSIVE);
512
513         if (mem->am_is_bound) {
514                 device_printf(dev, "memory already bound\n");
515                 lockmgr(&sc->as_lock, LK_RELEASE);
516                 return EINVAL;
517         }
518         
519         /* Do some sanity checks first. */
520         if (offset < 0
521             || (offset & (AGP_PAGE_SIZE - 1)) != 0
522             || offset + mem->am_size > AGP_GET_APERTURE(dev)) {
523                 device_printf(dev, "binding memory at bad offset %#x,%#x,%#x\n",
524                               (int) offset, (int)mem->am_size,
525                               (int)AGP_GET_APERTURE(dev));
526                 kprintf("Check BIOS's aperature size vs X\n");
527                 lockmgr(&sc->as_lock, LK_RELEASE);
528                 return EINVAL;
529         }
530
531         /*
532          * Bind the individual pages and flush the chipset's
533          * TLB.
534          */
535         for (i = 0; i < mem->am_size; i += PAGE_SIZE) {
536                 /*
537                  * Find a page from the object and wire it down. This page
538                  * will be mapped using one or more entries in the GATT
539                  * (assuming that PAGE_SIZE >= AGP_PAGE_SIZE. If this is
540                  * the first call to bind, the pages will be allocated
541                  * and zeroed.
542                  */
543                 m = vm_page_grab(mem->am_obj, OFF_TO_IDX(i),
544                                  VM_ALLOC_NORMAL | VM_ALLOC_ZERO |
545                                  VM_ALLOC_RETRY);
546                 AGP_DPF("found page pa=%#jx\n", (uintmax_t)VM_PAGE_TO_PHYS(m));
547                 vm_page_wire(m);
548
549                 /*
550                  * Install entries in the GATT, making sure that if
551                  * AGP_PAGE_SIZE < PAGE_SIZE and mem->am_size is not
552                  * aligned to PAGE_SIZE, we don't modify too many GATT 
553                  * entries.
554                  */
555                 for (j = 0; j < PAGE_SIZE && i + j < mem->am_size;
556                      j += AGP_PAGE_SIZE) {
557                         vm_offset_t pa = VM_PAGE_TO_PHYS(m) + j;
558                         AGP_DPF("binding offset %#jx to pa %#jx\n",
559                                 (uintmax_t)offset + i + j, (uintmax_t)pa);
560                         error = AGP_BIND_PAGE(dev, offset + i + j, pa);
561                         if (error) {
562                                 /*
563                                  * Bail out. Reverse all the mappings
564                                  * and unwire the pages.
565                                  */
566                                 vm_page_wakeup(m);
567                                 for (k = 0; k < i + j; k += AGP_PAGE_SIZE)
568                                         AGP_UNBIND_PAGE(dev, offset + k);
569                                 vm_object_hold(mem->am_obj);
570                                 for (k = 0; k <= i; k += PAGE_SIZE) {
571                                         m = vm_page_lookup_busy_wait(
572                                                 mem->am_obj, OFF_TO_IDX(k),
573                                                 FALSE, "agppg");
574                                         vm_page_unwire(m, 0);
575                                         vm_page_wakeup(m);
576                                 }
577                                 vm_object_drop(mem->am_obj);
578                                 lockmgr(&sc->as_lock, LK_RELEASE);
579                                 return error;
580                         }
581                 }
582                 vm_page_wakeup(m);
583         }
584
585         /*
586          * Flush the cpu cache since we are providing a new mapping
587          * for these pages.
588          */
589         agp_flush_cache();
590
591         /*
592          * Make sure the chipset gets the new mappings.
593          */
594         AGP_FLUSH_TLB(dev);
595
596         mem->am_offset = offset;
597         mem->am_is_bound = 1;
598
599         lockmgr(&sc->as_lock, LK_RELEASE);
600
601         return 0;
602 }
603
604 int
605 agp_generic_unbind_memory(device_t dev, struct agp_memory *mem)
606 {
607         struct agp_softc *sc = device_get_softc(dev);
608         vm_page_t m;
609         int i;
610
611         lockmgr(&sc->as_lock, LK_EXCLUSIVE);
612
613         if (!mem->am_is_bound) {
614                 device_printf(dev, "memory is not bound\n");
615                 lockmgr(&sc->as_lock, LK_RELEASE);
616                 return EINVAL;
617         }
618
619
620         /*
621          * Unbind the individual pages and flush the chipset's
622          * TLB. Unwire the pages so they can be swapped.
623          */
624         for (i = 0; i < mem->am_size; i += AGP_PAGE_SIZE)
625                 AGP_UNBIND_PAGE(dev, mem->am_offset + i);
626         vm_object_hold(mem->am_obj);
627         for (i = 0; i < mem->am_size; i += PAGE_SIZE) {
628                 m = vm_page_lookup_busy_wait(mem->am_obj, atop(i),
629                                              FALSE, "agppg");
630                 vm_page_unwire(m, 0);
631                 vm_page_wakeup(m);
632         }
633         vm_object_drop(mem->am_obj);
634                 
635         agp_flush_cache();
636         AGP_FLUSH_TLB(dev);
637
638         mem->am_offset = 0;
639         mem->am_is_bound = 0;
640
641         lockmgr(&sc->as_lock, LK_RELEASE);
642
643         return 0;
644 }
645
646 /* Helper functions for implementing user/kernel api */
647
648 static int
649 agp_acquire_helper(device_t dev, enum agp_acquire_state state)
650 {
651         struct agp_softc *sc = device_get_softc(dev);
652
653         if (sc->as_state != AGP_ACQUIRE_FREE)
654                 return EBUSY;
655         sc->as_state = state;
656
657         return 0;
658 }
659
660 static int
661 agp_release_helper(device_t dev, enum agp_acquire_state state)
662 {
663         struct agp_softc *sc = device_get_softc(dev);
664
665         if (sc->as_state == AGP_ACQUIRE_FREE)
666                 return 0;
667
668         if (sc->as_state != state)
669                 return EBUSY;
670
671         sc->as_state = AGP_ACQUIRE_FREE;
672         return 0;
673 }
674
675 static struct agp_memory *
676 agp_find_memory(device_t dev, int id)
677 {
678         struct agp_softc *sc = device_get_softc(dev);
679         struct agp_memory *mem;
680
681         AGP_DPF("searching for memory block %d\n", id);
682         TAILQ_FOREACH(mem, &sc->as_memory, am_link) {
683                 AGP_DPF("considering memory block %d\n", mem->am_id);
684                 if (mem->am_id == id)
685                         return mem;
686         }
687         return 0;
688 }
689
690 /* Implementation of the userland ioctl api */
691
692 static int
693 agp_info_user(device_t dev, agp_info *info)
694 {
695         struct agp_softc *sc = device_get_softc(dev);
696
697         bzero(info, sizeof *info);
698         info->bridge_id = pci_get_devid(dev);
699         info->agp_mode = 
700             pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4);
701         info->aper_base = rman_get_start(sc->as_aperture);
702         info->aper_size = AGP_GET_APERTURE(dev) >> 20;
703         info->pg_total = info->pg_system = sc->as_maxmem >> AGP_PAGE_SHIFT;
704         info->pg_used = sc->as_allocated >> AGP_PAGE_SHIFT;
705
706         return 0;
707 }
708
709 static int
710 agp_setup_user(device_t dev, agp_setup *setup)
711 {
712         return AGP_ENABLE(dev, setup->agp_mode);
713 }
714
715 static int
716 agp_allocate_user(device_t dev, agp_allocate *alloc)
717 {
718         struct agp_memory *mem;
719
720         mem = AGP_ALLOC_MEMORY(dev,
721                                alloc->type,
722                                alloc->pg_count << AGP_PAGE_SHIFT);
723         if (mem) {
724                 alloc->key = mem->am_id;
725                 alloc->physical = mem->am_physical;
726                 return 0;
727         } else {
728                 return ENOMEM;
729         }
730 }
731
732 static int
733 agp_deallocate_user(device_t dev, int id)
734 {
735         struct agp_memory *mem = agp_find_memory(dev, id);
736
737         if (mem) {
738                 AGP_FREE_MEMORY(dev, mem);
739                 return 0;
740         } else {
741                 return ENOENT;
742         }
743 }
744
745 static int
746 agp_bind_user(device_t dev, agp_bind *bind)
747 {
748         struct agp_memory *mem = agp_find_memory(dev, bind->key);
749
750         if (!mem)
751                 return ENOENT;
752
753         return AGP_BIND_MEMORY(dev, mem, bind->pg_start << AGP_PAGE_SHIFT);
754 }
755
756 static int
757 agp_unbind_user(device_t dev, agp_unbind *unbind)
758 {
759         struct agp_memory *mem = agp_find_memory(dev, unbind->key);
760
761         if (!mem)
762                 return ENOENT;
763
764         return AGP_UNBIND_MEMORY(dev, mem);
765 }
766
767 static int
768 agp_chipset_flush(device_t dev)
769 {
770
771         return (AGP_CHIPSET_FLUSH(dev));
772 }
773
774 static int
775 agp_open(struct dev_open_args *ap)
776 {
777         cdev_t kdev = ap->a_head.a_dev;
778         device_t dev = kdev->si_drv1;
779         struct agp_softc *sc = device_get_softc(dev);
780
781         if (!sc->as_isopen) {
782                 sc->as_isopen = 1;
783                 device_busy(dev);
784         }
785
786         return 0;
787 }
788
789 static int
790 agp_close(struct dev_close_args *ap)
791 {
792         cdev_t kdev = ap->a_head.a_dev;
793         device_t dev = kdev->si_drv1;
794         struct agp_softc *sc = device_get_softc(dev);
795         struct agp_memory *mem;
796
797         /*
798          * Clear the GATT and force release on last close
799          */
800         while ((mem = TAILQ_FIRST(&sc->as_memory)) != NULL) {
801                 if (mem->am_is_bound)
802                         AGP_UNBIND_MEMORY(dev, mem);
803                 AGP_FREE_MEMORY(dev, mem);
804         }
805         if (sc->as_state == AGP_ACQUIRE_USER)
806                 agp_release_helper(dev, AGP_ACQUIRE_USER);
807         if (sc->as_isopen) {
808                 sc->as_isopen = 0;
809                 device_unbusy(dev);
810         }
811
812         return 0;
813 }
814
815 static int
816 agp_ioctl(struct dev_ioctl_args *ap)
817 {
818         cdev_t kdev = ap->a_head.a_dev;
819         device_t dev = kdev->si_drv1;
820
821         switch (ap->a_cmd) {
822         case AGPIOC_INFO:
823                 return agp_info_user(dev, (agp_info *)ap->a_data);
824
825         case AGPIOC_ACQUIRE:
826                 return agp_acquire_helper(dev, AGP_ACQUIRE_USER);
827
828         case AGPIOC_RELEASE:
829                 return agp_release_helper(dev, AGP_ACQUIRE_USER);
830
831         case AGPIOC_SETUP:
832                 return agp_setup_user(dev, (agp_setup *)ap->a_data);
833
834         case AGPIOC_ALLOCATE:
835                 return agp_allocate_user(dev, (agp_allocate *)ap->a_data);
836
837         case AGPIOC_DEALLOCATE:
838                 return agp_deallocate_user(dev, *(int *)ap->a_data);
839
840         case AGPIOC_BIND:
841                 return agp_bind_user(dev, (agp_bind *)ap->a_data);
842
843         case AGPIOC_UNBIND:
844                 return agp_unbind_user(dev, (agp_unbind *)ap->a_data);
845
846         case AGPIOC_CHIPSET_FLUSH:
847                 return agp_chipset_flush(dev);
848         }
849
850         return EINVAL;
851 }
852
853 static int
854 agp_mmap(struct dev_mmap_args *ap)
855 {
856         cdev_t kdev = ap->a_head.a_dev;
857         device_t dev = kdev->si_drv1;
858         struct agp_softc *sc = device_get_softc(dev);
859
860         if (ap->a_offset > AGP_GET_APERTURE(dev))
861                 return EINVAL;
862         ap->a_result = atop(rman_get_start(sc->as_aperture) + ap->a_offset);
863         return 0;
864 }
865
866 /* Implementation of the kernel api */
867
868 device_t
869 agp_find_device(void)
870 {
871         device_t *children, child;
872         int i, count;
873
874         if (!agp_devclass)
875                 return NULL;
876         if (devclass_get_devices(agp_devclass, &children, &count) != 0)
877                 return NULL;
878         child = NULL;
879         for (i = 0; i < count; i++) {
880                 if (device_is_attached(children[i])) {
881                         child = children[i];
882                         break;
883                 }
884         }
885         kfree(children, M_TEMP);
886         return child;
887 }
888
889 enum agp_acquire_state
890 agp_state(device_t dev)
891 {
892         struct agp_softc *sc = device_get_softc(dev);
893         return sc->as_state;
894 }
895
896 void
897 agp_get_info(device_t dev, struct agp_info *info)
898 {
899         struct agp_softc *sc = device_get_softc(dev);
900
901         info->ai_mode =
902                 pci_read_config(dev, agp_find_caps(dev) + AGP_STATUS, 4);
903         info->ai_aperture_base = rman_get_start(sc->as_aperture);
904         info->ai_aperture_size = rman_get_size(sc->as_aperture);
905         info->ai_memory_allowed = sc->as_maxmem;
906         info->ai_memory_used = sc->as_allocated;
907 }
908
909 int
910 agp_acquire(device_t dev)
911 {
912         return agp_acquire_helper(dev, AGP_ACQUIRE_KERNEL);
913 }
914
915 int
916 agp_release(device_t dev)
917 {
918         return agp_release_helper(dev, AGP_ACQUIRE_KERNEL);
919 }
920
921 int
922 agp_enable(device_t dev, u_int32_t mode)
923 {
924         return AGP_ENABLE(dev, mode);
925 }
926
927 void *agp_alloc_memory(device_t dev, int type, vm_size_t bytes)
928 {
929         return  (void *) AGP_ALLOC_MEMORY(dev, type, bytes);
930 }
931
932 void agp_free_memory(device_t dev, void *handle)
933 {
934         struct agp_memory *mem = (struct agp_memory *) handle;
935         AGP_FREE_MEMORY(dev, mem);
936 }
937
938 int agp_bind_memory(device_t dev, void *handle, vm_offset_t offset)
939 {
940         struct agp_memory *mem = (struct agp_memory *) handle;
941         return AGP_BIND_MEMORY(dev, mem, offset);
942 }
943
944 int agp_unbind_memory(device_t dev, void *handle)
945 {
946         struct agp_memory *mem = (struct agp_memory *) handle;
947         return AGP_UNBIND_MEMORY(dev, mem);
948 }
949
950 void agp_memory_info(device_t dev, void *handle, struct
951                      agp_memory_info *mi)
952 {
953         struct agp_memory *mem = (struct agp_memory *) handle;
954
955         mi->ami_size = mem->am_size;
956         mi->ami_physical = mem->am_physical;
957         mi->ami_offset = mem->am_offset;
958         mi->ami_is_bound = mem->am_is_bound;
959 }