Style(9) cleanup to src/sys/vfs, stage 20/21: umapfs.
[dragonfly.git] / sys / dev / video / tga / tga_pci.c
1 /*
2  * Copyright (c) 1995, 1996 Carnegie-Mellon University.
3  * All rights reserved.
4  *
5  * Author: Chris G. Demetriou
6  * 
7  * Permission to use, copy, modify and distribute this software and
8  * its documentation is hereby granted, provided that both the copyright
9  * notice and this permission notice appear in all copies of the
10  * software, derivative works or modified versions, and any portions
11  * thereof, and that both notices appear in supporting documentation.
12  * 
13  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 
14  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 
15  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
16  * 
17  * Carnegie Mellon requests users of this software to return to
18  *
19  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
20  *  School of Computer Science
21  *  Carnegie Mellon University
22  *  Pittsburgh PA 15213-3890
23  *
24  * any improvements or extensions that they make and grant Carnegie the
25  * rights to redistribute these changes.
26  *
27  * Copyright (c) 2000 Andrew Miklic, Andrew Gallatin, and Thomas V. Crimi
28  *
29  * $FreeBSD: src/sys/dev/tga/tga_pci.c,v 1.1.2.1 2001/11/01 08:33:15 obrien Exp $
30  * $DragonFly: src/sys/dev/video/tga/Attic/tga_pci.c,v 1.6 2004/05/13 23:49:23 dillon Exp $
31  */
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/conf.h>
37 #include <sys/proc.h>
38 #include <sys/fcntl.h>
39 #include <sys/malloc.h>
40 #include <sys/fbio.h>
41
42 #include <vm/vm.h>
43 #include <vm/vm_param.h>
44 #include <vm/pmap.h>
45
46 #include <machine/md_var.h>
47 #include <machine/pc/bios.h>
48 #include <machine/clock.h>
49 #include <machine/bus_memio.h>
50 #include <machine/bus.h>
51 #include <machine/pc/vesa.h>
52 #include <machine/resource.h>
53
54 #include <sys/bus.h>
55 #include <sys/rman.h>
56
57 #include <bus/pci/pcireg.h>
58 #include <bus/pci/pcivar.h>
59
60 #include <dev/fb/fbreg.h>
61 #include <dev/fb/tga.h>
62 #include "tga_pci.h"
63 #include <dev/fb/gfb.h>
64 #include <dev/gfb/gfb_pci.h>
65
66 #include "opt_fb.h"
67
68 static int tga_probe(device_t);
69 static int tga_attach(device_t);
70 static void tga_intr(void *);
71
72 static device_method_t tga_methods[] = {
73         DEVMETHOD(device_probe, tga_probe),
74         DEVMETHOD(device_attach, tga_attach),
75         DEVMETHOD(device_detach, pcigfb_detach),
76         { 0, 0 }
77 };
78
79 static driver_t tga_driver = {
80         "tga",
81         tga_methods,
82         sizeof(struct gfb_softc)
83 };
84
85 static devclass_t tga_devclass;
86
87 DRIVER_MODULE(tga, pci, tga_driver, tga_devclass, 0, 0);
88
89 static struct gfb_type tga_devs[] = {
90         { DEC_VENDORID, DEC_DEVICEID_TGA,
91         "DEC TGA (21030) 2D Graphics Accelerator" },
92         { DEC_VENDORID, DEC_DEVICEID_TGA2,
93         "DEC TGA2 (21130) 3D Graphics Accelerator" },
94         { 0, 0, NULL }
95 };
96
97 #ifdef FB_INSTALL_CDEV
98
99 static struct cdevsw tga_cdevsw = {
100         /* name */      "tga",
101         /* maj */       -1,
102         /* flags */     0,
103         /* port */      NULL,
104         /* clone */     NULL,
105
106         /* open */      pcigfb_open,
107         /* close */     pcigfb_close,
108         /* read */      pcigfb_read,
109         /* write */     pcigfb_write,
110         /* ioctl */     pcigfb_ioctl,
111         /* poll */      nopoll,
112         /* mmap */      pcigfb_mmap,
113         /* strategy */  nostrategy,
114         /* dump */      nodump,
115         /* psize */     nopsize
116 };
117
118 #endif /*FB_INSTALL_CDEV*/
119
120 static int
121 tga_probe(device_t dev)
122 {
123         int error;
124         gfb_type_t t;
125
126         t = tga_devs;
127         error = ENXIO;
128         while(t->name != NULL) {
129                 if((pci_get_vendor(dev) == t->vendor_id) &&
130                    (pci_get_device(dev) == t->device_id)) {
131                         device_set_desc(dev, t->name);
132                         error = 0;
133                         break;
134                 }
135                 t++;
136         }
137         return(error);
138 }
139
140 static int
141 tga_attach(device_t dev)
142 {
143         gfb_softc_t sc;
144         int unit, error, rid;
145
146         error = 0;
147         unit = device_get_unit(dev);
148         sc = device_get_softc(dev);
149         bzero(sc, sizeof(struct gfb_softc));
150         sc->driver_name = TGA_DRIVER_NAME;
151         switch(pci_get_device(dev)) {
152         case DEC_DEVICEID_TGA2:
153                 sc->model = 1;
154                 sc->type = KD_TGA2;
155                 break;
156         case DEC_DEVICEID_TGA:
157                 sc->model = 0;
158                 sc->type = KD_TGA;
159                 break;
160         default:
161                 device_printf(dev, "Unrecognized TGA type\n");
162                 goto fail;
163         }
164         if((error = pcigfb_attach(dev))) {
165                 goto fail;
166         }
167         sc->regs = sc->bhandle + TGA_MEM_CREGS;
168         error = bus_setup_intr(dev, sc->irq, INTR_TYPE_TTY, tga_intr, sc,
169                     &sc->intrhand);
170         if(error) {
171                 device_printf(dev, "couldn't set up irq\n");
172                 goto fail;
173         }
174         switch(sc->rev) {
175         case 0x1:
176         case 0x2:
177         case 0x3:
178                 device_printf(dev, "TGA (21030) step %c\n", 'A' + sc->rev - 1);
179                 break;
180
181         case 0x20:
182                 device_printf(dev, "TGA2 (21130) abstract software model\n");
183                 break;
184
185         case 0x21:
186         case 0x22:
187                 device_printf(dev, "TGA2 (21130) pass %d\n", sc->rev - 0x20);
188                 break;
189
190         default:
191                 device_printf(dev, "Unknown stepping (0x%x)\n", sc->rev);
192                 break;
193         }
194 #ifdef FB_INSTALL_CDEV
195         sc->devt = make_dev(&tga_cdevsw, unit, 0, 0, 02660, "tga%x", unit);
196         /* XXX fb_attach done too early in pcigfb_attach? */
197 #endif /*FB_INSTALL_CDEV*/
198         goto done;
199 fail:
200         if(sc->intrhand != NULL) {
201                 bus_teardown_intr(dev, sc->irq, sc->intrhand);
202                 sc->intrhand = NULL;
203         }
204         if(sc->irq != NULL) {
205                 rid = 0x0;
206                 bus_release_resource(dev, SYS_RES_IRQ, rid, sc->irq);
207                 sc->irq = NULL;
208         }
209         if(sc->res != NULL) {
210                 rid = GFB_MEM_BASE_RID;
211                 bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->res);
212                 sc->res = NULL;
213         }
214         error = ENXIO;
215 done:
216         return(error);
217 }
218
219 static void 
220 tga_intr(void *v)
221 {
222         struct gfb_softc *sc = (struct gfb_softc *)v;
223         u_int32_t reg;
224
225         reg = READ_GFB_REGISTER(sc->adp, TGA_REG_SISR);
226         if((reg & 0x00010001) != 0x00010001) {
227
228                 /* Odd. We never set any of the other interrupt enables. */
229                 if((reg & 0x1f) != 0) {
230
231                         /* Clear the mysterious pending interrupts. */
232                         WRITE_GFB_REGISTER(sc->adp, TGA_REG_SISR, (reg & 0x1f));
233                         GFB_REGISTER_WRITE_BARRIER(sc, TGA_REG_SISR, 1);
234
235                         /* This was our interrupt, even if we're puzzled as to
236                          * why we got it.  Don't make the interrupt handler
237                          * think it was a stray.
238                          */
239                 }
240         }
241
242         /* Call the scheduled handler... */
243         sc->gfbc->ramdac_intr(sc);
244
245         /*
246            Clear interrupt field (this way, we will force a
247            memory error if we get an unexpected interrupt)...
248         */
249         sc->gfbc->ramdac_intr = NULL;
250
251         /* Disable the interrupt... */
252         WRITE_GFB_REGISTER(sc->adp, TGA_REG_SISR, 0x00000001);
253         GFB_REGISTER_WRITE_BARRIER(sc, TGA_REG_SISR, 1);
254 }