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