sys/dev/bktr/bktr_os.c

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