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