The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/bktr/bktr_os.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * 1. Redistributions of source code must retain the 
    3  * Copyright (c) 1997 Amancio Hasty, 1999 Roger Hardiman
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. All advertising materials mentioning features or use of this software
   15  *    must display the following acknowledgement:
   16  *      This product includes software developed by Amancio Hasty and
   17  *      Roger Hardiman
   18  * 4. The name of the author may not be used to endorse or promote products 
   19  *    derived from this software without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   24  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   31  * POSSIBILITY OF SUCH DAMAGE.
   32  */
   33 
   34 #include <sys/cdefs.h>
   35 __FBSDID("$FreeBSD: releng/8.4/sys/dev/bktr/bktr_os.c 196405 2009-08-20 20:23:28Z jhb $");
   36 
   37 /*
   38  * This is part of the Driver for Video Capture Cards (Frame grabbers)
   39  * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
   40  * chipset.
   41  * Copyright Roger Hardiman and Amancio Hasty.
   42  *
   43  * bktr_os : This has all the Operating System dependant code,
   44  *             probe/attach and open/close/ioctl/read/mmap
   45  *             memory allocation
   46  *             PCI bus interfacing
   47  */
   48 
   49 #include "opt_bktr.h"           /* include any kernel config options */
   50 
   51 #define FIFO_RISC_DISABLED      0
   52 #define ALL_INTS_DISABLED       0
   53 
   54 
   55 /*******************/
   56 /* *** FreeBSD *** */
   57 /*******************/
   58 #ifdef __FreeBSD__
   59 
   60 #include <sys/param.h>
   61 #include <sys/systm.h>
   62 #include <sys/conf.h>
   63 #include <sys/uio.h>
   64 #include <sys/kernel.h>
   65 #include <sys/module.h>
   66 #include <sys/signalvar.h>
   67 #include <sys/malloc.h>
   68 #include <sys/mman.h>
   69 #include <sys/poll.h>
   70 #if __FreeBSD_version >= 500014
   71 #include <sys/selinfo.h>
   72 #else
   73 #include <sys/select.h>
   74 #endif
   75 
   76 #include <vm/vm.h>
   77 #include <vm/vm_kern.h>
   78 #include <vm/pmap.h>
   79 #include <vm/vm_extern.h>
   80 
   81 #include <sys/bus.h>            /* used by smbus and newbus */
   82 
   83 #include <machine/bus.h>        /* used by bus space and newbus */
   84 #include <sys/bus.h>
   85 
   86 #include <sys/rman.h>           /* used by newbus */
   87 #include <machine/resource.h>   /* used by newbus */
   88 
   89 #if (__FreeBSD_version < 500000)
   90 #include <machine/clock.h>              /* for DELAY */
   91 #include <pci/pcivar.h>
   92 #include <pci/pcireg.h>
   93 #else
   94 #include <dev/pci/pcivar.h>
   95 #include <dev/pci/pcireg.h>
   96 #endif
   97 
   98 #include <sys/sysctl.h>
   99 int bt848_card = -1; 
  100 int bt848_tuner = -1;
  101 int bt848_reverse_mute = -1; 
  102 int bt848_format = -1;
  103 int bt848_slow_msp_audio = -1;
  104 #ifdef BKTR_NEW_MSP34XX_DRIVER
  105 int bt848_stereo_once = 0;      /* no continuous stereo monitoring */
  106 int bt848_amsound = 0;          /* hard-wire AM sound at 6.5 Hz (france),
  107                                    the autoscan seems work well only with FM... */
  108 int bt848_dolby = 0;
  109 #endif
  110 
  111 SYSCTL_NODE(_hw, OID_AUTO, bt848, CTLFLAG_RW, 0, "Bt848 Driver mgmt");
  112 SYSCTL_INT(_hw_bt848, OID_AUTO, card, CTLFLAG_RW, &bt848_card, -1, "");
  113 SYSCTL_INT(_hw_bt848, OID_AUTO, tuner, CTLFLAG_RW, &bt848_tuner, -1, "");
  114 SYSCTL_INT(_hw_bt848, OID_AUTO, reverse_mute, CTLFLAG_RW, &bt848_reverse_mute, -1, "");
  115 SYSCTL_INT(_hw_bt848, OID_AUTO, format, CTLFLAG_RW, &bt848_format, -1, "");
  116 SYSCTL_INT(_hw_bt848, OID_AUTO, slow_msp_audio, CTLFLAG_RW, &bt848_slow_msp_audio, -1, "");
  117 #ifdef BKTR_NEW_MSP34XX_DRIVER
  118 SYSCTL_INT(_hw_bt848, OID_AUTO, stereo_once, CTLFLAG_RW, &bt848_stereo_once, 0, "");
  119 SYSCTL_INT(_hw_bt848, OID_AUTO, amsound, CTLFLAG_RW, &bt848_amsound, 0, "");
  120 SYSCTL_INT(_hw_bt848, OID_AUTO, dolby, CTLFLAG_RW, &bt848_dolby, 0, "");
  121 #endif
  122 
  123 #endif /* end freebsd section */
  124 
  125 
  126 
  127 /****************/
  128 /* *** BSDI *** */
  129 /****************/
  130 #ifdef __bsdi__
  131 #endif /* __bsdi__ */
  132 
  133 
  134 /**************************/
  135 /* *** OpenBSD/NetBSD *** */
  136 /**************************/
  137 #if defined(__NetBSD__) || defined(__OpenBSD__)
  138 
  139 #include <sys/param.h>
  140 #include <sys/systm.h>
  141 #include <sys/conf.h>
  142 #include <sys/uio.h>
  143 #include <sys/kernel.h>
  144 #include <sys/signalvar.h>
  145 #include <sys/mman.h>
  146 #include <sys/poll.h>
  147 #include <sys/select.h>
  148 #include <sys/vnode.h>
  149 
  150 #include <vm/vm.h>
  151 
  152 #include <dev/bktr/ioctl_bt848.h>       /* extensions to ioctl_meteor.h */
  153 
  154 #ifndef __NetBSD__
  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 : 0)
  169 #else
  170 #define DPR(x)
  171 #endif
  172 #endif /* __NetBSD__ || __OpenBSD__ */
  173 
  174 
  175 #ifdef __NetBSD__
  176 #include <dev/ic/bt8xx.h>       /* NetBSD location for .h files */
  177 #include <dev/pci/bktr/bktr_reg.h>
  178 #include <dev/pci/bktr/bktr_tuner.h>
  179 #include <dev/pci/bktr/bktr_card.h>
  180 #include <dev/pci/bktr/bktr_audio.h>
  181 #include <dev/pci/bktr/bktr_core.h>
  182 #include <dev/pci/bktr/bktr_os.h>
  183 #else                                   /* Traditional location for .h files */
  184 #include <dev/bktr/ioctl_meteor.h>
  185 #include <dev/bktr/ioctl_bt848.h>       /* extensions to ioctl_meteor.h */
  186 #include <dev/bktr/bktr_reg.h>
  187 #include <dev/bktr/bktr_tuner.h>
  188 #include <dev/bktr/bktr_card.h>
  189 #include <dev/bktr/bktr_audio.h>
  190 #include <dev/bktr/bktr_core.h>
  191 #include <dev/bktr/bktr_os.h>
  192 
  193 #if defined(BKTR_USE_FREEBSD_SMBUS)
  194 #include <dev/bktr/bktr_i2c.h>
  195 
  196 #include "iicbb_if.h"
  197 #include "smbus_if.h"
  198 #endif
  199 #endif
  200 
  201 
  202 /****************************/
  203 /* *** FreeBSD 4.x code *** */
  204 /****************************/
  205 
  206 static int      bktr_probe( device_t dev );
  207 static int      bktr_attach( device_t dev );
  208 static int      bktr_detach( device_t dev );
  209 static int      bktr_shutdown( device_t dev );
  210 static void     bktr_intr(void *arg) { common_bktr_intr(arg); }
  211 
  212 static device_method_t bktr_methods[] = {
  213         /* Device interface */
  214         DEVMETHOD(device_probe,         bktr_probe),
  215         DEVMETHOD(device_attach,        bktr_attach),
  216         DEVMETHOD(device_detach,        bktr_detach),
  217         DEVMETHOD(device_shutdown,      bktr_shutdown),
  218 
  219 #if defined(BKTR_USE_FREEBSD_SMBUS)
  220         /* iicbb interface */
  221         DEVMETHOD(iicbb_callback,       bti2c_iic_callback),
  222         DEVMETHOD(iicbb_setsda,         bti2c_iic_setsda),
  223         DEVMETHOD(iicbb_setscl,         bti2c_iic_setscl),
  224         DEVMETHOD(iicbb_getsda,         bti2c_iic_getsda),
  225         DEVMETHOD(iicbb_getscl,         bti2c_iic_getscl),
  226         DEVMETHOD(iicbb_reset,          bti2c_iic_reset),
  227         
  228         /* smbus interface */
  229         DEVMETHOD(smbus_callback,       bti2c_smb_callback),
  230         DEVMETHOD(smbus_writeb,         bti2c_smb_writeb),
  231         DEVMETHOD(smbus_writew,         bti2c_smb_writew),
  232         DEVMETHOD(smbus_readb,          bti2c_smb_readb),
  233 #endif
  234 
  235         { 0, 0 }
  236 };
  237 
  238 static driver_t bktr_driver = {
  239         "bktr",
  240         bktr_methods,
  241         sizeof(struct bktr_softc),
  242 };
  243 
  244 static devclass_t bktr_devclass;
  245 
  246 static  d_open_t        bktr_open;
  247 static  d_close_t       bktr_close;
  248 static  d_read_t        bktr_read;
  249 static  d_write_t       bktr_write;
  250 static  d_ioctl_t       bktr_ioctl;
  251 static  d_mmap_t        bktr_mmap;
  252 static  d_poll_t        bktr_poll;
  253 
  254 static struct cdevsw bktr_cdevsw = {
  255         .d_version =    D_VERSION,
  256         .d_flags =      D_NEEDGIANT,
  257         .d_open =       bktr_open,
  258         .d_close =      bktr_close,
  259         .d_read =       bktr_read,
  260         .d_write =      bktr_write,
  261         .d_ioctl =      bktr_ioctl,
  262         .d_poll =       bktr_poll,
  263         .d_mmap =       bktr_mmap,
  264         .d_name =       "bktr",
  265 };
  266 
  267 #ifdef BKTR_USE_FREEBSD_SMBUS
  268 #include <dev/iicbus/iiconf.h>
  269 #include <dev/smbus/smbconf.h>
  270 MODULE_DEPEND(bktr, iicbb, IICBB_MINVER, IICBB_MODVER, IICBB_MAXVER);
  271 MODULE_DEPEND(bktr, iicbus, IICBUS_MINVER, IICBUS_MODVER, IICBUS_MAXVER);
  272 MODULE_DEPEND(bktr, smbus, SMBUS_MINVER, SMBUS_MODVER, SMBUS_MAXVER);
  273 #endif
  274 DRIVER_MODULE(bktr, pci, bktr_driver, bktr_devclass, 0, 0);
  275 MODULE_DEPEND(bktr, bktr_mem, 1,1,1);
  276 MODULE_VERSION(bktr, 1);
  277 
  278 
  279 /*
  280  * the boot time probe routine.
  281  */
  282 static int
  283 bktr_probe( device_t dev )
  284 {
  285         unsigned int type = pci_get_devid(dev);
  286         unsigned int rev  = pci_get_revid(dev);
  287 
  288         if (PCI_VENDOR(type) == PCI_VENDOR_BROOKTREE)
  289         {
  290                 switch (PCI_PRODUCT(type)) {
  291                 case PCI_PRODUCT_BROOKTREE_BT848:
  292                         if (rev == 0x12)
  293                                 device_set_desc(dev, "BrookTree 848A");
  294                         else
  295                                 device_set_desc(dev, "BrookTree 848");
  296                         return BUS_PROBE_DEFAULT;
  297                 case PCI_PRODUCT_BROOKTREE_BT849:
  298                         device_set_desc(dev, "BrookTree 849A");
  299                         return BUS_PROBE_DEFAULT;
  300                 case PCI_PRODUCT_BROOKTREE_BT878:
  301                         device_set_desc(dev, "BrookTree 878");
  302                         return BUS_PROBE_DEFAULT;
  303                 case PCI_PRODUCT_BROOKTREE_BT879:
  304                         device_set_desc(dev, "BrookTree 879");
  305                         return BUS_PROBE_DEFAULT;
  306                 }
  307         };
  308 
  309         return ENXIO;
  310 }
  311 
  312 
  313 /*
  314  * the attach routine.
  315  */
  316 static int
  317 bktr_attach( device_t dev )
  318 {
  319         u_long          latency;
  320         u_long          fun;
  321         u_long          val;
  322         unsigned int    rev;
  323         unsigned int    unit;
  324         int             error = 0;
  325 #ifdef BROOKTREE_IRQ
  326         u_long          old_irq, new_irq;
  327 #endif 
  328 
  329         struct bktr_softc *bktr = device_get_softc(dev);
  330 
  331         unit = device_get_unit(dev);
  332 
  333         /* build the device name for bktr_name() */
  334         snprintf(bktr->bktr_xname, sizeof(bktr->bktr_xname), "bktr%d",unit);
  335 
  336         /*
  337          * Enable bus mastering and Memory Mapped device
  338          */
  339         val = pci_read_config(dev, PCIR_COMMAND, 4);
  340         val |= (PCIM_CMD_MEMEN|PCIM_CMD_BUSMASTEREN);
  341         pci_write_config(dev, PCIR_COMMAND, val, 4);
  342 
  343         /*
  344          * Map control/status registers.
  345          */
  346         bktr->mem_rid = PCIR_BAR(0);
  347         bktr->res_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 
  348                                         &bktr->mem_rid, RF_ACTIVE);
  349 
  350         if (!bktr->res_mem) {
  351                 device_printf(dev, "could not map memory\n");
  352                 error = ENXIO;
  353                 goto fail;
  354         }
  355         bktr->memt = rman_get_bustag(bktr->res_mem);
  356         bktr->memh = rman_get_bushandle(bktr->res_mem);
  357 
  358 
  359         /*
  360          * Disable the brooktree device
  361          */
  362         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
  363         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
  364 
  365 
  366 #ifdef BROOKTREE_IRQ            /* from the configuration file */
  367         old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
  368         pci_conf_write(tag, PCI_INTERRUPT_REG, BROOKTREE_IRQ);
  369         new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
  370         printf("bktr%d: attach: irq changed from %d to %d\n",
  371                 unit, (old_irq & 0xff), (new_irq & 0xff));
  372 #endif 
  373 
  374         /*
  375          * Allocate our interrupt.
  376          */
  377         bktr->irq_rid = 0;
  378         bktr->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, 
  379                                 &bktr->irq_rid, RF_SHAREABLE | RF_ACTIVE);
  380         if (bktr->res_irq == NULL) {
  381                 device_printf(dev, "could not map interrupt\n");
  382                 error = ENXIO;
  383                 goto fail;
  384         }
  385 
  386         error = bus_setup_intr(dev, bktr->res_irq, INTR_TYPE_TTY,
  387                                NULL, bktr_intr, bktr, &bktr->res_ih);
  388         if (error) {
  389                 device_printf(dev, "could not setup irq\n");
  390                 goto fail;
  391 
  392         }
  393 
  394 
  395         /* Update the Device Control Register */
  396         /* on Bt878 and Bt879 cards           */
  397         fun = pci_read_config( dev, 0x40, 2);
  398         fun = fun | 1;  /* Enable writes to the sub-system vendor ID */
  399 
  400 #if defined( BKTR_430_FX_MODE )
  401         if (bootverbose) printf("Using 430 FX chipset compatibilty mode\n");
  402         fun = fun | 2;  /* Enable Intel 430 FX compatibility mode */
  403 #endif
  404 
  405 #if defined( BKTR_SIS_VIA_MODE )
  406         if (bootverbose) printf("Using SiS/VIA chipset compatibilty mode\n");
  407         fun = fun | 4;  /* Enable SiS/VIA compatibility mode (usefull for
  408                            OPTi chipset motherboards too */
  409 #endif
  410         pci_write_config(dev, 0x40, fun, 2);
  411 
  412 #if defined(BKTR_USE_FREEBSD_SMBUS)
  413         if (bt848_i2c_attach(dev))
  414                 printf("bktr%d: i2c_attach: can't attach\n", unit);
  415 #endif
  416 
  417 /*
  418  * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
  419  * you have more than four, then 16 would probably be a better value.
  420  */
  421 #ifndef BROOKTREE_DEF_LATENCY_VALUE
  422 #define BROOKTREE_DEF_LATENCY_VALUE     10
  423 #endif
  424         latency = pci_read_config(dev, PCI_LATENCY_TIMER, 4);
  425         latency = (latency >> 8) & 0xff;
  426         if ( bootverbose ) {
  427                 if (latency)
  428                         printf("brooktree%d: PCI bus latency is", unit);
  429                 else
  430                         printf("brooktree%d: PCI bus latency was 0 changing to",
  431                                 unit);
  432         }
  433         if ( !latency ) {
  434                 latency = BROOKTREE_DEF_LATENCY_VALUE;
  435                 pci_write_config(dev, PCI_LATENCY_TIMER, latency<<8, 4);
  436         }
  437         if ( bootverbose ) {
  438                 printf(" %d.\n", (int) latency);
  439         }
  440 
  441         /* read the pci device id and revision id */
  442         fun = pci_get_devid(dev);
  443         rev = pci_get_revid(dev);
  444 
  445         /* call the common attach code */
  446         common_bktr_attach( bktr, unit, fun, rev );
  447 
  448         /* make the device entries */
  449         bktr->bktrdev = make_dev(&bktr_cdevsw, unit,    
  450                                 0, 0, 0444, "bktr%d",  unit);
  451         bktr->tunerdev= make_dev(&bktr_cdevsw, unit+16,
  452                                 0, 0, 0444, "tuner%d", unit);
  453         bktr->vbidev  = make_dev(&bktr_cdevsw, unit+32,
  454                                 0, 0, 0444, "vbi%d"  , unit);
  455 
  456 
  457         /* if this is unit 0 (/dev/bktr0, /dev/tuner0, /dev/vbi0) then make */
  458         /* alias entries to /dev/bktr /dev/tuner and /dev/vbi */
  459 #if (__FreeBSD_version >=500000)
  460         if (unit == 0) {
  461                 bktr->bktrdev_alias = make_dev_alias(bktr->bktrdev,  "bktr");
  462                 bktr->tunerdev_alias= make_dev_alias(bktr->tunerdev, "tuner");
  463                 bktr->vbidev_alias  = make_dev_alias(bktr->vbidev,   "vbi");
  464         }
  465 #endif
  466 
  467         return 0;
  468 
  469 fail:
  470         if (bktr->res_irq)
  471                 bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
  472         if (bktr->res_mem)
  473                 bus_release_resource(dev, SYS_RES_MEMORY, bktr->mem_rid, bktr->res_mem);
  474         return error;
  475 
  476 }
  477 
  478 /*
  479  * the detach routine.
  480  */
  481 static int
  482 bktr_detach( device_t dev )
  483 {
  484         struct bktr_softc *bktr = device_get_softc(dev);
  485 
  486 #ifdef BKTR_NEW_MSP34XX_DRIVER
  487         /* Disable the soundchip and kernel thread */
  488         if (bktr->msp3400c_info != NULL)
  489                 msp_detach(bktr);
  490 #endif
  491 
  492         /* Disable the brooktree device */
  493         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
  494         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
  495 
  496 #if defined(BKTR_USE_FREEBSD_SMBUS)
  497         if (bt848_i2c_detach(dev))
  498                 printf("bktr%d: i2c_attach: can't attach\n",
  499                      device_get_unit(dev));
  500 #endif
  501 #ifdef USE_VBIMUTEX
  502         mtx_destroy(&bktr->vbimutex);
  503 #endif
  504 
  505         /* Note: We do not free memory for RISC programs, grab buffer, vbi buffers */
  506         /* The memory is retained by the bktr_mem module so we can unload and */
  507         /* then reload the main bktr driver module */
  508 
  509         /* Unregister the /dev/bktrN, tunerN and vbiN devices,
  510          * the aliases for unit 0 are automatically destroyed */
  511         destroy_dev(bktr->vbidev);
  512         destroy_dev(bktr->tunerdev);
  513         destroy_dev(bktr->bktrdev);
  514 
  515         /*
  516          * Deallocate resources.
  517          */
  518         bus_teardown_intr(dev, bktr->res_irq, bktr->res_ih);
  519         bus_release_resource(dev, SYS_RES_IRQ, bktr->irq_rid, bktr->res_irq);
  520         bus_release_resource(dev, SYS_RES_MEMORY, bktr->mem_rid, bktr->res_mem);
  521          
  522         return 0;
  523 }
  524 
  525 /*
  526  * the shutdown routine.
  527  */
  528 static int
  529 bktr_shutdown( device_t dev )
  530 {
  531         struct bktr_softc *bktr = device_get_softc(dev);
  532 
  533         /* Disable the brooktree device */
  534         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
  535         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
  536 
  537         return 0;
  538 }
  539 
  540 
  541 /*
  542  * Special Memory Allocation
  543  */
  544 vm_offset_t
  545 get_bktr_mem( int unit, unsigned size )
  546 {
  547         vm_offset_t     addr = 0;
  548 
  549         addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
  550             0xffffffff, 1<<24, 0);
  551         if (addr == 0)
  552                 addr = (vm_offset_t)contigmalloc(size, M_DEVBUF, M_NOWAIT, 0,
  553                     0xffffffff, PAGE_SIZE, 0);
  554         if (addr == 0) {
  555                 printf("bktr%d: Unable to allocate %d bytes of memory.\n",
  556                         unit, size);
  557         }
  558 
  559         return( addr );
  560 }
  561 
  562 
  563 /*---------------------------------------------------------
  564 **
  565 **      BrookTree 848 character device driver routines
  566 **
  567 **---------------------------------------------------------
  568 */
  569 
  570 #define VIDEO_DEV       0x00
  571 #define TUNER_DEV       0x01
  572 #define VBI_DEV         0x02
  573 
  574 #define UNIT(x)         ((x) & 0x0f)
  575 #define FUNCTION(x)     (x >> 4)
  576 
  577 /*
  578  * 
  579  */
  580 static int
  581 bktr_open( struct cdev *dev, int flags, int fmt, struct thread *td )
  582 {
  583         bktr_ptr_t      bktr;
  584         int             unit;
  585         int             result;
  586 
  587         unit = UNIT( dev2unit(dev) );
  588 
  589         /* Get the device data */
  590         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
  591         if (bktr == NULL) {
  592                 /* the device is no longer valid/functioning */
  593                 return (ENXIO);
  594         }
  595 
  596         if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
  597                 return( ENXIO );        
  598 
  599         /* Record that the device is now busy */
  600         device_busy(devclass_get_device(bktr_devclass, unit)); 
  601 
  602 
  603         if (bt848_card != -1) {
  604           if ((bt848_card >> 8   == unit ) &&
  605              ( (bt848_card & 0xff) < Bt848_MAX_CARD )) {
  606             if ( bktr->bt848_card != (bt848_card & 0xff) ) {
  607               bktr->bt848_card = (bt848_card & 0xff);
  608               probeCard(bktr, FALSE, unit);
  609             }
  610           }
  611         }
  612 
  613         if (bt848_tuner != -1) {
  614           if ((bt848_tuner >> 8   == unit ) &&
  615              ( (bt848_tuner & 0xff) < Bt848_MAX_TUNER )) {
  616             if ( bktr->bt848_tuner != (bt848_tuner & 0xff) ) {
  617               bktr->bt848_tuner = (bt848_tuner & 0xff);
  618               probeCard(bktr, FALSE, unit);
  619             }
  620           }
  621         }
  622 
  623         if (bt848_reverse_mute != -1) {
  624           if ((bt848_reverse_mute >> 8)   == unit ) {
  625             bktr->reverse_mute = bt848_reverse_mute & 0xff;
  626           }
  627         }
  628 
  629         if (bt848_slow_msp_audio != -1) {
  630           if ((bt848_slow_msp_audio >> 8) == unit ) {
  631               bktr->slow_msp_audio = (bt848_slow_msp_audio & 0xff);
  632           }
  633         }
  634 
  635 #ifdef BKTR_NEW_MSP34XX_DRIVER
  636         if (bt848_stereo_once != 0) {
  637           if ((bt848_stereo_once >> 8) == unit ) {
  638               bktr->stereo_once = (bt848_stereo_once & 0xff);
  639           }
  640         }
  641 
  642         if (bt848_amsound != -1) {
  643           if ((bt848_amsound >> 8) == unit ) {
  644               bktr->amsound = (bt848_amsound & 0xff);
  645           }
  646         }
  647 
  648         if (bt848_dolby != -1) {
  649           if ((bt848_dolby >> 8) == unit ) {
  650               bktr->dolby = (bt848_dolby & 0xff);
  651           }
  652         }
  653 #endif
  654 
  655         switch ( FUNCTION( dev2unit(dev) ) ) {
  656         case VIDEO_DEV:
  657                 result = video_open( bktr );
  658                 break;
  659         case TUNER_DEV:
  660                 result = tuner_open( bktr );
  661                 break;
  662         case VBI_DEV:
  663                 result = vbi_open( bktr );
  664                 break;
  665         default:
  666                 result = ENXIO;
  667                 break;
  668         }
  669 
  670         /* If there was an error opening the device, undo the busy status */
  671         if (result != 0)
  672                 device_unbusy(devclass_get_device(bktr_devclass, unit)); 
  673         return( result );
  674 }
  675 
  676 
  677 /*
  678  * 
  679  */
  680 static int
  681 bktr_close( struct cdev *dev, int flags, int fmt, struct thread *td )
  682 {
  683         bktr_ptr_t      bktr;
  684         int             unit;
  685         int             result;
  686 
  687         unit = UNIT( dev2unit(dev) );
  688 
  689         /* Get the device data */
  690         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
  691         if (bktr == NULL) {
  692                 /* the device is no longer valid/functioning */
  693                 return (ENXIO);
  694         }
  695 
  696         switch ( FUNCTION( dev2unit(dev) ) ) {
  697         case VIDEO_DEV:
  698                 result = video_close( bktr );
  699                 break;
  700         case TUNER_DEV:
  701                 result = tuner_close( bktr );
  702                 break;
  703         case VBI_DEV:
  704                 result = vbi_close( bktr );
  705                 break;
  706         default:
  707                 return (ENXIO);
  708                 break;
  709         }
  710 
  711         device_unbusy(devclass_get_device(bktr_devclass, unit)); 
  712         return( result );
  713 }
  714 
  715 
  716 /*
  717  * 
  718  */
  719 static int
  720 bktr_read( struct cdev *dev, struct uio *uio, int ioflag )
  721 {
  722         bktr_ptr_t      bktr;
  723         int             unit;
  724         
  725         unit = UNIT(dev2unit(dev));
  726 
  727         /* Get the device data */
  728         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
  729         if (bktr == NULL) {
  730                 /* the device is no longer valid/functioning */
  731                 return (ENXIO);
  732         }
  733 
  734         switch ( FUNCTION( dev2unit(dev) ) ) {
  735         case VIDEO_DEV:
  736                 return( video_read( bktr, unit, dev, uio ) );
  737         case VBI_DEV:
  738                 return( vbi_read( bktr, uio, ioflag ) );
  739         }
  740         return( ENXIO );
  741 }
  742 
  743 
  744 /*
  745  * 
  746  */
  747 static int
  748 bktr_write( struct cdev *dev, struct uio *uio, int ioflag )
  749 {
  750         return( EINVAL ); /* XXX or ENXIO ? */
  751 }
  752 
  753 
  754 /*
  755  * 
  756  */
  757 static int
  758 bktr_ioctl( struct cdev *dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td )
  759 {
  760         bktr_ptr_t      bktr;
  761         int             unit;
  762 
  763         unit = UNIT(dev2unit(dev));
  764 
  765         /* Get the device data */
  766         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
  767         if (bktr == NULL) {
  768                 /* the device is no longer valid/functioning */
  769                 return (ENXIO);
  770         }
  771 
  772 #ifdef BKTR_GPIO_ACCESS
  773         if (bktr->bigbuf == 0 && cmd != BT848_GPIO_GET_EN &&
  774             cmd != BT848_GPIO_SET_EN && cmd != BT848_GPIO_GET_DATA &&
  775             cmd != BT848_GPIO_SET_DATA) /* no frame buffer allocated (ioctl failed) */
  776                 return( ENOMEM );
  777 #else
  778         if (bktr->bigbuf == 0)  /* no frame buffer allocated (ioctl failed) */
  779                 return( ENOMEM );
  780 #endif
  781 
  782         switch ( FUNCTION( dev2unit(dev) ) ) {
  783         case VIDEO_DEV:
  784                 return( video_ioctl( bktr, unit, cmd, arg, td ) );
  785         case TUNER_DEV:
  786                 return( tuner_ioctl( bktr, unit, cmd, arg, td ) );
  787         }
  788 
  789         return( ENXIO );
  790 }
  791 
  792 
  793 /*
  794  * 
  795  */
  796 static int
  797 bktr_mmap( struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot )
  798 {
  799         int             unit;
  800         bktr_ptr_t      bktr;
  801 
  802         unit = UNIT(dev2unit(dev));
  803 
  804         if (FUNCTION(dev2unit(dev)) > 0)        /* only allow mmap on /dev/bktr[n] */
  805                 return( -1 );
  806 
  807         /* Get the device data */
  808         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
  809         if (bktr == NULL) {
  810                 /* the device is no longer valid/functioning */
  811                 return (ENXIO);
  812         }
  813 
  814         if (nprot & PROT_EXEC)
  815                 return( -1 );
  816 
  817         if (offset < 0)
  818                 return( -1 );
  819 
  820         if (offset >= bktr->alloc_pages * PAGE_SIZE)
  821                 return( -1 );
  822 
  823         *paddr = vtophys(bktr->bigbuf) + offset;
  824         return( 0 );
  825 }
  826 
  827 static int
  828 bktr_poll( struct cdev *dev, int events, struct thread *td)
  829 {
  830         int             unit;
  831         bktr_ptr_t      bktr;
  832         int revents = 0; 
  833         DECLARE_INTR_MASK(s);
  834 
  835         unit = UNIT(dev2unit(dev));
  836 
  837         /* Get the device data */
  838         bktr = (struct bktr_softc*)devclass_get_softc(bktr_devclass, unit);
  839         if (bktr == NULL) {
  840                 /* the device is no longer valid/functioning */
  841                 return (ENXIO);
  842         }
  843 
  844         LOCK_VBI(bktr);
  845         DISABLE_INTR(s);
  846 
  847         if (events & (POLLIN | POLLRDNORM)) {
  848 
  849                 switch ( FUNCTION( dev2unit(dev) ) ) {
  850                 case VBI_DEV:
  851                         if(bktr->vbisize == 0)
  852                                 selrecord(td, &bktr->vbi_select);
  853                         else
  854                                 revents |= events & (POLLIN | POLLRDNORM);
  855                         break;
  856                 }
  857         }
  858 
  859         ENABLE_INTR(s);
  860         UNLOCK_VBI(bktr);
  861 
  862         return (revents);
  863 }
  864 
  865 /*****************/
  866 /* *** BSDI  *** */
  867 /*****************/
  868 
  869 #if defined(__bsdi__)
  870 #endif          /* __bsdi__ BSDI specific kernel interface routines */
  871 
  872 
  873 /*****************************/
  874 /* *** OpenBSD / NetBSD  *** */
  875 /*****************************/
  876 #if defined(__NetBSD__) || defined(__OpenBSD__)
  877 
  878 #define IPL_VIDEO       IPL_BIO         /* XXX */
  879 
  880 static  int             bktr_intr(void *arg) { return common_bktr_intr(arg); }
  881 
  882 #define bktr_open       bktropen
  883 #define bktr_close      bktrclose
  884 #define bktr_read       bktrread
  885 #define bktr_write      bktrwrite
  886 #define bktr_ioctl      bktrioctl
  887 #define bktr_mmap       bktrmmap
  888 
  889 vm_offset_t vm_page_alloc_contig(vm_offset_t, vm_offset_t,
  890                                  vm_offset_t, vm_offset_t);
  891 
  892 #if defined(__OpenBSD__)
  893 static int      bktr_probe(struct device *, void *, void *);
  894 #else
  895 static int      bktr_probe(struct device *, struct cfdata *, void *);
  896 #endif
  897 static void     bktr_attach(struct device *, struct device *, void *);
  898 
  899 struct cfattach bktr_ca = {
  900         sizeof(struct bktr_softc), bktr_probe, bktr_attach
  901 };
  902 
  903 #if defined(__NetBSD__)
  904 extern struct cfdriver bktr_cd;
  905 #else
  906 struct cfdriver bktr_cd = {
  907         NULL, "bktr", DV_DULL
  908 };
  909 #endif
  910 
  911 int
  912 bktr_probe(parent, match, aux)
  913         struct device *parent;
  914 #if defined(__OpenBSD__)
  915         void *match;
  916 #else
  917         struct cfdata *match;
  918 #endif
  919         void *aux;
  920 {
  921         struct pci_attach_args *pa = aux;
  922 
  923         if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_BROOKTREE &&
  924             (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT848 ||
  925              PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT849 ||
  926              PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT878 ||
  927              PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BROOKTREE_BT879))
  928                 return 1;
  929 
  930         return 0;
  931 }
  932 
  933 
  934 /*
  935  * the attach routine.
  936  */
  937 static void
  938 bktr_attach(struct device *parent, struct device *self, void *aux)
  939 {
  940         bktr_ptr_t      bktr;
  941         u_long          latency;
  942         u_long          fun;
  943         unsigned int    rev;
  944 
  945 #if defined(__OpenBSD__)
  946         struct pci_attach_args *pa = aux;
  947         pci_chipset_tag_t pc = pa->pa_pc;
  948 
  949         pci_intr_handle_t ih;
  950         const char *intrstr;
  951         int retval;
  952         int unit;
  953 
  954         bktr = (bktr_ptr_t)self;
  955         unit = bktr->bktr_dev.dv_unit;
  956 
  957         bktr->pc = pa->pa_pc;
  958         bktr->tag = pa->pa_tag;
  959         bktr->dmat = pa->pa_dmat;
  960 
  961         /*
  962          * map memory
  963          */
  964         bktr->memt = pa->pa_memt;
  965         retval = pci_mem_find(pc, pa->pa_tag, PCI_MAPREG_START, 
  966                               &bktr->phys_base, &bktr->obmemsz, NULL);
  967         if (!retval)
  968                 retval = bus_space_map(pa->pa_memt, bktr->phys_base,
  969                                        bktr->obmemsz, 0, &bktr->memh);
  970         if (retval) {
  971                 printf(": couldn't map memory\n");
  972                 return;
  973         }
  974 
  975 
  976         /*
  977          * map interrupt
  978          */
  979         if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
  980                          pa->pa_intrline, &ih)) {
  981                 printf(": couldn't map interrupt\n");
  982                 return;
  983         }
  984         intrstr = pci_intr_string(pa->pa_pc, ih);
  985 
  986         bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
  987                                       bktr_intr, bktr, bktr->bktr_dev.dv_xname);
  988         if (bktr->ih == NULL) {
  989                 printf(": couldn't establish interrupt");
  990                 if (intrstr != NULL)    
  991                         printf(" at %s", intrstr);
  992                 printf("\n");
  993                 return;
  994         }
  995 
  996         if (intrstr != NULL)
  997                 printf(": %s\n", intrstr);
  998 #endif /* __OpenBSD__ */
  999 
 1000 #if defined(__NetBSD__) 
 1001         struct pci_attach_args *pa = aux;
 1002         pci_intr_handle_t ih;
 1003         const char *intrstr;
 1004         int retval;
 1005         int unit;
 1006 
 1007         bktr = (bktr_ptr_t)self;
 1008         unit = bktr->bktr_dev.dv_unit;
 1009         bktr->dmat = pa->pa_dmat;
 1010 
 1011         printf("\n");
 1012 
 1013         /*
 1014          * map memory
 1015          */
 1016         retval = pci_mapreg_map(pa, PCI_MAPREG_START,
 1017                                 PCI_MAPREG_TYPE_MEM
 1018                                 | PCI_MAPREG_MEM_TYPE_32BIT, 0,
 1019                                 &bktr->memt, &bktr->memh, NULL,
 1020                                 &bktr->obmemsz);
 1021         DPR(("pci_mapreg_map: memt %x, memh %x, size %x\n",
 1022              bktr->memt, (u_int)bktr->memh, (u_int)bktr->obmemsz));
 1023         if (retval) {
 1024                 printf("%s: couldn't map memory\n", bktr_name(bktr));
 1025                 return;
 1026         }
 1027 
 1028         /*
 1029          * Disable the brooktree device
 1030          */
 1031         OUTL(bktr, BKTR_INT_MASK, ALL_INTS_DISABLED);
 1032         OUTW(bktr, BKTR_GPIO_DMA_CTL, FIFO_RISC_DISABLED);
 1033         
 1034         /*
 1035          * map interrupt
 1036          */
 1037         if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
 1038                          pa->pa_intrline, &ih)) {
 1039                 printf("%s: couldn't map interrupt\n",
 1040                        bktr_name(bktr));
 1041                 return;
 1042         }
 1043         intrstr = pci_intr_string(pa->pa_pc, ih);
 1044         bktr->ih = pci_intr_establish(pa->pa_pc, ih, IPL_VIDEO,
 1045                                       bktr_intr, bktr);
 1046         if (bktr->ih == NULL) {
 1047                 printf("%s: couldn't establish interrupt",
 1048                        bktr_name(bktr));
 1049                 if (intrstr != NULL)
 1050                         printf(" at %s", intrstr);
 1051                 printf("\n");
 1052                 return;
 1053         }
 1054         if (intrstr != NULL)
 1055                 printf("%s: interrupting at %s\n", bktr_name(bktr),
 1056                        intrstr);
 1057 #endif /* __NetBSD__ */
 1058         
 1059 /*
 1060  * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
 1061  * you have more than four, then 16 would probably be a better value.
 1062  */
 1063 #ifndef BROOKTREE_DEF_LATENCY_VALUE
 1064 #define BROOKTREE_DEF_LATENCY_VALUE     10
 1065 #endif
 1066         latency = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_LATENCY_TIMER);
 1067         latency = (latency >> 8) & 0xff;
 1068 
 1069         if (!latency) {
 1070                 if (bootverbose) {
 1071                         printf("%s: PCI bus latency was 0 changing to %d",
 1072                                bktr_name(bktr), BROOKTREE_DEF_LATENCY_VALUE);
 1073                 }
 1074                 latency = BROOKTREE_DEF_LATENCY_VALUE;
 1075                 pci_conf_write(pa->pa_pc, pa->pa_tag, 
 1076                                PCI_LATENCY_TIMER, latency<<8);
 1077         }
 1078 
 1079 
 1080         /* Enabled Bus Master
 1081            XXX: check if all old DMA is stopped first (e.g. after warm
 1082            boot) */
 1083         fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
 1084         pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
 1085                        fun | PCI_COMMAND_MASTER_ENABLE);
 1086 
 1087         /* read the pci id and determine the card type */
 1088         fun = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG);
 1089         rev = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG) & 0x000000ff;
 1090 
 1091         common_bktr_attach(bktr, unit, fun, rev);
 1092 }
 1093 
 1094 
 1095 /*
 1096  * Special Memory Allocation
 1097  */
 1098 vm_offset_t
 1099 get_bktr_mem(bktr, dmapp, size)
 1100         bktr_ptr_t bktr;
 1101         bus_dmamap_t *dmapp;
 1102         unsigned int size;
 1103 {
 1104         bus_dma_tag_t dmat = bktr->dmat;
 1105         bus_dma_segment_t seg;
 1106         bus_size_t align;
 1107         int rseg;
 1108         caddr_t kva;
 1109 
 1110         /*
 1111          * Allocate a DMA area
 1112          */
 1113         align = 1 << 24;
 1114         if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
 1115                              &rseg, BUS_DMA_NOWAIT)) {
 1116                 align = PAGE_SIZE;
 1117                 if (bus_dmamem_alloc(dmat, size, align, 0, &seg, 1,
 1118                                      &rseg, BUS_DMA_NOWAIT)) {
 1119                         printf("%s: Unable to dmamem_alloc of %d bytes\n",
 1120                                bktr_name(bktr), size);
 1121                         return 0;
 1122                 }
 1123         }
 1124         if (bus_dmamem_map(dmat, &seg, rseg, size,
 1125                            &kva, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
 1126                 printf("%s: Unable to dmamem_map of %d bytes\n",
 1127                         bktr_name(bktr), size);
 1128                 bus_dmamem_free(dmat, &seg, rseg);
 1129                 return 0;
 1130         }
 1131 #ifdef __OpenBSD__
 1132         bktr->dm_mapsize = size;
 1133 #endif
 1134         /*
 1135          * Create and locd the DMA map for the DMA area
 1136          */
 1137         if (bus_dmamap_create(dmat, size, 1, size, 0, BUS_DMA_NOWAIT, dmapp)) {
 1138                 printf("%s: Unable to dmamap_create of %d bytes\n",
 1139                         bktr_name(bktr), size);
 1140                 bus_dmamem_unmap(dmat, kva, size);
 1141                 bus_dmamem_free(dmat, &seg, rseg);
 1142                 return 0;
 1143         }
 1144         if (bus_dmamap_load(dmat, *dmapp, kva, size, NULL, BUS_DMA_NOWAIT)) {
 1145                 printf("%s: Unable to dmamap_load of %d bytes\n",
 1146                         bktr_name(bktr), size);
 1147                 bus_dmamem_unmap(dmat, kva, size);
 1148                 bus_dmamem_free(dmat, &seg, rseg);
 1149                 bus_dmamap_destroy(dmat, *dmapp);
 1150                 return 0;
 1151         }
 1152         return (vm_offset_t)kva;
 1153 }
 1154 
 1155 void
 1156 free_bktr_mem(bktr, dmap, kva)
 1157         bktr_ptr_t bktr;
 1158         bus_dmamap_t dmap;
 1159         vm_offset_t kva;
 1160 {
 1161         bus_dma_tag_t dmat = bktr->dmat;
 1162 
 1163 #ifdef __NetBSD__ 
 1164         bus_dmamem_unmap(dmat, (caddr_t)kva, dmap->dm_mapsize);
 1165 #else
 1166         bus_dmamem_unmap(dmat, (caddr_t)kva, bktr->dm_mapsize);
 1167 #endif
 1168         bus_dmamem_free(dmat, dmap->dm_segs, 1);
 1169         bus_dmamap_destroy(dmat, dmap);
 1170 }
 1171 
 1172 
 1173 /*---------------------------------------------------------
 1174 **
 1175 **      BrookTree 848 character device driver routines
 1176 **
 1177 **---------------------------------------------------------
 1178 */
 1179 
 1180 
 1181 #define VIDEO_DEV       0x00
 1182 #define TUNER_DEV       0x01
 1183 #define VBI_DEV         0x02
 1184 
 1185 #define UNIT(x)         (dev2unit((x) & 0x0f))
 1186 #define FUNCTION(x)     (dev2unit((x >> 4) & 0x0f))
 1187 
 1188 /*
 1189  * 
 1190  */
 1191 int
 1192 bktr_open(dev_t dev, int flags, int fmt, struct thread *td)
 1193 {
 1194         bktr_ptr_t      bktr;
 1195         int             unit;
 1196 
 1197         unit = UNIT(dev);
 1198 
 1199         /* unit out of range */
 1200         if ((unit > bktr_cd.cd_ndevs) || (bktr_cd.cd_devs[unit] == NULL))
 1201                 return(ENXIO);
 1202 
 1203         bktr = bktr_cd.cd_devs[unit];
 1204 
 1205         if (!(bktr->flags & METEOR_INITALIZED)) /* device not found */
 1206                 return(ENXIO);  
 1207 
 1208         switch (FUNCTION(dev)) {
 1209         case VIDEO_DEV:
 1210                 return(video_open(bktr));
 1211         case TUNER_DEV:
 1212                 return(tuner_open(bktr));
 1213         case VBI_DEV:
 1214                 return(vbi_open(bktr));
 1215         }
 1216 
 1217         return(ENXIO);
 1218 }
 1219 
 1220 
 1221 /*
 1222  * 
 1223  */
 1224 int
 1225 bktr_close(dev_t dev, int flags, int fmt, struct thread *td)
 1226 {
 1227         bktr_ptr_t      bktr;
 1228         int             unit;
 1229 
 1230         unit = UNIT(dev);
 1231 
 1232         bktr = bktr_cd.cd_devs[unit];
 1233 
 1234         switch (FUNCTION(dev)) {
 1235         case VIDEO_DEV:
 1236                 return(video_close(bktr));
 1237         case TUNER_DEV:
 1238                 return(tuner_close(bktr));
 1239         case VBI_DEV:
 1240                 return(vbi_close(bktr));
 1241         }
 1242 
 1243         return(ENXIO);
 1244 }
 1245 
 1246 /*
 1247  * 
 1248  */
 1249 int
 1250 bktr_read(dev_t dev, struct uio *uio, int ioflag)
 1251 {
 1252         bktr_ptr_t      bktr;
 1253         int             unit;
 1254         
 1255         unit = UNIT(dev);
 1256 
 1257         bktr = bktr_cd.cd_devs[unit];
 1258 
 1259         switch (FUNCTION(dev)) {
 1260         case VIDEO_DEV:
 1261                 return(video_read(bktr, unit, dev, uio));
 1262         case VBI_DEV:
 1263                 return(vbi_read(bktr, uio, ioflag));
 1264         }
 1265 
 1266         return(ENXIO);
 1267 }
 1268 
 1269 
 1270 /*
 1271  * 
 1272  */
 1273 int
 1274 bktr_write(dev_t dev, struct uio *uio, int ioflag)
 1275 {
 1276         /* operation not supported */
 1277         return(EOPNOTSUPP);
 1278 }
 1279 
 1280 /*
 1281  * 
 1282  */
 1283 int
 1284 bktr_ioctl(dev_t dev, ioctl_cmd_t cmd, caddr_t arg, int flag, struct thread *td)
 1285 {
 1286         bktr_ptr_t      bktr;
 1287         int             unit;
 1288 
 1289         unit = UNIT(dev);
 1290 
 1291         bktr = bktr_cd.cd_devs[unit];
 1292 
 1293         if (bktr->bigbuf == 0)  /* no frame buffer allocated (ioctl failed) */
 1294                 return(ENOMEM);
 1295 
 1296         switch (FUNCTION(dev)) {
 1297         case VIDEO_DEV:
 1298                 return(video_ioctl(bktr, unit, cmd, arg, pr));
 1299         case TUNER_DEV:
 1300                 return(tuner_ioctl(bktr, unit, cmd, arg, pr));
 1301         }
 1302 
 1303         return(ENXIO);
 1304 }
 1305 
 1306 /*
 1307  * 
 1308  */
 1309 paddr_t
 1310 bktr_mmap(dev_t dev, off_t offset, int nprot)
 1311 {
 1312         int             unit;
 1313         bktr_ptr_t      bktr;
 1314 
 1315         unit = UNIT(dev);
 1316 
 1317         if (FUNCTION(dev) > 0)  /* only allow mmap on /dev/bktr[n] */
 1318                 return(-1);
 1319 
 1320         bktr = bktr_cd.cd_devs[unit];
 1321 
 1322         if ((vaddr_t)offset < 0)
 1323                 return(-1);
 1324 
 1325         if ((vaddr_t)offset >= bktr->alloc_pages * PAGE_SIZE)
 1326                 return(-1);
 1327 
 1328 #ifdef __NetBSD__
 1329         return (bus_dmamem_mmap(bktr->dmat, bktr->dm_mem->dm_segs, 1,
 1330                                 (vaddr_t)offset, nprot, BUS_DMA_WAITOK));
 1331 #else
 1332         return(i386_btop(vtophys(bktr->bigbuf) + offset));
 1333 #endif
 1334 }
 1335 
 1336 #endif /* __NetBSD__ || __OpenBSD__ */

Cache object: f98af79b8c172147f5d7811062de7ab0


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.