2 * Copyright (c) 2000-2001 by Coleman Kane <cokane@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Gardner Buchanan.
16 * 4. The name of Gardner Buchanan may not be used to endorse or promote
17 * products derived from this software without specific prior written
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 /* 3dfx driver for FreeBSD 4.x - Finished 11 May 2000, 12:25AM ET
37 * Copyright (C) 2000-2001, by Coleman Kane <cokane@FreeBSD.org>,
38 * based upon the 3dfx driver written for linux, by Daryll Straus, Jon Taylor,
39 * and Jens Axboe, located at http://linux.3dfx.com.
42 #include <sys/param.h>
46 #include <sys/fcntl.h>
48 #include <sys/filedesc.h>
49 #include <sys/filio.h>
50 #include <sys/ioccom.h>
51 #include <sys/kernel.h>
52 #include <sys/module.h>
53 #include <sys/malloc.h>
55 #include <sys/signalvar.h>
56 #include <sys/systm.h>
59 #include <dev/pci/pcivar.h>
60 #include <dev/pci/pcireg.h>
63 #include <vm/vm_kern.h>
65 #include <vm/vm_extern.h>
67 /* rman.h depends on machine/bus.h */
68 #include <machine/resource.h>
69 #include <machine/bus.h>
72 #include <dev/tdfx/tdfx_io.h>
73 #include <dev/tdfx/tdfx_vars.h>
74 #include <dev/tdfx/tdfx_pci.h>
77 static devclass_t tdfx_devclass;
80 static int tdfx_count = 0;
83 /* Set up the boot probe/attach routines */
84 static device_method_t tdfx_methods[] = {
85 DEVMETHOD(device_probe, tdfx_probe),
86 DEVMETHOD(device_attach, tdfx_attach),
87 DEVMETHOD(device_detach, tdfx_detach),
88 DEVMETHOD(device_shutdown, tdfx_shutdown),
92 static MALLOC_DEFINE(M_TDFX,"tdfx_driver","3DFX Graphics[/2D]/3D Accelerators");
94 /* Char. Dev. file operations structure */
95 static struct cdevsw tdfx_cdev = {
96 .d_version = D_VERSION,
97 .d_flags = D_NEEDGIANT,
99 .d_close = tdfx_close,
100 .d_ioctl = tdfx_ioctl,
106 tdfx_probe(device_t dev)
109 * probe routine called on kernel boot to register supported devices. We get
110 * a device structure to work with, and we can test the VENDOR/DEVICE IDs to
111 * see if this PCI device is one that we support. Return BUS_PRROBE_DEFAULT
112 * if yes, ENXIO if not.
114 switch(pci_get_devid(dev)) {
115 case PCI_DEVICE_ALLIANCE_AT3D:
116 device_set_desc(dev, "ProMotion At3D 3D Accelerator");
117 return BUS_PROBE_DEFAULT;
118 case PCI_DEVICE_3DFX_VOODOO2:
119 device_set_desc(dev, "3DFX Voodoo II 3D Accelerator");
120 return BUS_PROBE_DEFAULT;
121 /*case PCI_DEVICE_3DFX_BANSHEE:
122 device_set_desc(dev, "3DFX Voodoo Banshee 2D/3D Graphics Accelerator");
123 return BUS_PROBE_DEFAULT;
124 case PCI_DEVICE_3DFX_VOODOO3:
125 device_set_desc(dev, "3DFX Voodoo3 2D/3D Graphics Accelerator");
126 return BUS_PROBE_DEFAULT;*/
127 case PCI_DEVICE_3DFX_VOODOO1:
128 device_set_desc(dev, "3DFX Voodoo Graphics 3D Accelerator");
129 return BUS_PROBE_DEFAULT;
136 tdfx_attach(device_t dev) {
138 * The attach routine is called after the probe routine successfully says it
139 * supports a given card. We now proceed to initialize this card for use with
140 * the system. I want to map the device memory for userland allocation and
141 * fill an information structure with information on this card. I'd also like
142 * to set Write Combining with the MTRR code so that we can hopefully speed
143 * up memory writes. The last thing is to register the character device
144 * interface to the card, so we can open it from /dev/3dfxN, where N is a
145 * small, whole number.
147 struct tdfx_softc *tdfx_info;
148 /* rid value tells bus_alloc_resource where to find the addresses of ports or
149 * of memory ranges in the PCI config space*/
150 int rid = PCIR_BAR(0);
152 /* Increment the card counter (for the ioctl code) */
155 /* Fill the soft config struct with info about this device*/
156 tdfx_info = device_get_softc(dev);
157 tdfx_info->dev = dev;
158 tdfx_info->vendor = pci_get_vendor(dev);
159 tdfx_info->type = pci_get_devid(dev) >> 16;
160 tdfx_info->bus = pci_get_bus(dev);
161 tdfx_info->dv = pci_get_slot(dev);
162 tdfx_info->curFile = NULL;
165 * Get the Memory Location from the PCI Config, mask out lower word, since
166 * the config space register is only one word long (this is nicer than a
169 tdfx_info->addr0 = (pci_read_config(dev, 0x10, 4) & 0xffff0000);
171 device_printf(dev, "Base0 @ 0x%x\n", tdfx_info->addr0);
173 /* Notify the VM that we will be mapping some memory later */
174 tdfx_info->memrange = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
175 &rid, RF_ACTIVE | RF_SHAREABLE);
176 if(tdfx_info->memrange == NULL) {
178 device_printf(dev, "Error mapping mem, won't be able to use mmap()\n");
180 tdfx_info->memrid = 0;
183 tdfx_info->memrid = rid;
185 device_printf(dev, "Mapped to: 0x%x\n",
186 (unsigned int)rman_get_start(tdfx_info->memrange));
190 /* Setup for Voodoo3 and Banshee, PIO and an extram Memrange */
191 if(pci_get_devid(dev) == PCI_DEVICE_3DFX_VOODOO3 ||
192 pci_get_devid(dev) == PCI_DEVICE_3DFX_BANSHEE) {
193 rid = 0x14; /* 2nd mem map */
194 tdfx_info->addr1 = (pci_read_config(dev, 0x14, 4) & 0xffff0000);
196 device_printf(dev, "Base1 @ 0x%x\n", tdfx_info->addr1);
198 tdfx_info->memrange2 = bus_alloc_resource_any(dev,
199 SYS_RES_MEMORY, &rid, RF_ACTIVE | RF_SHAREABLE);
200 if(tdfx_info->memrange2 == NULL) {
202 device_printf(dev, "Mem1 couldn't be allocated, glide may not work.");
204 tdfx_info->memrid2 = 0;
207 tdfx_info->memrid2 = rid;
209 /* Now to map the PIO stuff */
210 rid = PCIR_IOBASE0_2;
211 tdfx_info->pio0 = pci_read_config(dev, 0x2c, 2);
212 tdfx_info->pio0max = pci_read_config(dev, 0x30, 2) + tdfx_info->pio0;
213 tdfx_info->piorange = bus_alloc_resource_any(dev,
214 SYS_RES_IOPORT, &rid, RF_ACTIVE | RF_SHAREABLE);
215 if(tdfx_info->piorange == NULL) {
217 device_printf(dev, "Couldn't map PIO range.");
219 tdfx_info->piorid = 0;
222 tdfx_info->piorid = rid;
225 tdfx_info->addr1 = 0;
226 tdfx_info->memrange2 = NULL;
227 tdfx_info->piorange = NULL;
231 * Set Writecombining, or at least Uncacheable for the memory region, if we
235 if(tdfx_setmtrr(dev) != 0) {
237 device_printf(dev, "Some weird error setting MTRRs");
243 * make_dev registers the cdev to access the 3dfx card from /dev
244 * use hex here for the dev num, simply to provide better support if > 10
245 * voodoo cards, for the mad. The user must set the link.
246 * Why would we want that many voodoo cards anyhow?
248 tdfx_info->devt = make_dev(&tdfx_cdev, device_get_unit(dev),
249 UID_ROOT, GID_WHEEL, 0600, "3dfx%x", device_get_unit(dev));
250 tdfx_info->devt->si_drv1 = tdfx_info;
256 tdfx_detach(device_t dev) {
257 struct tdfx_softc* tdfx_info;
259 tdfx_info = device_get_softc(dev);
261 /* Delete allocated resource, of course */
262 bus_release_resource(dev, SYS_RES_MEMORY, tdfx_info->memrid,
263 tdfx_info->memrange);
265 /* Release extended Voodoo3/Banshee resources */
266 if(pci_get_devid(dev) == PCI_DEVICE_3DFX_BANSHEE ||
267 pci_get_devid(dev) == PCI_DEVICE_3DFX_VOODOO3) {
268 if(tdfx_info->memrange2 != NULL)
269 bus_release_resource(dev, SYS_RES_MEMORY, tdfx_info->memrid2,
270 tdfx_info->memrange);
271 /* if(tdfx_info->piorange != NULL)
272 bus_release_resource(dev, SYS_RES_IOPORT, tdfx_info->piorid,
273 tdfx_info->piorange);*/
276 /* Though it is safe to leave the WRCOMB support since the
277 mem driver checks for it, we should remove it in order
278 to free an MTRR for another device */
279 retval = tdfx_clrmtrr(dev);
282 printf("tdfx: For some reason, I couldn't clear the mtrr\n");
284 /* Remove device entry when it can no longer be accessed */
285 destroy_dev(tdfx_info->devt);
290 tdfx_shutdown(device_t dev) {
292 device_printf(dev, "tdfx: Device Shutdown\n");
298 tdfx_clrmtrr(device_t dev) {
299 /* This function removes the MTRR set by the attach call, so it can be used
300 * in the future by other drivers.
303 struct tdfx_softc *tdfx_info = device_get_softc(dev);
305 act = MEMRANGE_SET_REMOVE;
306 retval = mem_range_attr_set(&tdfx_info->mrdesc, &act);
311 tdfx_setmtrr(device_t dev) {
313 * This is the MTRR setting function for the 3dfx card. It is called from
314 * tdfx_attach. If we can't set the MTRR properly, it's not the end of the
315 * world. We can still continue, just with slightly (very slightly) degraded
319 struct tdfx_softc *tdfx_info = device_get_softc(dev);
321 /* The older Voodoo cards have a shorter memrange than the newer ones */
322 if((pci_get_devid(dev) == PCI_DEVICE_3DFX_VOODOO1) || (pci_get_devid(dev) ==
323 PCI_DEVICE_3DFX_VOODOO2)) {
324 tdfx_info->mrdesc.mr_len = 0x400000;
326 /* The memory descriptor is described as the top 15 bits of the real
328 tdfx_info->mrdesc.mr_base = tdfx_info->addr0 & 0xfffe0000;
330 else if((pci_get_devid(dev) == PCI_DEVICE_3DFX_VOODOO3) ||
331 (pci_get_devid(dev) == PCI_DEVICE_3DFX_BANSHEE)) {
332 tdfx_info->mrdesc.mr_len = 0x1000000;
333 /* The Voodoo3 and Banshee LFB is the second memory address */
334 /* The memory descriptor is described as the top 15 bits of the real
336 tdfx_info->mrdesc.mr_base = tdfx_info->addr1 & 0xfffe0000;
341 * The Alliance Pro Motion AT3D was not mentioned in the linux
342 * driver as far as MTRR support goes, so I just won't put the
343 * code in here for it. This is where it should go, though.
346 /* Firstly, try to set write combining */
347 tdfx_info->mrdesc.mr_flags = MDF_WRITECOMBINE;
348 bcopy("tdfx", &tdfx_info->mrdesc.mr_owner, 4);
349 act = MEMRANGE_SET_UPDATE;
350 retval = mem_range_attr_set(&tdfx_info->mrdesc, &act);
354 device_printf(dev, "MTRR Set Correctly for tdfx\n");
356 } else if((pci_get_devid(dev) == PCI_DEVICE_3DFX_VOODOO2) ||
357 (pci_get_devid(dev) == PCI_DEVICE_3DFX_VOODOO1)) {
358 /* if, for some reason we can't set the WRCOMB range with the V1/V2, we
359 * can still possibly use the UNCACHEABLE region for it instead, and help
360 * out in a small way */
361 tdfx_info->mrdesc.mr_flags = MDF_UNCACHEABLE;
362 /* This length of 1000h was taken from the linux device driver... */
363 tdfx_info->mrdesc.mr_len = 0x1000;
366 * If, for some reason, we can't set the MTRR (N/A?) we may still continue
369 device_printf(dev, "MTRR Set Type Uncacheable %x\n",
370 (u_int32_t)tdfx_info->mrdesc.mr_base);
375 device_printf(dev, "Couldn't Set MTRR\n");
383 tdfx_open(struct cdev *dev, int flags, int fmt, struct thread *td)
386 * The open cdev method handles open(2) calls to /dev/3dfx[n]
387 * We can pretty much allow any opening of the device.
389 struct tdfx_softc *tdfx_info = dev->si_drv1;
390 if(tdfx_info->busy != 0) return EBUSY;
392 printf("3dfx: Opened by #%d\n", td->td_proc->p_pid);
394 /* Set the driver as busy */
400 tdfx_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
403 * The close cdev method handles close(2) calls to /dev/3dfx[n]
404 * We'll always want to close the device when it's called.
406 struct tdfx_softc *tdfx_info = dev->si_drv1;
407 if(tdfx_info->busy == 0) return EBADF;
410 printf("Closed by #%d\n", td->td_proc->p_pid);
416 tdfx_mmap(struct cdev *dev, vm_ooffset_t offset, vm_paddr_t *paddr,
417 int nprot, vm_memattr_t *memattr)
420 * mmap(2) is called by a user process to request that an area of memory
421 * associated with this device be mapped for the process to work with. Nprot
422 * holds the protections requested, PROT_READ, PROT_WRITE, or both.
425 /**** OLD GET CONFIG ****/
426 /* struct tdfx_softc* tdfx_info; */
428 /* Get the configuration for our card XXX*/
429 /*tdfx_info = dev->si_drv1; */
430 /************************/
432 struct tdfx_softc* tdfx_info[2];
434 tdfx_info[0] = (struct tdfx_softc*)devclass_get_softc(tdfx_devclass, 0);
436 /* If, for some reason, its not configured, we bail out */
437 if(tdfx_info[0] == NULL) {
439 printf("tdfx: tdfx_info (softc) is NULL\n");
444 /* We must stay within the bound of our address space */
445 if((offset & 0xff000000) == tdfx_info[0]->addr0) {
447 *paddr = rman_get_start(tdfx_info[0]->memrange) + offset;
452 tdfx_info[1] = (struct tdfx_softc*)devclass_get_softc(tdfx_devclass, 1);
453 if((offset & 0xff000000) == tdfx_info[1]->addr0) {
455 *paddr = rman_get_start(tdfx_info[1]->memrange) +
461 /* See if the Banshee/V3 LFB is being requested */
462 /*if(tdfx_info->memrange2 != NULL && (offset & 0xff000000) ==
465 return atop(rman_get_start(tdfx_info[1]->memrange2) + offset);
466 }*/ /* VoodooNG code */
469 /* atop -> address to page
470 * rman_get_start, get the (struct resource*)->r_start member,
471 * the mapping base address.
477 tdfx_query_boards(void) {
479 * This returns the number of installed tdfx cards, we have been keeping
480 * count, look at tdfx_attach
486 tdfx_query_fetch(u_int cmd, struct tdfx_pio_data *piod)
488 /* XXX Comment this later, after careful inspection and spring cleaning :) */
489 /* Various return values 8bit-32bit */
493 struct tdfx_softc* tdfx_info = NULL;
495 /* This one depend on the tdfx_* structs being properly initialized */
497 /*piod->device &= 0xf;*/
498 if((piod == NULL) ||(tdfx_count <= piod->device) ||
499 (piod->device < 0)) {
501 printf("tdfx: Bad device or internal struct in tdfx_query_fetch\n");
506 tdfx_info = (struct tdfx_softc*)devclass_get_softc(tdfx_devclass,
509 if(tdfx_info == NULL) return -ENXIO;
511 /* We must restrict the size reads from the port, since to high or low of a
512 * size witll result in wrong data being passed, and that's bad */
513 /* A few of these were pulled during the attach phase */
515 case PCI_VENDOR_ID_FREEBSD:
516 if(piod->size != 2) return -EINVAL;
517 copyout(&tdfx_info->vendor, piod->value, piod->size);
519 case PCI_DEVICE_ID_FREEBSD:
520 if(piod->size != 2) return -EINVAL;
521 copyout(&tdfx_info->type, piod->value, piod->size);
523 case PCI_BASE_ADDRESS_0_FREEBSD:
524 if(piod->size != 4) return -EINVAL;
525 copyout(&tdfx_info->addr0, piod->value, piod->size);
527 case PCI_BASE_ADDRESS_1_FREEBSD:
528 if(piod->size != 4) return -EINVAL;
529 copyout(&tdfx_info->addr1, piod->value, piod->size);
531 case PCI_PRIBUS_FREEBSD:
532 if(piod->size != 1) return -EINVAL;
534 case PCI_IOBASE_0_FREEBSD:
535 if(piod->size != 2) return -EINVAL;
537 case PCI_IOLIMIT_0_FREEBSD:
538 if(piod->size != 2) return -EINVAL;
540 case SST1_PCI_SPECIAL1_FREEBSD:
541 if(piod->size != 4) return -EINVAL;
543 case PCI_REVISION_ID_FREEBSD:
544 if(piod->size != 1) return -EINVAL;
546 case SST1_PCI_SPECIAL4_FREEBSD:
547 if(piod->size != 4) return -EINVAL;
554 /* Read the value and return */
557 ret_byte = pci_read_config(tdfx_info[piod->device].dev,
559 copyout(&ret_byte, piod->value, 1);
562 ret_word = pci_read_config(tdfx_info[piod->device].dev,
564 copyout(&ret_word, piod->value, 2);
567 ret_dword = pci_read_config(tdfx_info[piod->device].dev,
569 copyout(&ret_dword, piod->value, 4);
578 tdfx_query_update(u_int cmd, struct tdfx_pio_data *piod)
580 /* XXX Comment this later, after careful inspection and spring cleaning :) */
586 /* Port vals, mask */
587 u_int32_t retval, preval, mask;
588 struct tdfx_softc* tdfx_info = NULL;
591 if((piod == NULL) || (piod->device >= (tdfx_count &
594 printf("tdfx: Bad struct or device in tdfx_query_update\n");
599 tdfx_info = (struct tdfx_softc*)devclass_get_softc(tdfx_devclass,
601 if(tdfx_info == NULL) return -ENXIO;
602 /* Code below this line in the fuction was taken from the
603 * Linux driver and converted for freebsd. */
605 /* Check the size for all the ports, to make sure stuff doesn't get messed up
606 * by poorly written clients */
609 case PCI_COMMAND_FREEBSD:
610 if(piod->size != 2) return -EINVAL;
612 case SST1_PCI_SPECIAL1_FREEBSD:
613 if(piod->size != 4) return -EINVAL;
615 case SST1_PCI_SPECIAL2_FREEBSD:
616 if(piod->size != 4) return -EINVAL;
618 case SST1_PCI_SPECIAL3_FREEBSD:
619 if(piod->size != 4) return -EINVAL;
621 case SST1_PCI_SPECIAL4_FREEBSD:
622 if(piod->size != 4) return -EINVAL;
627 /* Read the current value */
628 retval = pci_read_config(tdfx_info->dev, piod->port & ~3, 4);
630 /* These set up a mask to use, since apparently they wanted to write 4 bytes
631 * at once to the ports */
632 switch (piod->size) {
634 copyin(piod->value, &ret_byte, 1);
635 preval = ret_byte << (8 * (piod->port & 0x3));
636 mask = 0xff << (8 * (piod->port & 0x3));
639 copyin(piod->value, &ret_word, 2);
640 preval = ret_word << (8 * (piod->port & 0x3));
641 mask = 0xffff << (8 * (piod->port & 0x3));
644 copyin(piod->value, &ret_dword, 4);
651 /* Finally, combine the values and write it to the port */
652 retval = (retval & ~mask) | preval;
653 pci_write_config(tdfx_info->dev, piod->port & ~3, retval, 4);
658 /* For both of these, I added a variable named workport of type u_int so
659 * that I could eliminate the warning about my data type size. The
660 * applications expect the port to be of type short, so I needed to change
661 * this within the function */
663 tdfx_do_pio_rd(struct tdfx_pio_data *piod)
668 struct tdfx_softc *tdfx_info =
669 (struct tdfx_softc*)devclass_get_softc(tdfx_devclass, piod->device);
671 /* Restricts the access of ports other than those we use */
672 if(((piod->port != VGA_INPUT_STATUS_1C) || (piod->port != SC_INDEX) ||
673 (piod->port != SC_DATA) || (piod->port != VGA_MISC_OUTPUT_READ)) &&
674 (piod->port < tdfx_info->pio0) && (piod->port > tdfx_info->pio0max))
677 /* All VGA STATUS REGS are byte registers, size should never be > 1 */
678 if(piod->size != 1) {
682 /* Write the data to the intended port */
683 workport = piod->port;
684 ret_byte = inb(workport);
685 copyout(&ret_byte, piod->value, sizeof(u_int8_t));
690 tdfx_do_pio_wt(struct tdfx_pio_data *piod)
695 struct tdfx_softc *tdfx_info = (struct
696 tdfx_softc*)devclass_get_softc(tdfx_devclass, piod->device);
697 /* Replace old switch w/ massive if(...) */
698 /* Restricts the access of ports other than those we use */
699 if(((piod->port != SC_INDEX) && (piod->port != SC_DATA) &&
700 (piod->port != VGA_MISC_OUTPUT_READ)) /* Can't write VGA_ST_1C */ &&
701 (piod->port < tdfx_info->pio0) && (piod->port > tdfx_info->pio0max))
704 /* All VGA STATUS REGS are byte registers, size should never be > 1 */
705 if(piod->size != 1) {
709 /* Write the data to the intended port */
710 copyin(piod->value, &ret_byte, sizeof(u_int8_t));
711 workport = piod->port;
712 outb(workport, ret_byte);
717 tdfx_do_query(u_int cmd, struct tdfx_pio_data *piod)
719 /* There are three sub-commands to the query 0x33 */
720 switch(_IOC_NR(cmd)) {
722 return tdfx_query_boards();
725 return tdfx_query_fetch(cmd, piod);
728 return tdfx_query_update(cmd, piod);
731 /* In case we are thrown a bogus sub-command! */
733 printf("Bad Sub-cmd: 0x%x\n", _IOC_NR(cmd));
740 tdfx_do_pio(u_int cmd, struct tdfx_pio_data *piod)
742 /* Two types of PIO, INPUT and OUTPUT, as the name suggests */
743 switch(_IOC_DIR(cmd)) {
745 return tdfx_do_pio_rd(piod);
748 return tdfx_do_pio_wt(piod);
755 /* Calls to ioctl(2) eventually end up here. Unhandled ioctls return an ENXIO,
756 * normally, you would read in the data pointed to by data, then write your
757 * output to it. The ioctl *should* normally return zero if everything is
758 * alright, but 3dfx didn't make it that way...
760 * For all of the ioctl code, in the event of a real error,
761 * we return -Exxxx rather than simply Exxxx. The reason for this
762 * is that the ioctls actually RET information back to the program
763 * sometimes, rather than filling it in the passed structure. We
764 * want to distinguish errors from useful data, and maintain compatibility.
766 * There is this portion of the proc struct called p_retval[], we can store a
767 * return value in td->td_retval[0] and place the return value if it is positive
768 * in there, then we can return 0 (good). If the return value is negative, we
769 * can return -retval and the error should be properly handled.
772 tdfx_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td)
775 struct tdfx_pio_data *piod = (struct tdfx_pio_data*)data;
777 printf("IOCTL'd by #%d, cmd: 0x%x, data: %p\n", td->td_proc->p_pid, (u_int32_t)cmd,
780 switch(_IOC_TYPE(cmd)) {
781 /* Return the real error if negative, or simply stick the valid return
782 * in td->td_retval */
784 /* The '3'(0x33) type IOCTL is for querying the installed cards */
785 if((retval = tdfx_do_query(cmd, piod)) > 0) td->td_retval[0] = retval;
789 /* The 0 type IOCTL is for programmed I/O methods */
790 if((tdfx_do_pio(cmd, piod)) > 0) td->td_retval[0] = retval;
794 /* Technically, we won't reach this from linux emu, but when glide
795 * finally gets ported, watch out! */
797 printf("Bad IOCTL from #%d\n", td->td_proc->p_pid);
805 /* This is the device driver struct. This is sent to the driver subsystem to
806 * register the method structure and the info strcut space for this particular
807 * instance of the driver.
809 static driver_t tdfx_driver = {
812 sizeof(struct tdfx_softc),
815 /* Tell Mr. Kernel about us! */
816 DRIVER_MODULE(tdfx, pci, tdfx_driver, tdfx_devclass, 0, 0);
817 MODULE_DEPEND(tdfx, mem, 1, 1, 1);
818 MODULE_VERSION(tdfx, 1);