Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / dev / video / bktr / bktr_os.c
CommitLineData
984263bc
MD
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.
a35cc233
JS
32 *
33 * $FreeBSD: src/sys/dev/bktr/bktr_os.c,v 1.45 2004/03/17 17:50:28 njl Exp $
b13267a5 34 * $DragonFly: src/sys/dev/video/bktr/bktr_os.c,v 1.15 2006/09/10 01:26:37 dillon Exp $
984263bc
MD
35 */
36
a35cc233
JS
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 */
984263bc
MD
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
984263bc
MD
54#include <sys/param.h>
55#include <sys/systm.h>
56#include <sys/conf.h>
fef8985e 57#include <sys/device.h>
984263bc
MD
58#include <sys/uio.h>
59#include <sys/kernel.h>
60#include <sys/signalvar.h>
a35cc233 61#include <sys/malloc.h>
984263bc
MD
62#include <sys/mman.h>
63#include <sys/poll.h>
64#include <sys/select.h>
65#include <sys/vnode.h>
052b6ffa 66#include <sys/thread2.h>
984263bc
MD
67
68#include <vm/vm.h>
69#include <vm/vm_kern.h>
70#include <vm/pmap.h>
71#include <vm/vm_extern.h>
72
984263bc 73#include <sys/bus.h> /* used by smbus and newbus */
984263bc 74
984263bc
MD
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>
984263bc 78
984263bc
MD
79#include <sys/rman.h> /* used by newbus */
80#include <machine/resource.h> /* used by newbus */
1f2de5d4
MD
81#include <bus/pci/pcivar.h>
82#include <bus/pci/pcireg.h>
a35cc233 83#include <bus/pci/pcidevs.h>
984263bc
MD
84
85#include <sys/sysctl.h>
86int bt848_card = -1;
87int bt848_tuner = -1;
88int bt848_reverse_mute = -1;
89int bt848_format = -1;
90int bt848_slow_msp_audio = -1;
a35cc233
JS
91#ifdef BKTR_NEW_MSP34XX_DRIVER
92int bt848_stereo_once = 0; /* no continuous stereo monitoring */
93int bt848_amsound = 0; /* hard-wire AM sound at 6.5 Hz (france),
94 the autoscan seems work well only with FM... */
95int bt848_dolby = 0;
96#endif
984263bc
MD
97
98SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
99SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
100SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
101SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
102SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, "");
103SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, "");
a35cc233
JS
104#ifdef BKTR_NEW_MSP34XX_DRIVER
105SYSCTL_INT(_hw_bt848, OID_AUTO, stereo_once, CTLFLAG_RW, &bt848_stereo_once, 0, "");
106SYSCTL_INT(_hw_bt848, OID_AUTO, amsound, CTLFLAG_RW, &bt848_amsound, 0, "");
107SYSCTL_INT(_hw_bt848, OID_AUTO, dolby, CTLFLAG_RW, &bt848_dolby, 0, "");
984263bc
MD
108#endif
109
a35cc233
JS
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>
984263bc 118
984263bc 119#if defined(BKTR_USE_FREEBSD_SMBUS)
a35cc233 120#include <dev/video/bktr/bktr_i2c.h>
984263bc 121
a35cc233
JS
122#include "iicbb_if.h"
123#include "smbus_if.h"
124#endif
984263bc
MD
125
126static int bktr_probe( device_t dev );
127static int bktr_attach( device_t dev );
128static int bktr_detach( device_t dev );
129static int bktr_shutdown( device_t dev );
130static void bktr_intr(void *arg) { common_bktr_intr(arg); }
131
132static 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
a35cc233
JS
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
984263bc
MD
155 { 0, 0 }
156};
157
158static driver_t bktr_driver = {
159 "bktr",
160 bktr_methods,
161 sizeof(struct bktr_softc),
162};
163
164static devclass_t bktr_devclass;
165
166static d_open_t bktr_open;
167static d_close_t bktr_close;
168static d_read_t bktr_read;
169static d_write_t bktr_write;
170static d_ioctl_t bktr_ioctl;
171static d_mmap_t bktr_mmap;
172static d_poll_t bktr_poll;
173
174#define CDEV_MAJOR 92
fef8985e
MD
175static 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,
984263bc
MD
184};
185
186DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0);
984263bc
MD
187MODULE_DEPEND(bktr, bktr_mem, 1,1,1);
188MODULE_VERSION(bktr, 1);
984263bc
MD
189
190/*
191 * the boot time probe routine.
192 */
193static int
194bktr_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 */
227static int
228bktr_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 */
a35cc233
JS
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);
984263bc
MD
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;
a35cc233
JS
289 bktr->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
290 &bktr->irq_rid, RF_SHAREABLE | RF_ACTIVE);
984263bc
MD
291 if (bktr->res_irq == NULL) {
292 device_printf(dev, "could not map interrupt\n");
293 error = ENXIO;
294 goto fail;
295 }
296
ee61f228 297 error = bus_setup_intr(dev, bktr->res_irq, 0,
e9cb6d99 298 bktr_intr, bktr, &bktr->res_ih, NULL);
984263bc
MD
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
984263bc 323#if defined(BKTR_USE_FREEBSD_SMBUS)
a35cc233 324 if (bt848_i2c_attach(dev))
984263bc
MD
325 printf("bktr%d: i2c_attach: can't attach\n", unit);
326#endif
327
984263bc
MD
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 */
fef8985e
MD
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);
984263bc
MD
364
365
984263bc
MD
366 return 0;
367
368fail:
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 */
380static int
381bktr_detach( device_t dev )
382{
984263bc
MD
383 struct bktr_softc *bktr = device_get_softc(dev);
384
a35cc233
JS
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
984263bc
MD
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
a35cc233
JS
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
984263bc
MD
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
fef8985e
MD
408 /* removing the ops automatically destroys all related devices */
409 dev_ops_remove(&bktr_ops, 0x0f, device_get_unit(dev));
984263bc 410
984263bc
MD
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 */
424static int
425bktr_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 */
440vm_offset_t
441get_bktr_mem( int unit, unsigned size )
442{
443 vm_offset_t addr = 0;
444
a35cc233
JS
445 addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
446 0xffffffff, 1<<24, 0);
984263bc 447 if (addr == 0)
a35cc233
JS
448 addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
449 0xffffffff, PAGE_SIZE, 0);
984263bc
MD
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 */
a35cc233 476static int
fef8985e 477bktr_open(struct dev_open_args *ap)
984263bc 478{
b13267a5 479 cdev_t dev = ap->a_head.a_dev;
984263bc
MD
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
a35cc233
JS
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
984263bc
MD
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 */
a35cc233 577static int
fef8985e 578bktr_close(struct dev_close_args *ap)
984263bc 579{
b13267a5 580 cdev_t dev = ap->a_head.a_dev;
984263bc
MD
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 */
a35cc233 617static int
fef8985e 618bktr_read(struct dev_read_args *ap)
984263bc 619{
b13267a5 620 cdev_t dev = ap->a_head.a_dev;
984263bc
MD
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:
fef8985e 635 return( video_read( bktr, unit, dev, ap->a_uio ) );
984263bc 636 case VBI_DEV:
fef8985e 637 return( vbi_read( bktr, ap->a_uio, ap->a_ioflag ) );
984263bc
MD
638 }
639 return( ENXIO );
640}
641
642
643/*
644 *
645 */
a35cc233 646static int
fef8985e 647bktr_write(struct dev_write_args *ap)
984263bc
MD
648{
649 return( EINVAL ); /* XXX or ENXIO ? */
650}
651
652
653/*
654 *
655 */
a35cc233 656static int
fef8985e 657bktr_ioctl(struct dev_ioctl_args *ap)
984263bc 658{
b13267a5 659 cdev_t dev = ap->a_head.a_dev;
984263bc
MD
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:
fef8985e 677 return( video_ioctl( bktr, unit, ap->a_cmd, ap->a_data, curthread ) );
984263bc 678 case TUNER_DEV:
fef8985e 679 return( tuner_ioctl( bktr, unit, ap->a_cmd, ap->a_data, curthread ) );
984263bc
MD
680 }
681
682 return( ENXIO );
683}
684
685
686/*
687 *
688 */
a35cc233 689static int
fef8985e 690bktr_mmap(struct dev_mmap_args *ap)
984263bc 691{
b13267a5 692 cdev_t dev = ap->a_head.a_dev;
984263bc
MD
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] */
fef8985e 699 return(EINVAL);
984263bc
MD
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
fef8985e
MD
708 if (ap->a_nprot & PROT_EXEC)
709 return(EINVAL);
984263bc 710
fef8985e
MD
711 if (ap->a_offset < 0)
712 return(EINVAL);
984263bc 713
fef8985e
MD
714 if (ap->a_offset >= bktr->alloc_pages * PAGE_SIZE)
715 return(EINVAL);
984263bc 716
fef8985e
MD
717 ap->a_result = atop(vtophys(bktr->bigbuf) + ap->a_offset);
718 return(0);
984263bc
MD
719}
720
a35cc233 721static int
fef8985e 722bktr_poll(struct dev_poll_args *ap)
984263bc 723{
b13267a5 724 cdev_t dev = ap->a_head.a_dev;
984263bc
MD
725 int unit;
726 bktr_ptr_t bktr;
727 int revents = 0;
984263bc
MD
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
a35cc233 738 LOCK_VBI(bktr);
052b6ffa 739 crit_enter();
984263bc 740
fef8985e 741 if (ap->a_events & (POLLIN | POLLRDNORM)) {
984263bc
MD
742
743 switch ( FUNCTION( minor(dev) ) ) {
744 case VBI_DEV:
745 if(bktr->vbisize == 0)
fef8985e 746 selrecord(curthread, &bktr->vbi_select);
984263bc 747 else
fef8985e 748 revents |= ap->a_events & (POLLIN | POLLRDNORM);
984263bc
MD
749 break;
750 }
751 }
752
052b6ffa 753 crit_exit();
a35cc233 754 UNLOCK_VBI(bktr);
984263bc 755
fef8985e
MD
756 ap->a_events = revents;
757 return (0);
984263bc 758}