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