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