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