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