bktr_os.c revision 1.27
1 /* $NetBSD: bktr_os.c,v 1.27 2002/01/07 12:12:55 tron Exp $ */ 2 3 /* FreeBSD: src/sys/dev/bktr/bktr_os.c,v 1.20 2000/10/20 08:16:53 roger Exp */ 4 5 /* 6 * This is part of the Driver for Video Capture Cards (Frame grabbers) 7 * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879 8 * chipset. 9 * Copyright Roger Hardiman and Amancio Hasty. 10 * 11 * bktr_os : This has all the Operating System dependant code, 12 * probe/attach and open/close/ioctl/read/mmap 13 * memory allocation 14 * PCI bus interfacing 15 * 16 * 17 */ 18 19 /* 20 * 1. Redistributions of source code must retain the 21 * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman 22 * All rights reserved. 23 * 24 * Redistribution and use in source and binary forms, with or without 25 * modification, are permitted provided that the following conditions 26 * are met: 27 * 1. Redistributions of source code must retain the above copyright 28 * notice, this list of conditions and the following disclaimer. 29 * 2. Redistributions in binary form must reproduce the above copyright 30 * notice, this list of conditions and the following disclaimer in the 31 * documentation and/or other materials provided with the distribution. 32 * 3. All advertising materials mentioning features or use of this software 33 * must display the following acknowledgement: 34 * This product includes software developed by Amancio Hasty and 35 * Roger Hardiman 36 * 4. The name of the author may not be used to endorse or promote products 37 * derived from this software without specific prior written permission. 38 * 39 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 40 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 41 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 42 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 43 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 44 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 45 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 46 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 47 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 48 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 49 * POSSIBILITY OF SUCH DAMAGE. 50 */ 51 52 #include <sys/cdefs.h> 53 __KERNEL_RCSID(0, "$NetBSD: bktr_os.c,v 1.27 2002/01/07 12:12:55 tron Exp $"); 54 55 #ifdef __FreeBSD__ 56 #include "bktr.h" 57 #endif /* __FreeBSD__ */ 58 59 #include "opt_bktr.h" /* include any kernel config options */ 60 61 #define FIFO_RISC_DISABLED 0 62 #define ALL_INTS_DISABLED 0 63 64 /*******************/ 65 /* *** FreeBSD *** */ 66 /*******************/ 67 #ifdef __FreeBSD__ 68 69 #include <sys/param.h> 70 #include <sys/systm.h> 71 #include <sys/conf.h> 72 #include <sys/uio.h> 73 #include <sys/kernel.h> 74 #include <sys/signalvar.h> 75 #include <sys/mman.h> 76 #include <sys/poll.h> 77 #include <sys/select.h> 78 #include <sys/vnode.h> 79 80 #include <vm/vm.h> 81 #include <vm/vm_kern.h> 82 #include <vm/pmap.h> 83 #include <vm/vm_extern.h> 84 85 #if (__FreeBSD_version >=400000) || (NSMBUS > 0) 86 #include <sys/bus.h> /* used by smbus and newbus */ 87 #endif 88 89 #if (__FreeBSD_version >=300000) 90 #include <machine/bus_memio.h> /* used by bus space */ 91 #include <machine/bus.h> /* used by bus space and newbus */ 92 #include <sys/bus.h> 93 #endif 94 95 #if (__FreeBSD_version >=400000) 96 #include <sys/rman.h> /* used by newbus */ 97 #include <machine/resource.h> /* used by newbus */ 98 #endif 99 100 #if (__FreeBSD_version < 500000) 101 #include <machine/clock.h> /* for DELAY */ 102 #endif 103 104 #include <pci/pcivar.h> 105 #include <pci/pcireg.h> 106 107 #include <sys/sysctl.h> 108 int bt848_card = -1; 109 int bt848_tuner = -1; 110 int bt848_reverse_mute = -1; 111 int bt848_format = -1; 112 int bt848_slow_msp_audio = -1; 113 114 SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt"); 115 SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, ""); 116 SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, ""); 117 SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, ""); 118 SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, ""); 119 SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, ""); 120 121 #if (__FreeBSD__ == 2) 122 #define PCIR_REVID PCI_CLASS_REG 123 #endif 124 125 #endif /* end freebsd section */ 126 127 128 129 /****************/ 130 /* *** BSDI *** */ 131 /****************/ 132 #ifdef __bsdi__ 133 #endif /* __bsdi__ */ 134 135 136 /**************************/ 137 /* *** OpenBSD/NetBSD *** */ 138 /**************************/ 139 #if defined(__NetBSD__) || defined(__OpenBSD__) 140 141 #include <sys/param.h> 142 #include <sys/systm.h> 143 #include <sys/conf.h> 144 #include <sys/uio.h> 145 #include <sys/kernel.h> 146 #include <sys/signalvar.h> 147 #include <sys/mman.h> 148 #include <sys/poll.h> 149 #include <sys/select.h> 150 #include <sys/vnode.h> 151 152 #ifndef __NetBSD__ 153 #include <vm/vm.h> 154 #include <vm/vm_kern.h> 155 #include <vm/pmap.h> 156 #include <vm/vm_extern.h> 157 #endif 158 159 #include <sys/device.h> 160 #include <dev/pci/pcivar.h> 161 #include <dev/pci/pcireg.h> 162 #include <dev/pci/pcidevs.h> 163 164 #define BKTR_DEBUG 165 #ifdef BKTR_DEBUG 166 int bktr_debug = 0; 167 #define DPR(x) (bktr_debug ? printf x : 0) 168 #else 169 #define DPR(x) 170 #endif 171 #endif /* __NetBSD__ || __OpenBSD__ */ 172 173 174 #ifdef __NetBSD__ 175 #include <dev/ic/bt8xx.h> /* NetBSD location for .h files */ 176 #include <dev/pci/bktr/bktr_reg.h> 177 #include <dev/pci/bktr/bktr_tuner.h> 178 #include <dev/pci/bktr/bktr_card.h> 179 #include <dev/pci/bktr/bktr_audio.h> 180 #include <dev/pci/bktr/bktr_core.h> 181 #include <dev/pci/bktr/bktr_os.h> 182 #else /* Traditional location for .h files */ 183 #include <machine/ioctl_meteor.h> 184 #include <machine/ioctl_bt848.h> /* extensions to ioctl_meteor.h */ 185 #include <dev/bktr/bktr_reg.h> 186 #include <dev/bktr/bktr_tuner.h> 187 #include <dev/bktr/bktr_card.h> 188 #include <dev/bktr/bktr_audio.h> 189 #include <dev/bktr/bktr_core.h> 190 #include <dev/bktr/bktr_os.h> 191 #if defined(BKTR_USE_FREEBSD_SMBUS) 192 #include <dev/bktr/bktr_i2c.h> 193 #endif 194 #endif 195 196 /* Support for radio(4) under NetBSD */ 197 #ifdef __NetBSD__ 198 #ifdef RADIO_ON_BKTR_WORKS 199 #include "radio.h" 200 #else 201 #define NRADIO 0 202 #endif 203 #if NRADIO > 0 204 #include <sys/radioio.h> 205 #include <dev/radio_if.h> 206 #endif 207 #else 208 #define NRADIO 0 209 #endif 210 211 /****************************/ 212 /* *** FreeBSD 4.x code *** */ 213 /****************************/ 214 #if (__FreeBSD_version >= 400000) 215 216 static int bktr_probe( device_t dev ); 217 static int bktr_attach( device_t dev ); 218 static int bktr_detach( device_t dev ); 219 static int bktr_shutdown( device_t dev ); 220 static void bktr_intr(void *arg) { common_bktr_intr(arg); } 221 222 static device_method_t bktr_methods[] = { 223 /* Device interface */ 224 DEVMETHOD(device_probe, bktr_probe), 225 DEVMETHOD(device_attach, bktr_attach), 226 DEVMETHOD(device_detach, bktr_detach), 227 DEVMETHOD(device_shutdown, bktr_shutdown), 228 229 { 0, 0 } 230 }; 231 232 static driver_t bktr_driver = { 233 "bktr", 234 bktr_methods, 235 sizeof(struct bktr_softc), 236 }; 237 238 static devclass_t bktr_devclass; 239 240 static d_open_t bktr_open; 241 static d_close_t bktr_close; 242 static d_read_t bktr_read; 243 static d_write_t bktr_write; 244 static d_ioctl_t bktr_ioctl; 245 static d_mmap_t bktr_mmap; 246 static d_poll_t bktr_poll; 247 248 #define CDEV_MAJOR 92 249 static struct cdevsw bktr_cdevsw = { 250 /* open */ bktr_open, 251 /* close */ bktr_close, 252 /* read */ bktr_read, 253 /* write */ bktr_write, 254 /* ioctl */ bktr_ioctl, 255 /* poll */ bktr_poll, 256 /* mmap */ bktr_mmap, 257 /* strategy */ nostrategy, 258 /* name */ "bktr", 259 /* maj */ CDEV_MAJOR, 260 /* dump */ nodump, 261 /* psize */ nopsize, 262 /* flags */ 0, 263 /* bmaj */ -1 264 }; 265 266 DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0); 267 #if (__FreeBSD_version > 410000) 268 MODULE_DEPEND(bktr, bktr_mem, 1,1,1); 269 MODULE_VERSION(bktr, 1); 270 #endif 271 272 273 /* 274 * the boot time probe routine. 275 */ 276 static int 277 bktr_probe( device_t dev ) 278 { 279 unsigned int type = pci_get_devid(dev); 280 unsigned int rev = pci_get_revid(dev); 281 282 if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE) 283 { 284 switch (PCI_PRODUCT(type)) { 285 case PCI_PRODUCT_BROOKTREE_BT848: 286 if (rev == 0x12) 287 device_set_desc(dev, "BrookTree 848A"); 288 else 289 device_set_desc(dev, "BrookTree 848"); 290 return 0; 291 case PCI_PRODUCT_BROOKTREE_BT849: 292 device_set_desc(dev, "BrookTree 849A"); 293 return 0; 294 case PCI_PRODUCT_BROOKTREE_BT878: 295 device_set_desc(dev, "BrookTree 878"); 296 return 0; 297 case PCI_PRODUCT_BROOKTREE_BT879: 298 device_set_desc(dev, "BrookTree 879"); 299 return 0; 300 } 301 }; 302 303 return ENXIO; 304 } 305 306 307 /* 308 * the attach routine. 309 */ 310 static int 311 bktr_attach( device_t dev ) 312 { 313 u_long latency; 314 u_long fun; 315 u_long val; 316 unsigned int rev; 317 unsigned int unit; 318 int error = 0; 319 #ifdef BROOKTREE_IRQ 320 u_long old_irq, new_irq; 321 #endif 322 323 struct bktr_softc *bktr = device_get_softc(dev); 324 325 unit = device_get_unit(dev); 326 327 /* build the device name for bktr_name() */ 328 snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit); 329 330 /* 331 * Enable bus mastering and Memory Mapped device 332 */ 333 val = pci_read_config(dev, PCIR_COMMAND, 4); 334 val |= (PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN); 335 pci_write_config(dev, PCIR_COMMAND, val, 4); 336 337 /* 338 * Map control/status registers. 339 */ 340 bktr->mem_rid = PCIR_MAPS; 341 bktr->res_mem = bus_alloc_resource(dev, SYS_RES_MEMORY, &bktr->mem_rid, 342 0, ~0, 1, RF_ACTIVE); 343 344 345 if (!bktr->res_mem) { 346 device_printf(dev, "could not map memory\n"); 347 error = ENXIO; 348 goto fail; 349 } 350 bktr->memt = rman_get_bustag(bktr->res_mem); 351 bktr->memh = rman_get_bushandle(bktr->res_mem); 352 353 354 /* 355 * Disable the brooktree device 356 */ 357 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 358 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 359 360 361 #ifdef BROOKTREE_IRQ /* from the configuration file */ 362 old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG); 363 pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ); 364 new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG); 365 printf("bktr%d: attach: irq changed from %d to %d\n", 366 unit, (old_irq & 0xff), (new_irq & 0xff)); 367 #endif 368 369 /* 370 * Allocate our interrupt. 371 */ 372 bktr->irq_rid = 0; 373 bktr->res_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &bktr->irq_rid, 374 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE); 375 if (bktr->res_irq == NULL) { 376 device_printf(dev, "could not map interrupt\n"); 377 error = ENXIO; 378 goto fail; 379 } 380 381 error = bus_setup_intr(dev, bktr->res_irq, INTR_TYPE_TTY, 382 bktr_intr, bktr, &bktr->res_ih); 383 if (error) { 384 device_printf(dev, "could not setup irq\n"); 385 goto fail; 386 387 } 388 389 390 /* Update the Device Control Register */ 391 /* on Bt878 and Bt879 cards */ 392 fun = pci_read_config( dev, 0x40, 2); 393 fun = fun | 1; /* Enable writes to the sub-system vendor ID */ 394 395 #if defined( BKTR_430_FX_MODE ) 396 if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n"); 397 fun = fun | 2; /* Enable Intel 430 FX compatibility mode */ 398 #endif 399 400 #if defined( BKTR_SIS_VIA_MODE ) 401 if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n"); 402 fun = fun | 4; /* Enable SiS/VIA compatibility mode (usefull for 403 OPTi chipset motherboards too */ 404 #endif 405 pci_write_config(dev, 0x40, fun, 2); 406 407 408 /* XXX call bt848_i2c dependent attach() routine */ 409 #if defined(BKTR_USE_FREEBSD_SMBUS) 410 if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc)) 411 printf("bktr%d: i2c_attach: can't attach\n", unit); 412 #endif 413 414 415 /* 416 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if 417 * you have more than four, then 16 would probably be a better value. 418 */ 419 #ifndef BROOKTREE_DEF_LATENCY_VALUE 420 #define BROOKTREE_DEF_LATENCY_VALUE 10 421 #endif 422 latency = pci_read_config(dev, PCI_LATENCY_TIMER, 4); 423 latency = (latency >> 8) & 0xff; 424 if ( bootverbose ) { 425 if (latency) 426 printf("brooktree%d: PCI bus latency is", unit); 427 else 428 printf("brooktree%d: PCI bus latency was 0 changing to", 429 unit); 430 } 431 if ( !latency ) { 432 latency = BROOKTREE_DEF_LATENCY_VALUE; 433 pci_write_config(dev, PCI_LATENCY_TIMER, latency<<8, 4); 434 } 435 if ( bootverbose ) { 436 printf(" %d.\n", (int) latency); 437 } 438 439 /* read the pci device id and revision id */ 440 fun = pci_get_devid(dev); 441 rev = pci_get_revid(dev); 442 443 /* call the common attach code */ 444 common_bktr_attach( bktr, unit, fun, rev ); 445 446 /* make the device entries */ 447 bktr->bktrdev = make_dev(&bktr_cdevsw, unit, 448 0, 0, 0444, "bktr%d", unit); 449 bktr->tunerdev= make_dev(&bktr_cdevsw, unit+16, 450 0, 0, 0444, "tuner%d", unit); 451 bktr->vbidev = make_dev(&bktr_cdevsw, unit+32, 452 0, 0, 0444, "vbi%d" , unit); 453 454 455 /* if this is unit 0 (/dev/bktr0, /dev/tuner0, /dev/vbi0) then make */ 456 /* alias entries to /dev/bktr /dev/tuner and /dev/vbi */ 457 #if (__FreeBSD_version >=500000) 458 if (unit == 0) { 459 bktr->bktrdev_alias = make_dev_alias(bktr->bktrdev, "bktr"); 460 bktr->tunerdev_alias= make_dev_alias(bktr->tunerdev, "tuner"); 461 bktr->vbidev_alias = make_dev_alias(bktr->vbidev, "vbi"); 462 } 463 #endif 464 465 return 0; 466 467 fail: 468 if (bktr->res_irq) 469 bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq); 470 if (bktr->res_mem) 471 bus_release_resource(dev, SYS_RES_IRQ, bktr->mem_rid, bktr->res_mem); 472 return error; 473 474 } 475 476 /* 477 * the detach routine. 478 */ 479 static int 480 bktr_detach( device_t dev ) 481 { 482 unsigned int unit; 483 484 struct bktr_softc *bktr = device_get_softc(dev); 485 486 unit = device_get_unit(dev); 487 488 /* Disable the brooktree device */ 489 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 490 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 491 492 /* Note: We do not free memory for RISC programs, grab buffer, vbi buffers */ 493 /* The memory is retained by the bktr_mem module so we can unload and */ 494 /* then reload the main bktr driver module */ 495 496 /* Unregister the /dev/bktrN, tunerN and vbiN devices */ 497 destroy_dev(bktr->vbidev); 498 destroy_dev(bktr->tunerdev); 499 destroy_dev(bktr->bktrdev); 500 501 /* If this is unit 0, then destroy the alias entries too */ 502 #if (__FreeBSD_version >=500000) 503 if (unit == 0) { 504 destroy_dev(bktr->vbidev_alias); 505 destroy_dev(bktr->tunerdev_alias); 506 destroy_dev(bktr->bktrdev_alias); 507 } 508 #endif 509 510 /* 511 * Deallocate resources. 512 */ 513 bus_teardown_intr(dev, bktr->res_irq, bktr->res_ih); 514 bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq); 515 bus_release_resource(dev, SYS_RES_MEMORY, bktr->mem_rid, bktr->res_mem); 516 517 return 0; 518 } 519 520 /* 521 * the shutdown routine. 522 */ 523 static int 524 bktr_shutdown( device_t dev ) 525 { 526 struct bktr_softc *bktr = device_get_softc(dev); 527 528 /* Disable the brooktree device */ 529 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 530 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 531 532 return 0; 533 } 534 535 536 /* 537 * Special Memory Allocation 538 */ 539 vm_offset_t 540 get_bktr_mem( int unit, unsigned size ) 541 { 542 vm_offset_t addr = 0; 543 544 addr = vm_page_alloc_contig(size, 0, 0xffffffff, 1<<24); 545 if (addr == 0) 546 addr = vm_page_alloc_contig(size, 0, 0xffffffff, PAGE_SIZE); 547 if (addr == 0) { 548 printf("bktr%d: Unable to allocate %d bytes of memory.\n", 549 unit, size); 550 } 551 552 return( addr ); 553 } 554 555 556 /*--------------------------------------------------------- 557 ** 558 ** BrookTree 848 character device driver routines 559 ** 560 **--------------------------------------------------------- 561 */ 562 563 #define VIDEO_DEV 0x00 564 #define TUNER_DEV 0x01 565 #define VBI_DEV 0x02 566 567 #define UNIT(x) ((x) & 0x0f) 568 #define FUNCTION(x) (x >> 4) 569 570 /* 571 * 572 */ 573 int 574 bktr_open( dev_t dev, int flags, int fmt, struct proc *p ) 575 { 576 bktr_ptr_t bktr; 577 int unit; 578 int result; 579 580 unit = UNIT( minor(dev) ); 581 582 /* Get the device data */ 583 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit); 584 if (bktr == NULL) { 585 /* the device is no longer valid/functioning */ 586 return (ENXIO); 587 } 588 589 if (!(bktr->flags & METEOR_INITIALIZED)) /* device not found */ 590 return( ENXIO ); 591 592 /* Record that the device is now busy */ 593 device_busy(devclass_get_device(bktr_devclass, unit)); 594 595 596 if (bt848_card != -1) { 597 if ((bt848_card >> 8 == unit ) && 598 ( (bt848_card & 0xff) < Bt848_MAX_CARD )) { 599 if ( bktr->bt848_card != (bt848_card & 0xff) ) { 600 bktr->bt848_card = (bt848_card & 0xff); 601 probeCard(bktr, FALSE, unit); 602 } 603 } 604 } 605 606 if (bt848_tuner != -1) { 607 if ((bt848_tuner >> 8 == unit ) && 608 ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) { 609 if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) { 610 bktr->bt848_tuner = (bt848_tuner & 0xff); 611 probeCard(bktr, FALSE, unit); 612 } 613 } 614 } 615 616 if (bt848_reverse_mute != -1) { 617 if ((bt848_reverse_mute >> 8) == unit ) { 618 bktr->reverse_mute = bt848_reverse_mute & 0xff; 619 } 620 } 621 622 if (bt848_slow_msp_audio != -1) { 623 if ((bt848_slow_msp_audio >> 8) == unit ) { 624 bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff); 625 } 626 } 627 628 switch ( FUNCTION( minor(dev) ) ) { 629 case VIDEO_DEV: 630 result = video_open( bktr ); 631 break; 632 case TUNER_DEV: 633 result = tuner_open( bktr ); 634 break; 635 case VBI_DEV: 636 result = vbi_open( bktr ); 637 break; 638 default: 639 result = ENXIO; 640 break; 641 } 642 643 /* If there was an error opening the device, undo the busy status */ 644 if (result != 0) 645 device_unbusy(devclass_get_device(bktr_devclass, unit)); 646 return( result ); 647 } 648 649 650 /* 651 * 652 */ 653 int 654 bktr_close( dev_t dev, int flags, int fmt, struct proc *p ) 655 { 656 bktr_ptr_t bktr; 657 int unit; 658 int result; 659 660 unit = UNIT( minor(dev) ); 661 662 /* Get the device data */ 663 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit); 664 if (bktr == NULL) { 665 /* the device is no longer valid/functioning */ 666 return (ENXIO); 667 } 668 669 switch ( FUNCTION( minor(dev) ) ) { 670 case VIDEO_DEV: 671 result = video_close( bktr ); 672 break; 673 case TUNER_DEV: 674 result = tuner_close( bktr ); 675 break; 676 case VBI_DEV: 677 result = vbi_close( bktr ); 678 break; 679 default: 680 return (ENXIO); 681 break; 682 } 683 684 device_unbusy(devclass_get_device(bktr_devclass, unit)); 685 return( result ); 686 } 687 688 689 /* 690 * 691 */ 692 int 693 bktr_read( dev_t dev, struct uio *uio, int ioflag ) 694 { 695 bktr_ptr_t bktr; 696 int unit; 697 698 unit = UNIT(minor(dev)); 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 switch ( FUNCTION( minor(dev) ) ) { 708 case VIDEO_DEV: 709 return( video_read( bktr, unit, dev, uio ) ); 710 case VBI_DEV: 711 return( vbi_read( bktr, uio, ioflag ) ); 712 } 713 return( ENXIO ); 714 } 715 716 717 /* 718 * 719 */ 720 int 721 bktr_write( dev_t dev, struct uio *uio, int ioflag ) 722 { 723 return( EINVAL ); /* XXX or ENXIO ? */ 724 } 725 726 727 /* 728 * 729 */ 730 int 731 bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr ) 732 { 733 bktr_ptr_t bktr; 734 int unit; 735 736 unit = UNIT(minor(dev)); 737 738 /* Get the device data */ 739 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit); 740 if (bktr == NULL) { 741 /* the device is no longer valid/functioning */ 742 return (ENXIO); 743 } 744 745 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */ 746 return( ENOMEM ); 747 748 switch ( FUNCTION( minor(dev) ) ) { 749 case VIDEO_DEV: 750 return( video_ioctl( bktr, unit, cmd, arg, pr ) ); 751 case TUNER_DEV: 752 return( tuner_ioctl( bktr, unit, cmd, arg, pr ) ); 753 } 754 755 return( ENXIO ); 756 } 757 758 759 /* 760 * 761 */ 762 int 763 bktr_mmap( dev_t dev, vm_offset_t offset, int nprot ) 764 { 765 int unit; 766 bktr_ptr_t bktr; 767 768 unit = UNIT(minor(dev)); 769 770 if (FUNCTION(minor(dev)) > 0) /* only allow mmap on /dev/bktr[n] */ 771 return( -1 ); 772 773 /* Get the device data */ 774 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit); 775 if (bktr == NULL) { 776 /* the device is no longer valid/functioning */ 777 return (-1); 778 } 779 780 if (nprot & PROT_EXEC) 781 return( -1 ); 782 783 if (offset < 0) 784 return( -1 ); 785 786 if (offset >= bktr->alloc_pages * PAGE_SIZE) 787 return( -1 ); 788 789 return( atop(vtophys(bktr->bigbuf) + offset) ); 790 } 791 792 int bktr_poll( dev_t dev, int events, struct proc *p) 793 { 794 int unit; 795 bktr_ptr_t bktr; 796 int revents = 0; 797 DECLARE_INTR_MASK(s); 798 799 unit = UNIT(minor(dev)); 800 801 /* Get the device data */ 802 bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit); 803 if (bktr == NULL) { 804 /* the device is no longer valid/functioning */ 805 return (ENXIO); 806 } 807 808 DISABLE_INTR(s); 809 810 if (events & (POLLIN | POLLRDNORM)) { 811 812 switch ( FUNCTION( minor(dev) ) ) { 813 case VBI_DEV: 814 if(bktr->vbisize == 0) 815 selrecord(p, &bktr->vbi_select); 816 else 817 revents |= events & (POLLIN | POLLRDNORM); 818 break; 819 } 820 } 821 822 ENABLE_INTR(s); 823 824 return (revents); 825 } 826 827 #endif /* FreeBSD 4.x specific kernel interface routines */ 828 829 /**********************************/ 830 /* *** FreeBSD 2.2.x and 3.x *** */ 831 /**********************************/ 832 833 #if ((__FreeBSD__ == 2) || (__FreeBSD__ == 3)) 834 835 static bktr_reg_t brooktree[ NBKTR ]; 836 837 static const char* bktr_probe( pcici_t tag, pcidi_t type ); 838 static void bktr_attach( pcici_t tag, int unit ); 839 static void bktr_intr(void *arg) { common_bktr_intr(arg); } 840 841 static u_long bktr_count; 842 843 static struct pci_device bktr_device = { 844 "bktr", 845 bktr_probe, 846 bktr_attach, 847 &bktr_count 848 }; 849 850 DATA_SET (pcidevice_set, bktr_device); 851 852 static d_open_t bktr_open; 853 static d_close_t bktr_close; 854 static d_read_t bktr_read; 855 static d_write_t bktr_write; 856 static d_ioctl_t bktr_ioctl; 857 static d_mmap_t bktr_mmap; 858 static d_poll_t bktr_poll; 859 860 #define CDEV_MAJOR 92 861 static struct cdevsw bktr_cdevsw = 862 { 863 bktr_open, bktr_close, bktr_read, bktr_write, 864 bktr_ioctl, nostop, nullreset, nodevtotty, 865 bktr_poll, bktr_mmap, NULL, "bktr", 866 NULL, -1 867 }; 868 869 static int bktr_devsw_installed; 870 871 static void 872 bktr_drvinit( void *unused ) 873 { 874 dev_t dev; 875 876 if ( ! bktr_devsw_installed ) { 877 dev = makedev(CDEV_MAJOR, 0); 878 cdevsw_add(&dev,&bktr_cdevsw, NULL); 879 bktr_devsw_installed = 1; 880 } 881 } 882 883 SYSINIT(bktrdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,bktr_drvinit,NULL) 884 885 /* 886 * the boot time probe routine. 887 */ 888 static const char* 889 bktr_probe( pcici_t tag, pcidi_t type ) 890 { 891 unsigned int rev = pci_conf_read( tag, PCIR_REVID) & 0x000000ff; 892 893 if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE) 894 { 895 switch (PCI_PRODUCT(type)) { 896 case PCI_PRODUCT_BROOKTREE_BT848: 897 if (rev == 0x12) return("BrookTree 848A"); 898 else return("BrookTree 848"); 899 case PCI_PRODUCT_BROOKTREE_BT849: 900 return("BrookTree 849A"); 901 case PCI_PRODUCT_BROOKTREE_BT878: 902 return("BrookTree 878"); 903 case PCI_PRODUCT_BROOKTREE_BT879: 904 return("BrookTree 879"); 905 } 906 }; 907 908 return ((char *)0); 909 } 910 911 /* 912 * the attach routine. 913 */ 914 static void 915 bktr_attach( pcici_t tag, int unit ) 916 { 917 bktr_ptr_t bktr; 918 u_long latency; 919 u_long fun; 920 unsigned int rev; 921 unsigned long base; 922 #ifdef BROOKTREE_IRQ 923 u_long old_irq, new_irq; 924 #endif 925 926 bktr = &brooktree[unit]; 927 928 if (unit >= NBKTR) { 929 printf("brooktree%d: attach: only %d units configured.\n", 930 unit, NBKTR); 931 printf("brooktree%d: attach: invalid unit number.\n", unit); 932 return; 933 } 934 935 /* build the device name for bktr_name() */ 936 snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit); 937 938 /* Enable Memory Mapping */ 939 fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG); 940 pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 2); 941 942 /* Enable Bus Mastering */ 943 fun = pci_conf_read(tag, PCI_COMMAND_STATUS_REG); 944 pci_conf_write(tag, PCI_COMMAND_STATUS_REG, fun | 4); 945 946 bktr->tag = tag; 947 948 949 /* 950 * Map control/status registers 951 */ 952 pci_map_mem( tag, PCI_MAP_REG_START, (vm_offset_t *) &base, 953 &bktr->phys_base ); 954 #if (__FreeBSD_version >= 300000) 955 bktr->memt = I386_BUS_SPACE_MEM; /* XXX should use proper bus space */ 956 bktr->memh = (bus_space_handle_t)base; /* XXX functions here */ 957 #endif 958 959 /* 960 * Disable the brooktree device 961 */ 962 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 963 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 964 965 #ifdef BROOKTREE_IRQ /* from the configuration file */ 966 old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG); 967 pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ); 968 new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG); 969 printf("bktr%d: attach: irq changed from %d to %d\n", 970 unit, (old_irq & 0xff), (new_irq & 0xff)); 971 #endif 972 973 /* 974 * setup the interrupt handling routine 975 */ 976 pci_map_int(tag, bktr_intr, (void*) bktr, &tty_imask); 977 978 979 /* Update the Device Control Register */ 980 /* on Bt878 and Bt879 cards */ 981 fun = pci_conf_read(tag, 0x40); 982 fun = fun | 1; /* Enable writes to the sub-system vendor ID */ 983 984 #if defined( BKTR_430_FX_MODE ) 985 if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n"); 986 fun = fun | 2; /* Enable Intel 430 FX compatibility mode */ 987 #endif 988 989 #if defined( BKTR_SIS_VIA_MODE ) 990 if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n"); 991 fun = fun | 4; /* Enable SiS/VIA compatibility mode (usefull for 992 OPTi chipset motherboards too */ 993 #endif 994 pci_conf_write(tag, 0x40, fun); 995 996 997 /* XXX call bt848_i2c dependent attach() routine */ 998 #if defined(BKTR_USE_FREEBSD_SMBUS) 999 if (bt848_i2c_attach(unit, bktr, &bktr->i2c_sc)) 1000 printf("bktr%d: i2c_attach: can't attach\n", unit); 1001 #endif 1002 1003 1004 /* 1005 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if 1006 * you have more than four, then 16 would probably be a better value. 1007 */ 1008 #ifndef BROOKTREE_DEF_LATENCY_VALUE 1009 #define BROOKTREE_DEF_LATENCY_VALUE 10 1010 #endif 1011 latency = pci_conf_read(tag, PCI_LATENCY_TIMER); 1012 latency = (latency >> 8) & 0xff; 1013 if ( bootverbose ) { 1014 if (latency) 1015 printf("brooktree%d: PCI bus latency is", unit); 1016 else 1017 printf("brooktree%d: PCI bus latency was 0 changing to", 1018 unit); 1019 } 1020 if ( !latency ) { 1021 latency = BROOKTREE_DEF_LATENCY_VALUE; 1022 pci_conf_write(tag, PCI_LATENCY_TIMER, latency<<8); 1023 } 1024 if ( bootverbose ) { 1025 printf(" %d.\n", (int) latency); 1026 } 1027 1028 1029 /* read the pci device id and revision id */ 1030 fun = pci_conf_read(tag, PCI_ID_REG); 1031 rev = pci_conf_read(tag, PCIR_REVID) & 0x000000ff; 1032 1033 /* call the common attach code */ 1034 common_bktr_attach( bktr, unit, fun, rev ); 1035 1036 } 1037 1038 1039 /* 1040 * Special Memory Allocation 1041 */ 1042 vm_offset_t 1043 get_bktr_mem( int unit, unsigned size ) 1044 { 1045 vm_offset_t addr = 0; 1046 1047 addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff, 1<<24); 1048 if (addr == 0) 1049 addr = vm_page_alloc_contig(size, 0x100000, 0xffffffff, 1050 PAGE_SIZE); 1051 if (addr == 0) { 1052 printf("bktr%d: Unable to allocate %d bytes of memory.\n", 1053 unit, size); 1054 } 1055 1056 return( addr ); 1057 } 1058 1059 /*--------------------------------------------------------- 1060 ** 1061 ** BrookTree 848 character device driver routines 1062 ** 1063 **--------------------------------------------------------- 1064 */ 1065 1066 1067 #define VIDEO_DEV 0x00 1068 #define TUNER_DEV 0x01 1069 #define VBI_DEV 0x02 1070 1071 #define UNIT(x) ((x) & 0x0f) 1072 #define FUNCTION(x) ((x >> 4) & 0x0f) 1073 1074 1075 /* 1076 * 1077 */ 1078 int 1079 bktr_open( dev_t dev, int flags, int fmt, struct proc *p ) 1080 { 1081 bktr_ptr_t bktr; 1082 int unit; 1083 1084 unit = UNIT( minor(dev) ); 1085 if (unit >= NBKTR) /* unit out of range */ 1086 return( ENXIO ); 1087 1088 bktr = &(brooktree[ unit ]); 1089 1090 if (!(bktr->flags & METEOR_INITIALIZED)) /* device not found */ 1091 return( ENXIO ); 1092 1093 1094 if (bt848_card != -1) { 1095 if ((bt848_card >> 8 == unit ) && 1096 ( (bt848_card & 0xff) < Bt848_MAX_CARD )) { 1097 if ( bktr->bt848_card != (bt848_card & 0xff) ) { 1098 bktr->bt848_card = (bt848_card & 0xff); 1099 probeCard(bktr, FALSE, unit); 1100 } 1101 } 1102 } 1103 1104 if (bt848_tuner != -1) { 1105 if ((bt848_tuner >> 8 == unit ) && 1106 ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) { 1107 if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) { 1108 bktr->bt848_tuner = (bt848_tuner & 0xff); 1109 probeCard(bktr, FALSE, unit); 1110 } 1111 } 1112 } 1113 1114 if (bt848_reverse_mute != -1) { 1115 if ((bt848_reverse_mute >> 8) == unit ) { 1116 bktr->reverse_mute = bt848_reverse_mute & 0xff; 1117 } 1118 } 1119 1120 if (bt848_slow_msp_audio != -1) { 1121 if ((bt848_slow_msp_audio >> 8) == unit ) { 1122 bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff); 1123 } 1124 } 1125 1126 switch ( FUNCTION( minor(dev) ) ) { 1127 case VIDEO_DEV: 1128 return( video_open( bktr ) ); 1129 case TUNER_DEV: 1130 return( tuner_open( bktr ) ); 1131 case VBI_DEV: 1132 return( vbi_open( bktr ) ); 1133 } 1134 return( ENXIO ); 1135 } 1136 1137 1138 /* 1139 * 1140 */ 1141 int 1142 bktr_close( dev_t dev, int flags, int fmt, struct proc *p ) 1143 { 1144 bktr_ptr_t bktr; 1145 int unit; 1146 1147 unit = UNIT( minor(dev) ); 1148 if (unit >= NBKTR) /* unit out of range */ 1149 return( ENXIO ); 1150 1151 bktr = &(brooktree[ unit ]); 1152 1153 switch ( FUNCTION( minor(dev) ) ) { 1154 case VIDEO_DEV: 1155 return( video_close( bktr ) ); 1156 case TUNER_DEV: 1157 return( tuner_close( bktr ) ); 1158 case VBI_DEV: 1159 return( vbi_close( bktr ) ); 1160 } 1161 1162 return( ENXIO ); 1163 } 1164 1165 /* 1166 * 1167 */ 1168 int 1169 bktr_read( dev_t dev, struct uio *uio, int ioflag ) 1170 { 1171 bktr_ptr_t bktr; 1172 int unit; 1173 1174 unit = UNIT(minor(dev)); 1175 if (unit >= NBKTR) /* unit out of range */ 1176 return( ENXIO ); 1177 1178 bktr = &(brooktree[unit]); 1179 1180 switch ( FUNCTION( minor(dev) ) ) { 1181 case VIDEO_DEV: 1182 return( video_read( bktr, unit, dev, uio ) ); 1183 case VBI_DEV: 1184 return( vbi_read( bktr, uio, ioflag ) ); 1185 } 1186 return( ENXIO ); 1187 } 1188 1189 1190 /* 1191 * 1192 */ 1193 int 1194 bktr_write( dev_t dev, struct uio *uio, int ioflag ) 1195 { 1196 return( EINVAL ); /* XXX or ENXIO ? */ 1197 } 1198 1199 /* 1200 * 1201 */ 1202 int 1203 bktr_ioctl( dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr ) 1204 { 1205 bktr_ptr_t bktr; 1206 int unit; 1207 1208 unit = UNIT(minor(dev)); 1209 if (unit >= NBKTR) /* unit out of range */ 1210 return( ENXIO ); 1211 1212 bktr = &(brooktree[ unit ]); 1213 1214 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */ 1215 return( ENOMEM ); 1216 1217 switch ( FUNCTION( minor(dev) ) ) { 1218 case VIDEO_DEV: 1219 return( video_ioctl( bktr, unit, cmd, arg, pr ) ); 1220 case TUNER_DEV: 1221 return( tuner_ioctl( bktr, unit, cmd, arg, pr ) ); 1222 } 1223 1224 return( ENXIO ); 1225 } 1226 1227 /* 1228 * bktr_mmap. 1229 * Note: 2.2.5/2.2.6/2.2.7/3.0 users must manually 1230 * edit the line below and change "vm_offset_t" to "int" 1231 */ 1232 int bktr_mmap( dev_t dev, vm_offset_t offset, int nprot ) 1233 1234 { 1235 int unit; 1236 bktr_ptr_t bktr; 1237 1238 unit = UNIT(minor(dev)); 1239 1240 if (unit >= NBKTR || FUNCTION(minor(dev)) > 0) 1241 return( -1 ); 1242 1243 bktr = &(brooktree[ unit ]); 1244 1245 if (nprot & PROT_EXEC) 1246 return( -1 ); 1247 1248 if (offset < 0) 1249 return( -1 ); 1250 1251 if (offset >= bktr->alloc_pages * PAGE_SIZE) 1252 return( -1 ); 1253 1254 return( i386_btop(vtophys(bktr->bigbuf) + offset) ); 1255 } 1256 1257 int bktr_poll( dev_t dev, int events, struct proc *p) 1258 { 1259 int unit; 1260 bktr_ptr_t bktr; 1261 int revents = 0; 1262 1263 unit = UNIT(minor(dev)); 1264 1265 if (unit >= NBKTR) 1266 return( -1 ); 1267 1268 bktr = &(brooktree[ unit ]); 1269 1270 disable_intr(); 1271 1272 if (events & (POLLIN | POLLRDNORM)) { 1273 1274 switch ( FUNCTION( minor(dev) ) ) { 1275 case VBI_DEV: 1276 if(bktr->vbisize == 0) 1277 selrecord(p, &bktr->vbi_select); 1278 else 1279 revents |= events & (POLLIN | POLLRDNORM); 1280 break; 1281 } 1282 } 1283 1284 enable_intr(); 1285 1286 return (revents); 1287 } 1288 1289 1290 #endif /* FreeBSD 2.2.x and 3.x specific kernel interface routines */ 1291 1292 1293 /*****************/ 1294 /* *** BSDI *** */ 1295 /*****************/ 1296 1297 #if defined(__bsdi__) 1298 #endif /* __bsdi__ BSDI specific kernel interface routines */ 1299 1300 1301 /*****************************/ 1302 /* *** OpenBSD / NetBSD *** */ 1303 /*****************************/ 1304 #if defined(__NetBSD__) || defined(__OpenBSD__) 1305 1306 #define IPL_VIDEO IPL_BIO /* XXX */ 1307 1308 static int bktr_intr(void *arg) { return common_bktr_intr(arg); } 1309 1310 #define bktr_open bktropen 1311 #define bktr_close bktrclose 1312 #define bktr_read bktrread 1313 #define bktr_write bktrwrite 1314 #define bktr_ioctl bktrioctl 1315 #define bktr_mmap bktrmmap 1316 1317 #if defined(__OpenBSD__) 1318 static int bktr_probe __P((struct device *, void *, void *)); 1319 #else 1320 static int bktr_probe __P((struct device *, struct cfdata *, void *)); 1321 #endif 1322 static void bktr_attach __P((struct device *, struct device *, void *)); 1323 1324 struct cfattach bktr_ca = { 1325 sizeof(struct bktr_softc), bktr_probe, bktr_attach 1326 }; 1327 1328 #if defined(__NetBSD__) 1329 extern struct cfdriver bktr_cd; 1330 #else 1331 struct cfdriver bktr_cd = { 1332 NULL, "bktr", DV_DULL 1333 }; 1334 #endif 1335 1336 1337 #if NRADIO > 0 1338 /* for radio(4) */ 1339 int bktr_get_info(void *, struct radio_info *); 1340 int bktr_set_info(void *, struct radio_info *); 1341 1342 struct radio_hw_if bktr_hw_if = { 1343 NULL, /* open */ 1344 NULL, /* close */ 1345 bktr_get_info, 1346 bktr_set_info, 1347 NULL /* search */ 1348 }; 1349 #endif 1350 1351 int 1352 bktr_probe(parent, match, aux) 1353 struct device *parent; 1354 #if defined(__OpenBSD__) 1355 void *match; 1356 #else 1357 struct cfdata *match; 1358 #endif 1359 void *aux; 1360 { 1361 struct pci_attach_args *pa = aux; 1362 1363 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_BROOKTREE && 1364 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT848 || 1365 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT849 || 1366 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT878 || 1367 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT879)) 1368 return 1; 1369 1370 return 0; 1371 } 1372 1373 1374 /* 1375 * the attach routine. 1376 */ 1377 static void 1378 bktr_attach(struct device *parent, struct device *self, void *aux) 1379 { 1380 bktr_ptr_t bktr; 1381 u_long latency; 1382 u_long fun; 1383 unsigned int rev; 1384 1385 #if defined(__OpenBSD__) 1386 struct pci_attach_args *pa = aux; 1387 pci_chipset_tag_t pc = pa->pa_pc; 1388 1389 pci_intr_handle_t ih; 1390 const char *intrstr; 1391 int retval; 1392 int unit; 1393 1394 bktr = (bktr_ptr_t)self; 1395 unit = bktr->bktr_dev.dv_unit; 1396 1397 bktr->pc = pa->pa_pc; 1398 bktr->tag = pa->pa_tag; 1399 bktr->dmat = pa->pa_dmat; 1400 1401 /* 1402 * map memory 1403 */ 1404 bktr->memt = pa->pa_memt; 1405 retval = pci_mem_find(pc, pa->pa_tag, PCI_MAPREG_START, 1406 &bktr->phys_base, &bktr->obmemsz, NULL); 1407 if (!retval) 1408 retval = bus_space_map(pa->pa_memt, bktr->phys_base, 1409 bktr->obmemsz, 0, &bktr->memh); 1410 if (retval) { 1411 printf(": couldn't map memory\n"); 1412 return; 1413 } 1414 1415 1416 /* 1417 * map interrupt 1418 */ 1419 if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin, 1420 pa->pa_intrline, &ih)) { 1421 printf(": couldn't map interrupt\n"); 1422 return; 1423 } 1424 intrstr = pci_intr_string(pa->pa_pc, ih); 1425 1426 bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO, 1427 bktr_intr, bktr, bktr->bktr_dev.dv_xname); 1428 if (bktr->ih == NULL) { 1429 printf(": couldn't establish interrupt"); 1430 if (intrstr != NULL) 1431 printf(" at %s", intrstr); 1432 printf("\n"); 1433 return; 1434 } 1435 1436 if (intrstr != NULL) 1437 printf(": %s\n", intrstr); 1438 #endif /* __OpenBSD__ */ 1439 1440 #if defined(__NetBSD__) 1441 struct pci_attach_args *pa = aux; 1442 pci_intr_handle_t ih; 1443 const char *intrstr; 1444 int retval; 1445 int unit; 1446 1447 bktr = (bktr_ptr_t)self; 1448 unit = bktr->bktr_dev.dv_unit; 1449 bktr->dmat = pa->pa_dmat; 1450 1451 printf("\n"); 1452 1453 /* 1454 * map memory 1455 */ 1456 retval = pci_mapreg_map(pa, PCI_MAPREG_START, 1457 PCI_MAPREG_TYPE_MEM 1458 | PCI_MAPREG_MEM_TYPE_32BIT, 0, 1459 &bktr->memt, &bktr->memh, NULL, 1460 &bktr->obmemsz); 1461 DPR(("pci_mapreg_map: memt %lx, memh %x, size %x\n", 1462 (long unsigned)bktr->memt, (u_int)bktr->memh, 1463 (u_int)bktr->obmemsz)); 1464 if (retval) { 1465 printf("%s: couldn't map memory\n", bktr_name(bktr)); 1466 return; 1467 } 1468 1469 /* 1470 * Disable the brooktree device 1471 */ 1472 OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED); 1473 OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED); 1474 1475 /* 1476 * map interrupt 1477 */ 1478 if (pci_intr_map(pa, &ih)) { 1479 printf("%s: couldn't map interrupt\n", 1480 bktr_name(bktr)); 1481 return; 1482 } 1483 intrstr = pci_intr_string(pa->pa_pc, ih); 1484 bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO, 1485 bktr_intr, bktr); 1486 if (bktr->ih == NULL) { 1487 printf("%s: couldn't establish interrupt", 1488 bktr_name(bktr)); 1489 if (intrstr != NULL) 1490 printf(" at %s", intrstr); 1491 printf("\n"); 1492 return; 1493 } 1494 if (intrstr != NULL) 1495 printf("%s: interrupting at %s\n", bktr_name(bktr), 1496 intrstr); 1497 #endif /* __NetBSD__ */ 1498 1499 /* 1500 * PCI latency timer. 32 is a good value for 4 bus mastering slots, if 1501 * you have more than four, then 16 would probably be a better value. 1502 */ 1503 #ifndef BROOKTREE_DEF_LATENCY_VALUE 1504 #define BROOKTREE_DEF_LATENCY_VALUE 10 1505 #endif 1506 latency = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_LATENCY_TIMER); 1507 latency = (latency >> 8) & 0xff; 1508 1509 if (!latency) { 1510 if (bootverbose) { 1511 printf("%s: PCI bus latency was 0 changing to %d", 1512 bktr_name(bktr), BROOKTREE_DEF_LATENCY_VALUE); 1513 } 1514 latency = BROOKTREE_DEF_LATENCY_VALUE; 1515 pci_conf_write(pa->pa_pc, pa->pa_tag, 1516 PCI_LATENCY_TIMER, latency<<8); 1517 } 1518 1519 1520 /* Enabled Bus Master 1521 XXX: check if all old DMA is stopped first (e.g. after warm 1522 boot) */ 1523 fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG); 1524 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 1525 fun | PCI_COMMAND_MASTER_ENABLE); 1526 1527 /* read the pci id and determine the card type */ 1528 fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG); 1529 rev = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG) & 0x000000ff; 1530 1531 common_bktr_attach(bktr, unit, fun, rev); 1532 1533 #if NRADIO > 0 1534 /* attach to radio(4) */ 1535 radio_attach_mi(&bktr_hw_if, bktr, &bktr->bktr_dev); 1536 #endif 1537 } 1538 1539 1540 /* 1541 * Special Memory Allocation 1542 */ 1543 #if defined (__NetBSD__) 1544 vaddr_t 1545 #else 1546 vm_offset_t 1547 #endif 1548 get_bktr_mem(bktr, dmapp, size) 1549 bktr_ptr_t bktr; 1550 bus_dmamap_t *dmapp; 1551 unsigned int size; 1552 { 1553 bus_dma_tag_t dmat = bktr->dmat; 1554 bus_dma_segment_t seg; 1555 bus_size_t align; 1556 int rseg; 1557 caddr_t kva; 1558 1559 /* 1560 * Allocate a DMA area 1561 */ 1562 align = 1 << 24; 1563 if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1, 1564 &rseg, BUS_DMA_NOWAIT)) { 1565 align = PAGE_SIZE; 1566 if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1, 1567 &rseg, BUS_DMA_NOWAIT)) { 1568 printf("%s: Unable to dmamem_alloc of %d bytes\n", 1569 bktr_name(bktr), size); 1570 return 0; 1571 } 1572 } 1573 if (bus_dmamem_map(dmat, &seg, rseg, size, 1574 &kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) { 1575 printf("%s: Unable to dmamem_map of %d bytes\n", 1576 bktr_name(bktr), size); 1577 bus_dmamem_free(dmat, &seg, rseg); 1578 return 0; 1579 } 1580 #ifdef __OpenBSD__ 1581 bktr->dm_mapsize = size; 1582 #endif 1583 /* 1584 * Create and locd the DMA map for the DMA area 1585 */ 1586 if (bus_dmamap_create(dmat, size, 1, size, 0, BUS_DMA_NOWAIT, dmapp)) { 1587 printf("%s: Unable to dmamap_create of %d bytes\n", 1588 bktr_name(bktr), size); 1589 bus_dmamem_unmap(dmat, kva, size); 1590 bus_dmamem_free(dmat, &seg, rseg); 1591 return 0; 1592 } 1593 if (bus_dmamap_load(dmat, *dmapp, kva, size, NULL, BUS_DMA_NOWAIT)) { 1594 printf("%s: Unable to dmamap_load of %d bytes\n", 1595 bktr_name(bktr), size); 1596 bus_dmamem_unmap(dmat, kva, size); 1597 bus_dmamem_free(dmat, &seg, rseg); 1598 bus_dmamap_destroy(dmat, *dmapp); 1599 return 0; 1600 } 1601 #if defined(__NetBSD__) 1602 return (vaddr_t)kva; 1603 #else 1604 return (vm_offset_t)kva; 1605 #endif 1606 } 1607 1608 void 1609 free_bktr_mem(bktr, dmap, kva) 1610 bktr_ptr_t bktr; 1611 bus_dmamap_t dmap; 1612 #if defined(__NetBSD__) 1613 vaddr_t kva; 1614 #else 1615 vm_offset_t kva; 1616 #endif 1617 { 1618 bus_dma_tag_t dmat = bktr->dmat; 1619 1620 #ifdef __NetBSD__ 1621 bus_dmamem_unmap(dmat, (caddr_t)kva, dmap->dm_mapsize); 1622 #else 1623 bus_dmamem_unmap(dmat, (caddr_t)kva, bktr->dm_mapsize); 1624 #endif 1625 bus_dmamem_free(dmat, dmap->dm_segs, 1); 1626 bus_dmamap_destroy(dmat, dmap); 1627 } 1628 1629 1630 /*--------------------------------------------------------- 1631 ** 1632 ** BrookTree 848 character device driver routines 1633 ** 1634 **--------------------------------------------------------- 1635 */ 1636 1637 1638 #define VIDEO_DEV 0x00 1639 #define TUNER_DEV 0x01 1640 #define VBI_DEV 0x02 1641 1642 #define UNIT(x) (minor((x) & 0x0f)) 1643 #define FUNCTION(x) (minor((x >> 4) & 0x0f)) 1644 1645 /* 1646 * 1647 */ 1648 int 1649 bktr_open(dev_t dev, int flags, int fmt, struct proc *p) 1650 { 1651 bktr_ptr_t bktr; 1652 int unit; 1653 1654 unit = UNIT(dev); 1655 1656 /* unit out of range */ 1657 if ((unit >= bktr_cd.cd_ndevs) || (bktr_cd.cd_devs[unit] == NULL)) 1658 return(ENXIO); 1659 1660 bktr = bktr_cd.cd_devs[unit]; 1661 1662 if (!(bktr->flags & METEOR_INITIALIZED)) /* device not found */ 1663 return(ENXIO); 1664 1665 switch (FUNCTION(dev)) { 1666 case VIDEO_DEV: 1667 return(video_open(bktr)); 1668 case TUNER_DEV: 1669 return(tuner_open(bktr)); 1670 case VBI_DEV: 1671 return(vbi_open(bktr)); 1672 } 1673 1674 return(ENXIO); 1675 } 1676 1677 1678 /* 1679 * 1680 */ 1681 int 1682 bktr_close(dev_t dev, int flags, int fmt, struct proc *p) 1683 { 1684 bktr_ptr_t bktr; 1685 int unit; 1686 1687 unit = UNIT(dev); 1688 1689 bktr = bktr_cd.cd_devs[unit]; 1690 1691 switch (FUNCTION(dev)) { 1692 case VIDEO_DEV: 1693 return(video_close(bktr)); 1694 case TUNER_DEV: 1695 return(tuner_close(bktr)); 1696 case VBI_DEV: 1697 return(vbi_close(bktr)); 1698 } 1699 1700 return(ENXIO); 1701 } 1702 1703 /* 1704 * 1705 */ 1706 int 1707 bktr_read(dev_t dev, struct uio *uio, int ioflag) 1708 { 1709 bktr_ptr_t bktr; 1710 int unit; 1711 1712 unit = UNIT(dev); 1713 1714 bktr = bktr_cd.cd_devs[unit]; 1715 1716 switch (FUNCTION(dev)) { 1717 case VIDEO_DEV: 1718 return(video_read(bktr, unit, dev, uio)); 1719 case VBI_DEV: 1720 return(vbi_read(bktr, uio, ioflag)); 1721 } 1722 1723 return(ENXIO); 1724 } 1725 1726 1727 /* 1728 * 1729 */ 1730 int 1731 bktr_write(dev_t dev, struct uio *uio, int ioflag) 1732 { 1733 /* operation not supported */ 1734 return(EOPNOTSUPP); 1735 } 1736 1737 /* 1738 * 1739 */ 1740 int 1741 bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct proc* pr) 1742 { 1743 bktr_ptr_t bktr; 1744 int unit; 1745 1746 unit = UNIT(dev); 1747 1748 bktr = bktr_cd.cd_devs[unit]; 1749 1750 if (bktr->bigbuf == 0) /* no frame buffer allocated (ioctl failed) */ 1751 return(ENOMEM); 1752 1753 switch (FUNCTION(dev)) { 1754 case VIDEO_DEV: 1755 return(video_ioctl(bktr, unit, cmd, arg, pr)); 1756 case TUNER_DEV: 1757 return(tuner_ioctl(bktr, unit, cmd, arg, pr)); 1758 } 1759 1760 return(ENXIO); 1761 } 1762 1763 /* 1764 * 1765 */ 1766 paddr_t 1767 bktr_mmap(dev_t dev, off_t offset, int nprot) 1768 { 1769 int unit; 1770 bktr_ptr_t bktr; 1771 1772 unit = UNIT(dev); 1773 1774 if (FUNCTION(dev) > 0) /* only allow mmap on /dev/bktr[n] */ 1775 return(-1); 1776 1777 bktr = bktr_cd.cd_devs[unit]; 1778 1779 if ((vaddr_t)offset < 0) 1780 return(-1); 1781 1782 if ((vaddr_t)offset >= bktr->alloc_pages * PAGE_SIZE) 1783 return(-1); 1784 1785 #ifdef __NetBSD__ 1786 return (bus_dmamem_mmap(bktr->dmat, bktr->dm_mem->dm_segs, 1, 1787 (vaddr_t)offset, nprot, BUS_DMA_WAITOK)); 1788 #else 1789 return(i386_btop(vtophys(bktr->bigbuf) + offset)); 1790 #endif 1791 } 1792 1793 #if NRADIO > 0 1794 int 1795 bktr_set_info(void *v, struct radio_info *ri) 1796 { 1797 struct bktr_softc *sc = v; 1798 u_int32_t freq; 1799 1800 if (ri->mute) { 1801 /* mute the audio stream by switching the mux */ 1802 set_audio(sc, AUDIO_MUTE); 1803 1804 /* disable drivers on the GPIO port that controls the MUXes */ 1805 OUTL(sc, BKTR_GPIO_OUT_EN, INL(sc, BKTR_GPIO_OUT_EN) & 1806 ~sc->card.gpio_mux_bits); 1807 } else { 1808 /* enable drivers on the GPIO port that controls the MUXes */ 1809 OUTL(sc, BKTR_GPIO_OUT_EN, INL(sc, BKTR_GPIO_OUT_EN) | 1810 sc->card.gpio_mux_bits); 1811 1812 /* unmute the audio stream */ 1813 set_audio(sc, AUDIO_UNMUTE); 1814 init_audio_devices(sc); 1815 } 1816 1817 freq = ri->freq / 10; 1818 set_audio(sc, AUDIO_INTERN); /* use internal audio */ 1819 temp_mute(sc, TRUE); 1820 ri->freq = tv_freq(sc, freq, FM_RADIO_FREQUENCY) * 10; 1821 temp_mute(sc, FALSE); 1822 1823 return (0); 1824 } 1825 1826 int 1827 bktr_get_info(void *v, struct radio_info *ri) 1828 { 1829 struct bktr_softc *sc = v; 1830 struct TVTUNER *tv = &sc->tuner; 1831 int status; 1832 1833 status = get_tuner_status(sc); 1834 1835 #define STATUSBIT_STEREO 0x10 1836 ri->mute = (int)sc->audio_mute_state ? 1 : 0; 1837 ri->stereo = (status & STATUSBIT_STEREO) ? 1 : 0; 1838 ri->caps = RADIO_CAPS_DETECT_STEREO | RADIO_CAPS_HW_AFC; 1839 ri->freq = tv->frequency * 10; 1840 ri->info = (status & STATUSBIT_STEREO) ? RADIO_INFO_STEREO : 0; 1841 #undef STATUSBIT_STEREO 1842 1843 /* not yet supported */ 1844 ri->volume = ri->rfreq = ri->lock = 0; 1845 1846 return (0); 1847 } 1848 #endif 1849 1850 #endif /* __NetBSD__ || __OpenBSD__ */ 1851
Indexes created Thu Oct 30 16:09:53 GMT 2025