?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / sys / dev / pci / agp.c
blob0c4611954dbb35327bb9bbe7daa656363dfcb2a6
1 /* $NetBSD: agp.c,v 1.65 2009/01/27 08:39:33 markd Exp $ */
2
3 /*-
4 * Copyright (c) 2000 Doug Rabson
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: src/sys/pci/agp.c,v 1.12 2001/05/19 01:28:07 alfred Exp $
29 */
30
31 /*
32 * Copyright (c) 2001 Wasabi Systems, Inc.
33 * All rights reserved.
34 *
35 * Written by Frank van der Linden for Wasabi Systems, Inc.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. All advertising materials mentioning features or use of this software
46 * must display the following acknowledgement:
47 * This product includes software developed for the NetBSD Project by
48 * Wasabi Systems, Inc.
49 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
50 * or promote products derived from this software without specific prior
51 * written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
56 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
57 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
58 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
59 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
60 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
61 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
62 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
63 * POSSIBILITY OF SUCH DAMAGE.
64 */
65
66
67 #include <sys/cdefs.h>
68 __KERNEL_RCSID(0, "$NetBSD: agp.c,v 1.65 2009/01/27 08:39:33 markd Exp $");
69
70 #include <sys/param.h>
71 #include <sys/systm.h>
72 #include <sys/malloc.h>
73 #include <sys/kernel.h>
74 #include <sys/device.h>
75 #include <sys/conf.h>
76 #include <sys/ioctl.h>
77 #include <sys/fcntl.h>
78 #include <sys/agpio.h>
79 #include <sys/proc.h>
80 #include <sys/mutex.h>
81
82 #include <uvm/uvm_extern.h>
83
84 #include <dev/pci/pcireg.h>
85 #include <dev/pci/pcivar.h>
86 #include <dev/pci/agpvar.h>
87 #include <dev/pci/agpreg.h>
88 #include <dev/pci/pcidevs.h>
89
90 #include <sys/bus.h>
91
92 MALLOC_DEFINE(M_AGP, "AGP", "AGP memory");
93
94 /* Helper functions for implementing chipset mini drivers. */
95 /* XXXfvdl get rid of this one. */
96
97 extern struct cfdriver agp_cd;
98
99 static int agp_info_user(struct agp_softc *, agp_info *);
100 static int agp_setup_user(struct agp_softc *, agp_setup *);
101 static int agp_allocate_user(struct agp_softc *, agp_allocate *);
102 static int agp_deallocate_user(struct agp_softc *, int);
103 static int agp_bind_user(struct agp_softc *, agp_bind *);
104 static int agp_unbind_user(struct agp_softc *, agp_unbind *);
105 static int agpdev_match(struct pci_attach_args *);
106 static bool agp_resume(device_t, pmf_qual_t);
107
108 #include "agp_ali.h"
109 #include "agp_amd.h"
110 #include "agp_i810.h"
111 #include "agp_intel.h"
112 #include "agp_sis.h"
113 #include "agp_via.h"
114 #include "agp_amd64.h"
115
116 const struct agp_product {
117 uint32_t ap_vendor;
118 uint32_t ap_product;
119 int (*ap_match)(const struct pci_attach_args *);
120 int (*ap_attach)(device_t, device_t, void *);
121 } agp_products[] = {
122 #if NAGP_AMD64 > 0
123 { PCI_VENDOR_ALI, PCI_PRODUCT_ALI_M1689,
124 agp_amd64_match, agp_amd64_attach },
125 #endif
126
127 #if NAGP_ALI > 0
128 { PCI_VENDOR_ALI, -1,
129 NULL, agp_ali_attach },
130 #endif
131
132 #if NAGP_AMD64 > 0
133 { PCI_VENDOR_AMD, PCI_PRODUCT_AMD_AGP8151_DEV,
134 agp_amd64_match, agp_amd64_attach },
135 #endif
136
137 #if NAGP_AMD > 0
138 { PCI_VENDOR_AMD, -1,
139 agp_amd_match, agp_amd_attach },
140 #endif
141
142 #if NAGP_I810 > 0
143 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82810_MCH,
144 NULL, agp_i810_attach },
145 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82810_DC100_MCH,
146 NULL, agp_i810_attach },
147 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82810E_MCH,
148 NULL, agp_i810_attach },
149 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82815_FULL_HUB,
150 NULL, agp_i810_attach },
151 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82840_HB,
152 NULL, agp_i810_attach },
153 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82830MP_IO_1,
154 NULL, agp_i810_attach },
155 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82845G_DRAM,
156 NULL, agp_i810_attach },
157 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82855GM_MCH,
158 NULL, agp_i810_attach },
159 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82865_HB,
160 NULL, agp_i810_attach },
161 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82915G_HB,
162 NULL, agp_i810_attach },
163 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82915GM_HB,
164 NULL, agp_i810_attach },
165 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82945P_MCH,
166 NULL, agp_i810_attach },
167 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82945GM_HB,
168 NULL, agp_i810_attach },
169 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82945GME_HB,
170 NULL, agp_i810_attach },
171 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82965Q_HB,
172 NULL, agp_i810_attach },
173 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82965PM_HB,
174 NULL, agp_i810_attach },
175 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82965G_HB,
176 NULL, agp_i810_attach },
177 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82Q35_HB,
178 NULL, agp_i810_attach },
179 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82G33_HB,
180 NULL, agp_i810_attach },
181 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82Q33_HB,
182 NULL, agp_i810_attach },
183 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82G35_HB,
184 NULL, agp_i810_attach },
185 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82946GZ_HB,
186 NULL, agp_i810_attach },
187 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82GM45_HB,
188 NULL, agp_i810_attach },
189 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82IGD_E_HB,
190 NULL, agp_i810_attach },
191 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82Q45_HB,
192 NULL, agp_i810_attach },
193 { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_82G45_HB,
194 NULL, agp_i810_attach },
195 #endif
196
197 #if NAGP_INTEL > 0
198 { PCI_VENDOR_INTEL, -1,
199 NULL, agp_intel_attach },
200 #endif
201
202 #if NAGP_AMD64 > 0
203 { PCI_VENDOR_NVIDIA, PCI_PRODUCT_NVIDIA_NFORCE3_PCHB,
204 agp_amd64_match, agp_amd64_attach },
205 { PCI_VENDOR_NVIDIA, PCI_PRODUCT_NVIDIA_NFORCE3_250_PCHB,
206 agp_amd64_match, agp_amd64_attach },
207 #endif
208
209 #if NAGP_AMD64 > 0
210 { PCI_VENDOR_SIS, PCI_PRODUCT_SIS_755,
211 agp_amd64_match, agp_amd64_attach },
212 { PCI_VENDOR_SIS, PCI_PRODUCT_SIS_760,
213 agp_amd64_match, agp_amd64_attach },
214 #endif
215
216 #if NAGP_SIS > 0
217 { PCI_VENDOR_SIS, -1,
218 NULL, agp_sis_attach },
219 #endif
220
221 #if NAGP_AMD64 > 0
222 { PCI_VENDOR_VIATECH, PCI_PRODUCT_VIATECH_K8M800_0,
223 agp_amd64_match, agp_amd64_attach },
224 { PCI_VENDOR_VIATECH, PCI_PRODUCT_VIATECH_K8T890_0,
225 agp_amd64_match, agp_amd64_attach },
226 { PCI_VENDOR_VIATECH, PCI_PRODUCT_VIATECH_K8HTB_0,
227 agp_amd64_match, agp_amd64_attach },
228 { PCI_VENDOR_VIATECH, PCI_PRODUCT_VIATECH_K8HTB,
229 agp_amd64_match, agp_amd64_attach },
230 #endif
231
232 #if NAGP_VIA > 0
233 { PCI_VENDOR_VIATECH, -1,
234 NULL, agp_via_attach },
235 #endif
236
237 { 0, 0,
238 NULL, NULL },
239 };
240
241 static const struct agp_product *
242 agp_lookup(const struct pci_attach_args *pa)
243 {
244 const struct agp_product *ap;
245
246 /* First find the vendor. */
247 for (ap = agp_products; ap->ap_attach != NULL; ap++) {
248 if (PCI_VENDOR(pa->pa_id) == ap->ap_vendor)
249 break;
250 }
251
252 if (ap->ap_attach == NULL)
253 return (NULL);
254
255 /* Now find the product within the vendor's domain. */
256 for (; ap->ap_attach != NULL; ap++) {
257 if (PCI_VENDOR(pa->pa_id) != ap->ap_vendor) {
258 /* Ran out of this vendor's section of the table. */
259 return (NULL);
260 }
261 if (ap->ap_product == PCI_PRODUCT(pa->pa_id)) {
262 /* Exact match. */
263 break;
264 }
265 if (ap->ap_product == (uint32_t) -1) {
266 /* Wildcard match. */
267 break;
268 }
269 }
270
271 if (ap->ap_attach == NULL)
272 return (NULL);
273
274 /* Now let the product-specific driver filter the match. */
275 if (ap->ap_match != NULL && (*ap->ap_match)(pa) == 0)
276 return (NULL);
277
278 return (ap);
279 }
280
281 static int
282 agpmatch(device_t parent, cfdata_t match, void *aux)
283 {
284 struct agpbus_attach_args *apa = aux;
285 struct pci_attach_args *pa = &apa->apa_pci_args;
286
287 if (agp_lookup(pa) == NULL)
288 return (0);
289
290 return (1);
291 }
292
293 static const int agp_max[][2] = {
294 {0, 0},
295 {32, 4},
296 {64, 28},
297 {128, 96},
298 {256, 204},
299 {512, 440},
300 {1024, 942},
301 {2048, 1920},
302 {4096, 3932}
303 };
304 #define agp_max_size (sizeof(agp_max) / sizeof(agp_max[0]))
305
306 static void
307 agpattach(device_t parent, device_t self, void *aux)
308 {
309 struct agpbus_attach_args *apa = aux;
310 struct pci_attach_args *pa = &apa->apa_pci_args;
311 struct agp_softc *sc = device_private(self);
312 const struct agp_product *ap;
313 int memsize, i, ret;
314
315 ap = agp_lookup(pa);
316 KASSERT(ap != NULL);
317
318 aprint_naive(": AGP controller\n");
319
320 sc->as_dev = self;
321 sc->as_dmat = pa->pa_dmat;
322 sc->as_pc = pa->pa_pc;
323 sc->as_tag = pa->pa_tag;
324 sc->as_id = pa->pa_id;
325
326 /*
327 * Work out an upper bound for agp memory allocation. This
328 * uses a heuristic table from the Linux driver.
329 */
330 memsize = ptoa(physmem) >> 20;
331 for (i = 0; i < agp_max_size; i++) {
332 if (memsize <= agp_max[i][0])
333 break;
334 }
335 if (i == agp_max_size)
336 i = agp_max_size - 1;
337 sc->as_maxmem = agp_max[i][1] << 20U;
338
339 /*
340 * The mutex is used to prevent re-entry to
341 * agp_generic_bind_memory() since that function can sleep.
342 */
343 mutex_init(&sc->as_mtx, MUTEX_DEFAULT, IPL_NONE);
344
345 TAILQ_INIT(&sc->as_memory);
346
347 ret = (*ap->ap_attach)(parent, self, pa);
348 if (ret == 0)
349 aprint_normal(": aperture at 0x%lx, size 0x%lx\n",
350 (unsigned long)sc->as_apaddr,
351 (unsigned long)AGP_GET_APERTURE(sc));
352 else
353 sc->as_chipc = NULL;
354
355 if (!device_pmf_is_registered(self)) {
356 if (!pmf_device_register(self, NULL, agp_resume))
357 aprint_error_dev(self, "couldn't establish power "
358 "handler\n");
359 }
360 }
361
362 CFATTACH_DECL_NEW(agp, sizeof(struct agp_softc),
363 agpmatch, agpattach, NULL, NULL);
364
365 int
366 agp_map_aperture(struct pci_attach_args *pa, struct agp_softc *sc, int reg)
367 {
368 /*
369 * Find the aperture. Don't map it (yet), this would
370 * eat KVA.
371 */
372 if (pci_mapreg_info(pa->pa_pc, pa->pa_tag, reg,
373 PCI_MAPREG_TYPE_MEM, &sc->as_apaddr, &sc->as_apsize,
374 &sc->as_apflags) != 0)
375 return ENXIO;
376
377 sc->as_apt = pa->pa_memt;
378
379 return 0;
380 }
381
382 struct agp_gatt *
383 agp_alloc_gatt(struct agp_softc *sc)
384 {
385 u_int32_t apsize = AGP_GET_APERTURE(sc);
386 u_int32_t entries = apsize >> AGP_PAGE_SHIFT;
387 struct agp_gatt *gatt;
388 void *virtual;
389 int dummyseg;
390
391 gatt = malloc(sizeof(struct agp_gatt), M_AGP, M_NOWAIT);
392 if (!gatt)
393 return NULL;
394 gatt->ag_entries = entries;
395
396 if (agp_alloc_dmamem(sc->as_dmat, entries * sizeof(u_int32_t),
397 0, &gatt->ag_dmamap, &virtual, &gatt->ag_physical,
398 &gatt->ag_dmaseg, 1, &dummyseg) != 0) {
399 free(gatt, M_AGP);
400 return NULL;
401 }
402 gatt->ag_virtual = (uint32_t *)virtual;
403
404 gatt->ag_size = entries * sizeof(u_int32_t);
405 memset(gatt->ag_virtual, 0, gatt->ag_size);
406 agp_flush_cache();
407
408 return gatt;
409 }
410
411 void
412 agp_free_gatt(struct agp_softc *sc, struct agp_gatt *gatt)
413 {
414 agp_free_dmamem(sc->as_dmat, gatt->ag_size, gatt->ag_dmamap,
415 (void *)gatt->ag_virtual, &gatt->ag_dmaseg, 1);
416 free(gatt, M_AGP);
417 }
418
419
420 int
421 agp_generic_detach(struct agp_softc *sc)
422 {
423 mutex_destroy(&sc->as_mtx);
424 agp_flush_cache();
425 return 0;
426 }
427
428 static int
429 agpdev_match(struct pci_attach_args *pa)
430 {
431 if (PCI_CLASS(pa->pa_class) == PCI_CLASS_DISPLAY &&
432 PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_DISPLAY_VGA)
433 if (pci_get_capability(pa->pa_pc, pa->pa_tag, PCI_CAP_AGP,
434 NULL, NULL))
435 return 1;
436
437 return 0;
438 }
439
440 int
441 agp_generic_enable(struct agp_softc *sc, u_int32_t mode)
442 {
443 struct pci_attach_args pa;
444 pcireg_t tstatus, mstatus;
445 pcireg_t command;
446 int rq, sba, fw, rate, capoff;
447
448 if (pci_find_device(&pa, agpdev_match) == 0 ||
449 pci_get_capability(pa.pa_pc, pa.pa_tag, PCI_CAP_AGP,
450 &capoff, NULL) == 0) {
451 aprint_error_dev(sc->as_dev, "can't find display\n");
452 return ENXIO;
453 }
454
455 tstatus = pci_conf_read(sc->as_pc, sc->as_tag,
456 sc->as_capoff + AGP_STATUS);
457 mstatus = pci_conf_read(pa.pa_pc, pa.pa_tag,
458 capoff + AGP_STATUS);
459
460 /* Set RQ to the min of mode, tstatus and mstatus */
461 rq = AGP_MODE_GET_RQ(mode);
462 if (AGP_MODE_GET_RQ(tstatus) < rq)
463 rq = AGP_MODE_GET_RQ(tstatus);
464 if (AGP_MODE_GET_RQ(mstatus) < rq)
465 rq = AGP_MODE_GET_RQ(mstatus);
466
467 /* Set SBA if all three can deal with SBA */
468 sba = (AGP_MODE_GET_SBA(tstatus)
469 & AGP_MODE_GET_SBA(mstatus)
470 & AGP_MODE_GET_SBA(mode));
471
472 /* Similar for FW */
473 fw = (AGP_MODE_GET_FW(tstatus)
474 & AGP_MODE_GET_FW(mstatus)
475 & AGP_MODE_GET_FW(mode));
476
477 /* Figure out the max rate */
478 rate = (AGP_MODE_GET_RATE(tstatus)
479 & AGP_MODE_GET_RATE(mstatus)
480 & AGP_MODE_GET_RATE(mode));
481 if (rate & AGP_MODE_RATE_4x)
482 rate = AGP_MODE_RATE_4x;
483 else if (rate & AGP_MODE_RATE_2x)
484 rate = AGP_MODE_RATE_2x;
485 else
486 rate = AGP_MODE_RATE_1x;
487
488 /* Construct the new mode word and tell the hardware */
489 command = AGP_MODE_SET_RQ(0, rq);
490 command = AGP_MODE_SET_SBA(command, sba);
491 command = AGP_MODE_SET_FW(command, fw);
492 command = AGP_MODE_SET_RATE(command, rate);
493 command = AGP_MODE_SET_AGP(command, 1);
494 pci_conf_write(sc->as_pc, sc->as_tag,
495 sc->as_capoff + AGP_COMMAND, command);
496 pci_conf_write(pa.pa_pc, pa.pa_tag, capoff + AGP_COMMAND, command);
497
498 return 0;
499 }
500
501 struct agp_memory *
502 agp_generic_alloc_memory(struct agp_softc *sc, int type, vsize_t size)
503 {
504 struct agp_memory *mem;
505
506 if ((size & (AGP_PAGE_SIZE - 1)) != 0)
507 return 0;
508
509 if (sc->as_allocated + size > sc->as_maxmem)
510 return 0;
511
512 if (type != 0) {
513 printf("agp_generic_alloc_memory: unsupported type %d\n",
514 type);
515 return 0;
516 }
517
518 mem = malloc(sizeof *mem, M_AGP, M_WAITOK);
519 if (mem == NULL)
520 return NULL;
521
522 if (bus_dmamap_create(sc->as_dmat, size, size / PAGE_SIZE + 1,
523 size, 0, BUS_DMA_NOWAIT, &mem->am_dmamap) != 0) {
524 free(mem, M_AGP);
525 return NULL;
526 }
527
528 mem->am_id = sc->as_nextid++;
529 mem->am_size = size;
530 mem->am_type = 0;
531 mem->am_physical = 0;
532 mem->am_offset = 0;
533 mem->am_is_bound = 0;
534 TAILQ_INSERT_TAIL(&sc->as_memory, mem, am_link);
535 sc->as_allocated += size;
536
537 return mem;
538 }
539
540 int
541 agp_generic_free_memory(struct agp_softc *sc, struct agp_memory *mem)
542 {
543 if (mem->am_is_bound)
544 return EBUSY;
545
546 sc->as_allocated -= mem->am_size;
547 TAILQ_REMOVE(&sc->as_memory, mem, am_link);
548 bus_dmamap_destroy(sc->as_dmat, mem->am_dmamap);
549 free(mem, M_AGP);
550 return 0;
551 }
552
553 int
554 agp_generic_bind_memory(struct agp_softc *sc, struct agp_memory *mem,
555 off_t offset)
556 {
557 off_t i, k;
558 bus_size_t done, j;
559 int error;
560 bus_dma_segment_t *segs, *seg;
561 bus_addr_t pa;
562 int contigpages, nseg;
563
564 mutex_enter(&sc->as_mtx);
565
566 if (mem->am_is_bound) {
567 aprint_error_dev(sc->as_dev, "memory already bound\n");
568 mutex_exit(&sc->as_mtx);
569 return EINVAL;
570 }
571
572 if (offset < 0
573 || (offset & (AGP_PAGE_SIZE - 1)) != 0
574 || offset + mem->am_size > AGP_GET_APERTURE(sc)) {
575 aprint_error_dev(sc->as_dev,
576 "binding memory at bad offset %#lx\n",
577 (unsigned long) offset);
578 mutex_exit(&sc->as_mtx);
579 return EINVAL;
580 }
581
582 /*
583 * XXXfvdl
584 * The memory here needs to be directly accessable from the
585 * AGP video card, so it should be allocated using bus_dma.
586 * However, it need not be contiguous, since individual pages
587 * are translated using the GATT.
588 *
589 * Using a large chunk of contiguous memory may get in the way
590 * of other subsystems that may need one, so we try to be friendly
591 * and ask for allocation in chunks of a minimum of 8 pages
592 * of contiguous memory on average, falling back to 4, 2 and 1
593 * if really needed. Larger chunks are preferred, since allocating
594 * a bus_dma_segment per page would be overkill.
595 */
596
597 for (contigpages = 8; contigpages > 0; contigpages >>= 1) {
598 nseg = (mem->am_size / (contigpages * PAGE_SIZE)) + 1;
599 segs = malloc(nseg * sizeof *segs, M_AGP, M_WAITOK);
600 if (segs == NULL) {
601 mutex_exit(&sc->as_mtx);
602 return ENOMEM;
603 }
604 if (bus_dmamem_alloc(sc->as_dmat, mem->am_size, PAGE_SIZE, 0,
605 segs, nseg, &mem->am_nseg,
606 contigpages > 1 ?
607 BUS_DMA_NOWAIT : BUS_DMA_WAITOK) != 0) {
608 free(segs, M_AGP);
609 continue;
610 }
611 if (bus_dmamem_map(sc->as_dmat, segs, mem->am_nseg,
612 mem->am_size, &mem->am_virtual, BUS_DMA_WAITOK) != 0) {
613 bus_dmamem_free(sc->as_dmat, segs, mem->am_nseg);
614 free(segs, M_AGP);
615 continue;
616 }
617 if (bus_dmamap_load(sc->as_dmat, mem->am_dmamap,
618 mem->am_virtual, mem->am_size, NULL, BUS_DMA_WAITOK) != 0) {
619 bus_dmamem_unmap(sc->as_dmat, mem->am_virtual,
620 mem->am_size);
621 bus_dmamem_free(sc->as_dmat, segs, mem->am_nseg);
622 free(segs, M_AGP);
623 continue;
624 }
625 mem->am_dmaseg = segs;
626 break;
627 }
628
629 if (contigpages == 0) {
630 mutex_exit(&sc->as_mtx);
631 return ENOMEM;
632 }
633
634
635 /*
636 * Bind the individual pages and flush the chipset's
637 * TLB.
638 */
639 done = 0;
640 for (i = 0; i < mem->am_dmamap->dm_nsegs; i++) {
641 seg = &mem->am_dmamap->dm_segs[i];
642 /*
643 * Install entries in the GATT, making sure that if
644 * AGP_PAGE_SIZE < PAGE_SIZE and mem->am_size is not
645 * aligned to PAGE_SIZE, we don't modify too many GATT
646 * entries.
647 */
648 for (j = 0; j < seg->ds_len && (done + j) < mem->am_size;
649 j += AGP_PAGE_SIZE) {
650 pa = seg->ds_addr + j;
651 AGP_DPF(("binding offset %#lx to pa %#lx\n",
652 (unsigned long)(offset + done + j),
653 (unsigned long)pa));
654 error = AGP_BIND_PAGE(sc, offset + done + j, pa);
655 if (error) {
656 /*
657 * Bail out. Reverse all the mappings
658 * and unwire the pages.
659 */
660 for (k = 0; k < done + j; k += AGP_PAGE_SIZE)
661 AGP_UNBIND_PAGE(sc, offset + k);
662
663 bus_dmamap_unload(sc->as_dmat, mem->am_dmamap);
664 bus_dmamem_unmap(sc->as_dmat, mem->am_virtual,
665 mem->am_size);
666 bus_dmamem_free(sc->as_dmat, mem->am_dmaseg,
667 mem->am_nseg);
668 free(mem->am_dmaseg, M_AGP);
669 mutex_exit(&sc->as_mtx);
670 return error;
671 }
672 }
673 done += seg->ds_len;
674 }
675
676 /*
677 * Flush the CPU cache since we are providing a new mapping
678 * for these pages.
679 */
680 agp_flush_cache();
681
682 /*
683 * Make sure the chipset gets the new mappings.
684 */
685 AGP_FLUSH_TLB(sc);
686
687 mem->am_offset = offset;
688 mem->am_is_bound = 1;
689
690 mutex_exit(&sc->as_mtx);
691
692 return 0;
693 }
694
695 int
696 agp_generic_unbind_memory(struct agp_softc *sc, struct agp_memory *mem)
697 {
698 int i;
699
700 mutex_enter(&sc->as_mtx);
701
702 if (!mem->am_is_bound) {
703 aprint_error_dev(sc->as_dev, "memory is not bound\n");
704 mutex_exit(&sc->as_mtx);
705 return EINVAL;
706 }
707
708
709 /*
710 * Unbind the individual pages and flush the chipset's
711 * TLB. Unwire the pages so they can be swapped.
712 */
713 for (i = 0; i < mem->am_size; i += AGP_PAGE_SIZE)
714 AGP_UNBIND_PAGE(sc, mem->am_offset + i);
715
716 agp_flush_cache();
717 AGP_FLUSH_TLB(sc);
718
719 bus_dmamap_unload(sc->as_dmat, mem->am_dmamap);
720 bus_dmamem_unmap(sc->as_dmat, mem->am_virtual, mem->am_size);
721 bus_dmamem_free(sc->as_dmat, mem->am_dmaseg, mem->am_nseg);
722
723 free(mem->am_dmaseg, M_AGP);
724
725 mem->am_offset = 0;
726 mem->am_is_bound = 0;
727
728 mutex_exit(&sc->as_mtx);
729
730 return 0;
731 }
732
733 /* Helper functions for implementing user/kernel api */
734
735 static int
736 agp_acquire_helper(struct agp_softc *sc, enum agp_acquire_state state)
737 {
738 if (sc->as_state != AGP_ACQUIRE_FREE)
739 return EBUSY;
740 sc->as_state = state;
741
742 return 0;
743 }
744
745 static int
746 agp_release_helper(struct agp_softc *sc, enum agp_acquire_state state)
747 {
748
749 if (sc->as_state == AGP_ACQUIRE_FREE)
750 return 0;
751
752 if (sc->as_state != state)
753 return EBUSY;
754
755 sc->as_state = AGP_ACQUIRE_FREE;
756 return 0;
757 }
758
759 static struct agp_memory *
760 agp_find_memory(struct agp_softc *sc, int id)
761 {
762 struct agp_memory *mem;
763
764 AGP_DPF(("searching for memory block %d\n", id));
765 TAILQ_FOREACH(mem, &sc->as_memory, am_link) {
766 AGP_DPF(("considering memory block %d\n", mem->am_id));
767 if (mem->am_id == id)
768 return mem;
769 }
770 return 0;
771 }
772
773 /* Implementation of the userland ioctl api */
774
775 static int
776 agp_info_user(struct agp_softc *sc, agp_info *info)
777 {
778 memset(info, 0, sizeof *info);
779 info->bridge_id = sc->as_id;
780 if (sc->as_capoff != 0)
781 info->agp_mode = pci_conf_read(sc->as_pc, sc->as_tag,
782 sc->as_capoff + AGP_STATUS);
783 else
784 info->agp_mode = 0; /* i810 doesn't have real AGP */
785 info->aper_base = sc->as_apaddr;
786 info->aper_size = AGP_GET_APERTURE(sc) >> 20;
787 info->pg_total = info->pg_system = sc->as_maxmem >> AGP_PAGE_SHIFT;
788 info->pg_used = sc->as_allocated >> AGP_PAGE_SHIFT;
789
790 return 0;
791 }
792
793 static int
794 agp_setup_user(struct agp_softc *sc, agp_setup *setup)
795 {
796 return AGP_ENABLE(sc, setup->agp_mode);
797 }
798
799 static int
800 agp_allocate_user(struct agp_softc *sc, agp_allocate *alloc)
801 {
802 struct agp_memory *mem;
803
804 mem = AGP_ALLOC_MEMORY(sc,
805 alloc->type,
806 alloc->pg_count << AGP_PAGE_SHIFT);
807 if (mem) {
808 alloc->key = mem->am_id;
809 alloc->physical = mem->am_physical;
810 return 0;
811 } else {
812 return ENOMEM;
813 }
814 }
815
816 static int
817 agp_deallocate_user(struct agp_softc *sc, int id)
818 {
819 struct agp_memory *mem = agp_find_memory(sc, id);
820
821 if (mem) {
822 AGP_FREE_MEMORY(sc, mem);
823 return 0;
824 } else {
825 return ENOENT;
826 }
827 }
828
829 static int
830 agp_bind_user(struct agp_softc *sc, agp_bind *bind)
831 {
832 struct agp_memory *mem = agp_find_memory(sc, bind->key);
833
834 if (!mem)
835 return ENOENT;
836
837 return AGP_BIND_MEMORY(sc, mem, bind->pg_start << AGP_PAGE_SHIFT);
838 }
839
840 static int
841 agp_unbind_user(struct agp_softc *sc, agp_unbind *unbind)
842 {
843 struct agp_memory *mem = agp_find_memory(sc, unbind->key);
844
845 if (!mem)
846 return ENOENT;
847
848 return AGP_UNBIND_MEMORY(sc, mem);
849 }
850
851 static int
852 agpopen(dev_t dev, int oflags, int devtype, struct lwp *l)
853 {
854 struct agp_softc *sc = device_lookup_private(&agp_cd, AGPUNIT(dev));
855
856 if (sc == NULL)
857 return ENXIO;
858
859 if (sc->as_chipc == NULL)
860 return ENXIO;
861
862 if (!sc->as_isopen)
863 sc->as_isopen = 1;
864 else
865 return EBUSY;
866
867 return 0;
868 }
869
870 static int
871 agpclose(dev_t dev, int fflag, int devtype, struct lwp *l)
872 {
873 struct agp_softc *sc = device_lookup_private(&agp_cd, AGPUNIT(dev));
874 struct agp_memory *mem;
875
876 if (sc == NULL)
877 return ENODEV;
878
879 /*
880 * Clear the GATT and force release on last close
881 */
882 if (sc->as_state == AGP_ACQUIRE_USER) {
883 while ((mem = TAILQ_FIRST(&sc->as_memory))) {
884 if (mem->am_is_bound) {
885 printf("agpclose: mem %d is bound\n",
886 mem->am_id);
887 AGP_UNBIND_MEMORY(sc, mem);
888 }
889 /*
890 * XXX it is not documented, but if the protocol allows
891 * allocate->acquire->bind, it would be possible that
892 * memory ranges are allocated by the kernel here,
893 * which we shouldn't free. We'd have to keep track of
894 * the memory range's owner.
895 * The kernel API is unsed yet, so we get away with
896 * freeing all.
897 */
898 AGP_FREE_MEMORY(sc, mem);
899 }
900 agp_release_helper(sc, AGP_ACQUIRE_USER);
901 }
902 sc->as_isopen = 0;
903
904 return 0;
905 }
906
907 static int
908 agpioctl(dev_t dev, u_long cmd, void *data, int fflag, struct lwp *l)
909 {
910 struct agp_softc *sc = device_lookup_private(&agp_cd, AGPUNIT(dev));
911
912 if (sc == NULL)
913 return ENODEV;
914
915 if ((fflag & FWRITE) == 0 && cmd != AGPIOC_INFO)
916 return EPERM;
917
918 switch (cmd) {
919 case AGPIOC_INFO:
920 return agp_info_user(sc, (agp_info *) data);
921
922 case AGPIOC_ACQUIRE:
923 return agp_acquire_helper(sc, AGP_ACQUIRE_USER);
924
925 case AGPIOC_RELEASE:
926 return agp_release_helper(sc, AGP_ACQUIRE_USER);
927
928 case AGPIOC_SETUP:
929 return agp_setup_user(sc, (agp_setup *)data);
930
931 case AGPIOC_ALLOCATE:
932 return agp_allocate_user(sc, (agp_allocate *)data);
933
934 case AGPIOC_DEALLOCATE:
935 return agp_deallocate_user(sc, *(int *) data);
936
937 case AGPIOC_BIND:
938 return agp_bind_user(sc, (agp_bind *)data);
939
940 case AGPIOC_UNBIND:
941 return agp_unbind_user(sc, (agp_unbind *)data);
942
943 }
944
945 return EINVAL;
946 }
947
948 static paddr_t
949 agpmmap(dev_t dev, off_t offset, int prot)
950 {
951 struct agp_softc *sc = device_lookup_private(&agp_cd, AGPUNIT(dev));
952
953 if (sc == NULL)
954 return ENODEV;
955
956 if (offset > AGP_GET_APERTURE(sc))
957 return -1;
958
959 return (bus_space_mmap(sc->as_apt, sc->as_apaddr, offset, prot,
960 BUS_SPACE_MAP_LINEAR));
961 }
962
963 const struct cdevsw agp_cdevsw = {
964 agpopen, agpclose, noread, nowrite, agpioctl,
965 nostop, notty, nopoll, agpmmap, nokqfilter, D_OTHER
966 };
967
968 /* Implementation of the kernel api */
969
970 void *
971 agp_find_device(int unit)
972 {
973 return device_lookup_private(&agp_cd, unit);
974 }
975
976 enum agp_acquire_state
977 agp_state(void *devcookie)
978 {
979 struct agp_softc *sc = devcookie;
980
981 return sc->as_state;
982 }
983
984 void
985 agp_get_info(void *devcookie, struct agp_info *info)
986 {
987 struct agp_softc *sc = devcookie;
988
989 info->ai_mode = pci_conf_read(sc->as_pc, sc->as_tag,
990 sc->as_capoff + AGP_STATUS);
991 info->ai_aperture_base = sc->as_apaddr;
992 info->ai_aperture_size = sc->as_apsize; /* XXXfvdl inconsistent */
993 info->ai_memory_allowed = sc->as_maxmem;
994 info->ai_memory_used = sc->as_allocated;
995 }
996
997 int
998 agp_acquire(void *dev)
999 {
1000 return agp_acquire_helper(dev, AGP_ACQUIRE_KERNEL);
1001 }
1002
1003 int
1004 agp_release(void *dev)
1005 {
1006 return agp_release_helper(dev, AGP_ACQUIRE_KERNEL);
1007 }
1008
1009 int
1010 agp_enable(void *dev, u_int32_t mode)
1011 {
1012 struct agp_softc *sc = dev;
1013
1014 return AGP_ENABLE(sc, mode);
1015 }
1016
1017 void *
1018 agp_alloc_memory(void *dev, int type, vsize_t bytes)
1019 {
1020 struct agp_softc *sc = dev;
1021
1022 return (void *)AGP_ALLOC_MEMORY(sc, type, bytes);
1023 }
1024
1025 void
1026 agp_free_memory(void *dev, void *handle)
1027 {
1028 struct agp_softc *sc = dev;
1029 struct agp_memory *mem = handle;
1030
1031 AGP_FREE_MEMORY(sc, mem);
1032 }
1033
1034 int
1035 agp_bind_memory(void *dev, void *handle, off_t offset)
1036 {
1037 struct agp_softc *sc = dev;
1038 struct agp_memory *mem = handle;
1039
1040 return AGP_BIND_MEMORY(sc, mem, offset);
1041 }
1042
1043 int
1044 agp_unbind_memory(void *dev, void *handle)
1045 {
1046 struct agp_softc *sc = dev;
1047 struct agp_memory *mem = handle;
1048
1049 return AGP_UNBIND_MEMORY(sc, mem);
1050 }
1051
1052 void
1053 agp_memory_info(void *dev, void *handle, struct agp_memory_info *mi)
1054 {
1055 struct agp_memory *mem = handle;
1056
1057 mi->ami_size = mem->am_size;
1058 mi->ami_physical = mem->am_physical;
1059 mi->ami_offset = mem->am_offset;
1060 mi->ami_is_bound = mem->am_is_bound;
1061 }
1062
1063 int
1064 agp_alloc_dmamem(bus_dma_tag_t tag, size_t size, int flags,
1065 bus_dmamap_t *mapp, void **vaddr, bus_addr_t *baddr,
1066 bus_dma_segment_t *seg, int nseg, int *rseg)
1067
1068 {
1069 int error, level = 0;
1070
1071 if ((error = bus_dmamem_alloc(tag, size, PAGE_SIZE, 0,
1072 seg, nseg, rseg, BUS_DMA_NOWAIT)) != 0)
1073 goto out;
1074 level++;
1075
1076 if ((error = bus_dmamem_map(tag, seg, *rseg, size, vaddr,
1077 BUS_DMA_NOWAIT | flags)) != 0)
1078 goto out;
1079 level++;
1080
1081 if ((error = bus_dmamap_create(tag, size, *rseg, size, 0,
1082 BUS_DMA_NOWAIT, mapp)) != 0)
1083 goto out;
1084 level++;
1085
1086 if ((error = bus_dmamap_load(tag, *mapp, *vaddr, size, NULL,
1087 BUS_DMA_NOWAIT)) != 0)
1088 goto out;
1089
1090 *baddr = (*mapp)->dm_segs[0].ds_addr;
1091
1092 return 0;
1093 out:
1094 switch (level) {
1095 case 3:
1096 bus_dmamap_destroy(tag, *mapp);
1097 /* FALLTHROUGH */
1098 case 2:
1099 bus_dmamem_unmap(tag, *vaddr, size);
1100 /* FALLTHROUGH */
1101 case 1:
1102 bus_dmamem_free(tag, seg, *rseg);
1103 break;
1104 default:
1105 break;
1106 }
1107
1108 return error;
1109 }
1110
1111 void
1112 agp_free_dmamem(bus_dma_tag_t tag, size_t size, bus_dmamap_t map,
1113 void *vaddr, bus_dma_segment_t *seg, int nseg)
1114 {
1115 bus_dmamap_unload(tag, map);
1116 bus_dmamap_destroy(tag, map);
1117 bus_dmamem_unmap(tag, vaddr, size);
1118 bus_dmamem_free(tag, seg, nseg);
1119 }
1120
1121 static bool
1122 agp_resume(device_t dv, pmf_qual_t qual)
1123 {
1124 agp_flush_cache();
1125
1126 return true;
1127 }
NetBSD on the FriendlyARM MINI2440