Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / dev / video / bktr / bktr_os.c
1 /*
2  * 1. Redistributions of source code must retain the 
3  * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. All advertising materials mentioning features or use of this software
15  *    must display the following acknowledgement:
16  *      This product includes software developed by Amancio Hasty and
17  *      Roger Hardiman
18  * 4. The name of the author may not be used to endorse or promote products 
19  *    derived from this software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31  * POSSIBILITY OF SUCH DAMAGE.
32  *
33  * $FreeBSD: src/sys/dev/bktr/bktr_os.c,v 1.45 2004/03/17 17:50:28 njl Exp $
34  * $DragonFly: src/sys/dev/video/bktr/bktr_os.c,v 1.15 2006/09/10 01:26:37 dillon Exp $
35  */
36
37 /*
38  * This is part of the Driver for Video Capture Cards (Frame grabbers)
39  * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
40  * chipset.
41  * Copyright Roger Hardiman and Amancio Hasty.
42  *
43  * bktr_os : This has all the Operating System dependant code,
44  *             probe/attach and open/close/ioctl/read/mmap
45  *             memory allocation
46  *             PCI bus interfacing
47  */
48
49 #include "opt_bktr.h"           /* include any kernel config options */
50
51 #define FIFO_RISC_DISABLED      0
52 #define ALL_INTS_DISABLED       0
53
54 #include <sys/param.h>
55 #include <sys/systm.h>
56 #include <sys/conf.h>
57 #include <sys/device.h>
58 #include <sys/uio.h>
59 #include <sys/kernel.h>
60 #include <sys/signalvar.h>
61 #include <sys/malloc.h>
62 #include <sys/mman.h>
63 #include <sys/poll.h>
64 #include <sys/select.h>
65 #include <sys/vnode.h>
66 #include <sys/thread2.h>
67
68 #include <vm/vm.h>
69 #include <vm/vm_kern.h>
70 #include <vm/pmap.h>
71 #include <vm/vm_extern.h>
72
73 #include <sys/bus.h>            /* used by smbus and newbus */
74
75 #include <machine/bus_memio.h>  /* used by bus space */
76 #include <machine/bus.h>        /* used by bus space and newbus */
77 #include <sys/bus.h>
78
79 #include <sys/rman.h>           /* used by newbus */
80 #include <machine/resource.h>   /* used by newbus */
81 #include <bus/pci/pcivar.h>
82 #include <bus/pci/pcireg.h>
83 #include <bus/pci/pcidevs.h>
84
85 #include <sys/sysctl.h>
86 int bt848_card = -1; 
87 int bt848_tuner = -1;
88 int bt848_reverse_mute = -1; 
89 int bt848_format = -1;
90 int bt848_slow_msp_audio = -1;
91 #ifdef BKTR_NEW_MSP34XX_DRIVER
92 int bt848_stereo_once = 0;      /* no continuous stereo monitoring */
93 int bt848_amsound = 0;          /* hard-wire AM sound at 6.5 Hz (france),
94                                    the autoscan seems work well only with FM... */
95 int bt848_dolby = 0;
96 #endif
97
98 SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
99 SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
100 SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
101 SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
102 SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, "");
103 SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, "");
104 #ifdef BKTR_NEW_MSP34XX_DRIVER
105 SYSCTL_INT(_hw_bt848, OID_AUTO, stereo_once, CTLFLAG_RW, &bt848_stereo_once, 0, "");
106 SYSCTL_INT(_hw_bt848, OID_AUTO, amsound, CTLFLAG_RW, &bt848_amsound, 0, "");
107 SYSCTL_INT(_hw_bt848, OID_AUTO, dolby, CTLFLAG_RW, &bt848_dolby, 0, "");
108 #endif
109
110 #include <dev/video/meteor/ioctl_meteor.h>
111 #include <dev/video/bktr/ioctl_bt848.h> /* extensions to ioctl_meteor.h */
112 #include <dev/video/bktr/bktr_reg.h>
113 #include <dev/video/bktr/bktr_tuner.h>
114 #include <dev/video/bktr/bktr_card.h>
115 #include <dev/video/bktr/bktr_audio.h>
116 #include <dev/video/bktr/bktr_core.h>
117 #include <dev/video/bktr/bktr_os.h>
118
119 #if defined(BKTR_USE_FREEBSD_SMBUS)
120 #include <dev/video/bktr/bktr_i2c.h>
121
122 #include "iicbb_if.h"
123 #include "smbus_if.h"
124 #endif
125
126 static int      bktr_probe( device_t dev );
127 static int      bktr_attach( device_t dev );
128 static int      bktr_detach( device_t dev );
129 static int      bktr_shutdown( device_t dev );
130 static void     bktr_intr(void *arg) { common_bktr_intr(arg); }
131
132 static device_method_t bktr_methods[] = {
133         /* Device interface */
134         DEVMETHOD(device_probe,         bktr_probe),
135         DEVMETHOD(device_attach,        bktr_attach),
136         DEVMETHOD(device_detach,        bktr_detach),
137         DEVMETHOD(device_shutdown,      bktr_shutdown),
138
139 #if defined(BKTR_USE_FREEBSD_SMBUS)
140         /* iicbb interface */
141         DEVMETHOD(iicbb_callback,       bti2c_iic_callback),
142         DEVMETHOD(iicbb_setsda,         bti2c_iic_setsda),
143         DEVMETHOD(iicbb_setscl,         bti2c_iic_setscl),
144         DEVMETHOD(iicbb_getsda,         bti2c_iic_getsda),
145         DEVMETHOD(iicbb_getscl,         bti2c_iic_getscl),
146         DEVMETHOD(iicbb_reset,          bti2c_iic_reset),
147         
148         /* smbus interface */
149         DEVMETHOD(smbus_callback,       bti2c_smb_callback),
150         DEVMETHOD(smbus_writeb,         bti2c_smb_writeb),
151         DEVMETHOD(smbus_writew,         bti2c_smb_writew),
152         DEVMETHOD(smbus_readb,          bti2c_smb_readb),
153 #endif
154
155         { 0, 0 }
156 };
157
158 static driver_t bktr_driver = {
159         "bktr",
160         bktr_methods,
161         sizeof(struct bktr_softc),
162 };
163
164 static devclass_t bktr_devclass;
165
166 static  d_open_t        bktr_open;
167 static  d_close_t       bktr_close;
168 static  d_read_t        bktr_read;
169 static  d_write_t       bktr_write;
170 static  d_ioctl_t       bktr_ioctl;
171 static  d_mmap_t        bktr_mmap;
172 static  d_poll_t        bktr_poll;
173
174 #define CDEV_MAJOR 92 
175 static struct dev_ops bktr_ops = {
176         { "bktr", CDEV_MAJOR, 0 },
177         .d_open =       bktr_open,
178         .d_close =      bktr_close,
179         .d_read =       bktr_read,
180         .d_write =      bktr_write,
181         .d_ioctl =      bktr_ioctl,
182         .d_poll =       bktr_poll,
183         .d_mmap =       bktr_mmap,
184 };
185
186 DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0);
187 MODULE_DEPEND(bktr, bktr_mem, 1,1,1);
188 MODULE_VERSION(bktr, 1);
189
190 /*
191  * the boot time probe routine.
192  */
193 static int
194 bktr_probe( device_t dev )
195 {
196         unsigned int type = pci_get_devid(dev);
197         unsigned int rev  = pci_get_revid(dev);
198
199         if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
200         {
201                 switch (PCI_PRODUCT(type)) {
202                 case PCI_PRODUCT_BROOKTREE_BT848:
203                         if (rev == 0x12)
204                                 device_set_desc(dev, "BrookTree 848A");
205                         else
206                                 device_set_desc(dev, "BrookTree 848");
207                         return 0;
208                 case PCI_PRODUCT_BROOKTREE_BT849:
209                         device_set_desc(dev, "BrookTree 849A");
210                         return 0;
211                 case PCI_PRODUCT_BROOKTREE_BT878:
212                         device_set_desc(dev, "BrookTree 878");
213                         return 0;
214                 case PCI_PRODUCT_BROOKTREE_BT879:
215                         device_set_desc(dev, "BrookTree 879");
216                         return 0;
217                 }
218         };
219
220         return ENXIO;
221 }
222
223
224 /*
225  * the attach routine.
226  */
227 static int
228 bktr_attach( device_t dev )
229 {
230         u_long          latency;
231         u_long          fun;
232         u_long          val;
233         unsigned int    rev;
234         unsigned int    unit;
235         int             error = 0;
236 #ifdef BROOKTREE_IRQ
237         u_long          old_irq, new_irq;
238 #endif 
239
240         struct bktr_softc *bktr = device_get_softc(dev);
241
242         unit = device_get_unit(dev);
243
244         /* build the device name for bktr_name() */
245         snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
246
247         /*
248          * Enable bus mastering and Memory Mapped device
249          */
250         val = pci_read_config(dev, PCIR_COMMAND, 4);
251         val |= (PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
252         pci_write_config(dev, PCIR_COMMAND, val, 4);
253
254         /*
255          * Map control/status registers.
256          */
257         bktr->mem_rid = PCIR_BAR(0);
258         bktr->res_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 
259                                         &bktr->mem_rid, RF_ACTIVE);
260
261         if (!bktr->res_mem) {
262                 device_printf(dev, "could not map memory\n");
263                 error = ENXIO;
264                 goto fail;
265         }
266         bktr->memt = rman_get_bustag(bktr->res_mem);
267         bktr->memh = rman_get_bushandle(bktr->res_mem);
268
269
270         /*
271          * Disable the brooktree device
272          */
273         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
274         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
275
276
277 #ifdef BROOKTREE_IRQ            /* from the configuration file */
278         old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
279         pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ);
280         new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
281         printf("bktr%d: attach: irq changed from %d to %d\n",
282                 unit, (old_irq & 0xff), (new_irq & 0xff));
283 #endif 
284
285         /*
286          * Allocate our interrupt.
287          */
288         bktr->irq_rid = 0;
289         bktr->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, 
290                                 &bktr->irq_rid, RF_SHAREABLE | RF_ACTIVE);
291         if (bktr->res_irq == NULL) {
292                 device_printf(dev, "could not map interrupt\n");
293                 error = ENXIO;
294                 goto fail;
295         }
296
297         error = bus_setup_intr(dev, bktr->res_irq, 0,
298                                bktr_intr, bktr, &bktr->res_ih, NULL);
299         if (error) {
300                 device_printf(dev, "could not setup irq\n");
301                 goto fail;
302
303         }
304
305
306         /* Update the Device Control Register */
307         /* on Bt878 and Bt879 cards           */
308         fun = pci_read_config( dev, 0x40, 2);
309         fun = fun | 1;  /* Enable writes to the sub-system vendor ID */
310
311 #if defined( BKTR_430_FX_MODE )
312         if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n");
313         fun = fun | 2;  /* Enable Intel 430 FX compatibility mode */
314 #endif
315
316 #if defined( BKTR_SIS_VIA_MODE )
317         if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n");
318         fun = fun | 4;  /* Enable SiS/VIA compatibility mode (usefull for
319                            OPTi chipset motherboards too */
320 #endif
321         pci_write_config(dev, 0x40, fun, 2);
322
323 #if defined(BKTR_USE_FREEBSD_SMBUS)
324         if (bt848_i2c_attach(dev))
325                 printf("bktr%d: i2c_attach: can't attach\n", unit);
326 #endif
327
328 /*
329  * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
330  * you have more than four, then 16 would probably be a better value.
331  */
332 #ifndef BROOKTREE_DEF_LATENCY_VALUE
333 #define BROOKTREE_DEF_LATENCY_VALUE     10
334 #endif
335         latency = pci_read_config(dev, PCI_LATENCY_TIMER, 4);
336         latency = (latency >> 8) & 0xff;
337         if ( bootverbose ) {
338                 if (latency)
339                         printf("brooktree%d: PCI bus latency is", unit);
340                 else
341                         printf("brooktree%d: PCI bus latency was 0 changing to",
342                                 unit);
343         }
344         if ( !latency ) {
345                 latency = BROOKTREE_DEF_LATENCY_VALUE;
346                 pci_write_config(dev, PCI_LATENCY_TIMER, latency<<8, 4);
347         }
348         if ( bootverbose ) {
349                 printf(" %d.\n", (int) latency);
350         }
351
352         /* read the pci device id and revision id */
353         fun = pci_get_devid(dev);
354         rev = pci_get_revid(dev);
355
356         /* call the common attach code */
357         common_bktr_attach( bktr, unit, fun, rev );
358
359         /* make the device entries */
360         dev_ops_add(&bktr_ops, 0x0f, unit);
361         make_dev(&bktr_ops, unit,    0, 0, 0444, "bktr%d",  unit);
362         make_dev(&bktr_ops, unit+16, 0, 0, 0444, "tuner%d", unit);
363         make_dev(&bktr_ops, unit+32, 0, 0, 0444, "vbi%d"  , unit);
364
365
366         return 0;
367
368 fail:
369         if (bktr->res_irq)
370                 bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
371         if (bktr->res_mem)
372                 bus_release_resource(dev, SYS_RES_IRQ, bktr->mem_rid, bktr->res_mem);
373         return error;
374
375 }
376
377 /*
378  * the detach routine.
379  */
380 static int
381 bktr_detach( device_t dev )
382 {
383         struct bktr_softc *bktr = device_get_softc(dev);
384
385 #ifdef BKTR_NEW_MSP34XX_DRIVER
386         /* Disable the soundchip and kernel thread */
387         if (bktr->msp3400c_info != NULL)
388                 msp_detach(bktr);
389 #endif
390
391         /* Disable the brooktree device */
392         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
393         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
394
395 #if defined(BKTR_USE_FREEBSD_SMBUS)
396         if (bt848_i2c_detach(dev))
397                 printf("bktr%d: i2c_attach: can't attach\n",
398                      device_get_unit(dev));
399 #endif
400 #ifdef USE_VBIMUTEX
401         mtx_destroy(&bktr->vbimutex);
402 #endif
403
404         /* Note: We do not free memory for RISC programs, grab buffer, vbi buffers */
405         /* The memory is retained by the bktr_mem module so we can unload and */
406         /* then reload the main bktr driver module */
407
408         /* removing the ops automatically destroys all related devices */
409         dev_ops_remove(&bktr_ops, 0x0f, device_get_unit(dev));
410
411         /*
412          * Deallocate resources.
413          */
414         bus_teardown_intr(dev, bktr->res_irq, bktr->res_ih);
415         bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
416         bus_release_resource(dev, SYS_RES_MEMORY, bktr->mem_rid, bktr->res_mem);
417          
418         return 0;
419 }
420
421 /*
422  * the shutdown routine.
423  */
424 static int
425 bktr_shutdown( device_t dev )
426 {
427         struct bktr_softc *bktr = device_get_softc(dev);
428
429         /* Disable the brooktree device */
430         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
431         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
432
433         return 0;
434 }
435
436
437 /*
438  * Special Memory Allocation
439  */
440 vm_offset_t
441 get_bktr_mem( int unit, unsigned size )
442 {
443         vm_offset_t     addr = 0;
444
445         addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
446             0xffffffff, 1<<24, 0);
447         if (addr == 0)
448                 addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
449                     0xffffffff, PAGE_SIZE, 0);
450         if (addr == 0) {
451                 printf("bktr%d: Unable to allocate %d bytes of memory.\n",
452                         unit, size);
453         }
454
455         return( addr );
456 }
457
458
459 /*---------------------------------------------------------
460 **
461 **      BrookTree 848 character device driver routines
462 **
463 **---------------------------------------------------------
464 */
465
466 #define VIDEO_DEV       0x00
467 #define TUNER_DEV       0x01
468 #define VBI_DEV         0x02
469
470 #define UNIT(x)         ((x) & 0x0f)
471 #define FUNCTION(x)     (x >> 4)
472
473 /*
474  * 
475  */
476 static int
477 bktr_open(struct dev_open_args *ap)
478 {
479         cdev_t dev = ap->a_head.a_dev;
480         bktr_ptr_t      bktr;
481         int             unit;
482         int             result;
483
484         unit = UNIT( minor(dev) );
485
486         /* Get the device data */
487         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
488         if (bktr == NULL) {
489                 /* the device is no longer valid/functioning */
490                 return (ENXIO);
491         }
492
493         if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
494                 return( ENXIO );        
495
496         /* Record that the device is now busy */
497         device_busy(devclass_get_device(bktr_devclass, unit)); 
498
499
500         if (bt848_card != -1) {
501           if ((bt848_card >> 8   == unit ) &&
502              ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
503             if ( bktr->bt848_card != (bt848_card & 0xff) ) {
504               bktr->bt848_card = (bt848_card & 0xff);
505               probeCard(bktr, FALSE, unit);
506             }
507           }
508         }
509
510         if (bt848_tuner != -1) {
511           if ((bt848_tuner >> 8   == unit ) &&
512              ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
513             if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
514               bktr->bt848_tuner = (bt848_tuner & 0xff);
515               probeCard(bktr, FALSE, unit);
516             }
517           }
518         }
519
520         if (bt848_reverse_mute != -1) {
521           if ((bt848_reverse_mute >> 8)   == unit ) {
522             bktr->reverse_mute = bt848_reverse_mute & 0xff;
523           }
524         }
525
526         if (bt848_slow_msp_audio != -1) {
527           if ((bt848_slow_msp_audio >> 8) == unit ) {
528               bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
529           }
530         }
531
532 #ifdef BKTR_NEW_MSP34XX_DRIVER
533         if (bt848_stereo_once != 0) {
534           if ((bt848_stereo_once >> 8) == unit ) {
535               bktr->stereo_once = (bt848_stereo_once & 0xff);
536           }
537         }
538
539         if (bt848_amsound != -1) {
540           if ((bt848_amsound >> 8) == unit ) {
541               bktr->amsound = (bt848_amsound & 0xff);
542           }
543         }
544
545         if (bt848_dolby != -1) {
546           if ((bt848_dolby >> 8) == unit ) {
547               bktr->dolby = (bt848_dolby & 0xff);
548           }
549         }
550 #endif
551
552         switch ( FUNCTION( minor(dev) ) ) {
553         case VIDEO_DEV:
554                 result = video_open( bktr );
555                 break;
556         case TUNER_DEV:
557                 result = tuner_open( bktr );
558                 break;
559         case VBI_DEV:
560                 result = vbi_open( bktr );
561                 break;
562         default:
563                 result = ENXIO;
564                 break;
565         }
566
567         /* If there was an error opening the device, undo the busy status */
568         if (result != 0)
569                 device_unbusy(devclass_get_device(bktr_devclass, unit)); 
570         return( result );
571 }
572
573
574 /*
575  * 
576  */
577 static int
578 bktr_close(struct dev_close_args *ap)
579 {
580         cdev_t dev = ap->a_head.a_dev;
581         bktr_ptr_t      bktr;
582         int             unit;
583         int             result;
584
585         unit = UNIT( minor(dev) );
586
587         /* Get the device data */
588         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
589         if (bktr == NULL) {
590                 /* the device is no longer valid/functioning */
591                 return (ENXIO);
592         }
593
594         switch ( FUNCTION( minor(dev) ) ) {
595         case VIDEO_DEV:
596                 result = video_close( bktr );
597                 break;
598         case TUNER_DEV:
599                 result = tuner_close( bktr );
600                 break;
601         case VBI_DEV:
602                 result = vbi_close( bktr );
603                 break;
604         default:
605                 return (ENXIO);
606                 break;
607         }
608
609         device_unbusy(devclass_get_device(bktr_devclass, unit)); 
610         return( result );
611 }
612
613
614 /*
615  * 
616  */
617 static int
618 bktr_read(struct dev_read_args *ap)
619 {
620         cdev_t dev = ap->a_head.a_dev;
621         bktr_ptr_t      bktr;
622         int             unit;
623         
624         unit = UNIT(minor(dev));
625
626         /* Get the device data */
627         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
628         if (bktr == NULL) {
629                 /* the device is no longer valid/functioning */
630                 return (ENXIO);
631         }
632
633         switch ( FUNCTION( minor(dev) ) ) {
634         case VIDEO_DEV:
635                 return( video_read( bktr, unit, dev, ap->a_uio ) );
636         case VBI_DEV:
637                 return( vbi_read( bktr, ap->a_uio, ap->a_ioflag ) );
638         }
639         return( ENXIO );
640 }
641
642
643 /*
644  * 
645  */
646 static int
647 bktr_write(struct dev_write_args *ap)
648 {
649         return( EINVAL ); /* XXX or ENXIO ? */
650 }
651
652
653 /*
654  * 
655  */
656 static int
657 bktr_ioctl(struct dev_ioctl_args *ap)
658 {
659         cdev_t dev = ap->a_head.a_dev;
660         bktr_ptr_t      bktr;
661         int             unit;
662
663         unit = UNIT(minor(dev));
664
665         /* Get the device data */
666         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
667         if (bktr == NULL) {
668                 /* the device is no longer valid/functioning */
669                 return (ENXIO);
670         }
671
672         if (bktr->bigbuf == 0)  /* no frame buffer allocated (ioctl failed) */
673                 return( ENOMEM );
674
675         switch ( FUNCTION( minor(dev) ) ) {
676         case VIDEO_DEV:
677                 return( video_ioctl( bktr, unit, ap->a_cmd, ap->a_data, curthread ) );
678         case TUNER_DEV:
679                 return( tuner_ioctl( bktr, unit, ap->a_cmd, ap->a_data, curthread ) );
680         }
681
682         return( ENXIO );
683 }
684
685
686 /*
687  * 
688  */
689 static int
690 bktr_mmap(struct dev_mmap_args *ap)
691 {
692         cdev_t dev = ap->a_head.a_dev;
693         int             unit;
694         bktr_ptr_t      bktr;
695
696         unit = UNIT(minor(dev));
697
698         if (FUNCTION(minor(dev)) > 0)   /* only allow mmap on /dev/bktr[n] */
699                 return(EINVAL);
700
701         /* Get the device data */
702         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
703         if (bktr == NULL) {
704                 /* the device is no longer valid/functioning */
705                 return (ENXIO);
706         }
707
708         if (ap->a_nprot & PROT_EXEC)
709                 return(EINVAL);
710
711         if (ap->a_offset < 0)
712                 return(EINVAL);
713
714         if (ap->a_offset >= bktr->alloc_pages * PAGE_SIZE)
715                 return(EINVAL);
716
717         ap->a_result = atop(vtophys(bktr->bigbuf) + ap->a_offset);
718         return(0);
719 }
720
721 static int
722 bktr_poll(struct dev_poll_args *ap)
723 {
724         cdev_t dev = ap->a_head.a_dev;
725         int             unit;
726         bktr_ptr_t      bktr;
727         int revents = 0; 
728
729         unit = UNIT(minor(dev));
730
731         /* Get the device data */
732         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
733         if (bktr == NULL) {
734                 /* the device is no longer valid/functioning */
735                 return (ENXIO);
736         }
737
738         LOCK_VBI(bktr);
739         crit_enter();
740
741         if (ap->a_events & (POLLIN | POLLRDNORM)) {
742
743                 switch ( FUNCTION( minor(dev) ) ) {
744                 case VBI_DEV:
745                         if(bktr->vbisize == 0)
746                                 selrecord(curthread, &bktr->vbi_select);
747                         else
748                                 revents |= ap->a_events & (POLLIN | POLLRDNORM);
749                         break;
750                 }
751         }
752
753         crit_exit();
754         UNLOCK_VBI(bktr);
755
756         ap->a_events = revents;
757         return (0);
758 }