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

Cache object: d013525d785deeb540ced8e6e6c3df47


[ 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.