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