bktr_mem.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  * This is part of the Driver for Video Capture Cards (Frame grabbers)
    3  * and TV Tuner cards using the Brooktree Bt848, Bt848A, Bt849A, Bt878, Bt879
    4  * chipset.
    5  * Copyright Roger Hardiman.
    6  *
    7  * bktr_mem : This kernel module allows us to keep our allocated
    8  *            contiguous memory for the video buffer, DMA programs and VBI data
    9  *            while the main bktr driver is unloaded and reloaded.
   10  *            This avoids the problem of trying to allocate contiguous each
   11  *            time the bktr driver is loaded.
   12  */
   13 
   14 /*-
   15  * 1. Redistributions of source code must retain the
   16  * Copyright (c) 2000 Roger Hardiman
   17  * All rights reserved.
   18  *
   19  * Redistribution and use in source and binary forms, with or without
   20  * modification, are permitted provided that the following conditions
   21  * are met:
   22  * 1. Redistributions of source code must retain the above copyright
   23  *    notice, this list of conditions and the following disclaimer.
   24  * 2. Redistributions in binary form must reproduce the above copyright
   25  *    notice, this list of conditions and the following disclaimer in the
   26  *    documentation and/or other materials provided with the distribution.
   27  * 3. All advertising materials mentioning features or use of this software
   28  *    must display the following acknowledgement:
   29  *      This product includes software developed by Roger Hardiman
   30  * 4. The name of the author may not be used to endorse or promote products
   31  *    derived from this software without specific prior written permission.
   32  *
   33  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   34  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   35  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   36  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   37  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   38  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   39  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   40  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   41  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   42  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   43  * POSSIBILITY OF SUCH DAMAGE.
   44  */
   45 
   46 #include <sys/cdefs.h>
   47 __FBSDID("$FreeBSD$");
   48 
   49 #include <sys/param.h>
   50 #include <sys/kernel.h>
   51 #include <sys/module.h>
   52 #include <sys/systm.h>
   53 #include <dev/bktr/bktr_mem.h>
   54 
   55 struct memory_pointers {
   56         int             addresses_stored;
   57         vm_offset_t     dma_prog;
   58         vm_offset_t     odd_dma_prog;
   59         vm_offset_t     vbidata;
   60         vm_offset_t     vbibuffer;
   61         vm_offset_t     buf;
   62 } memory_pointers;
   63 
   64 static struct memory_pointers memory_list[BKTR_MEM_MAX_DEVICES];
   65 
   66 /*************************************************************/
   67 
   68 static int
   69 bktr_mem_modevent(module_t mod, int type, void *unused){
   70 
   71         switch (type) {
   72         case MOD_LOAD:
   73                 printf("bktr_mem: memory holder loaded\n");
   74                 /*
   75                  * bzero((caddr_t)memory_list, sizeof(memory_list));
   76                  * causes a panic. So use a simple for loop for now.
   77                  */
   78                 {
   79                         int x;
   80                         unsigned char *d;
   81 
   82                         d = (unsigned char *)memory_list;
   83                         for (x = 0; x < sizeof(memory_list); x++)
   84                                 d[x] = 0;
   85                 }
   86                 return 0;
   87         case MOD_UNLOAD:
   88                 printf("bktr_mem: memory holder cannot be unloaded\n");
   89                 return EBUSY;
   90         default:
   91                 return EOPNOTSUPP;
   92                 break;
   93         }
   94         return (0);
   95 }
   96 
   97 /*************************************************************/
   98 
   99 int
  100 bktr_has_stored_addresses(int unit)
  101 {
  102 
  103         if (unit < 0 || unit >= BKTR_MEM_MAX_DEVICES) {
  104                 printf("bktr_mem: Unit number %d invalid\n", unit);
  105                 return 0;
  106         }
  107 
  108         return memory_list[unit].addresses_stored;
  109 }
  110 
  111 /*************************************************************/
  112 
  113 void
  114 bktr_store_address(int unit, int type, vm_offset_t addr)
  115 {
  116 
  117         if (unit < 0 || unit >= BKTR_MEM_MAX_DEVICES) {
  118                 printf("bktr_mem: Unit number %d invalid for memory type %d, address %p\n",
  119                        unit, type, (void *) addr);
  120                 return;
  121         }
  122 
  123         switch (type) {
  124         case BKTR_MEM_DMA_PROG:
  125                 memory_list[unit].dma_prog = addr;
  126                 memory_list[unit].addresses_stored = 1;
  127                 break;
  128         case BKTR_MEM_ODD_DMA_PROG:
  129                 memory_list[unit].odd_dma_prog = addr;
  130                 memory_list[unit].addresses_stored = 1;
  131                 break;
  132         case BKTR_MEM_VBIDATA:
  133                 memory_list[unit].vbidata = addr;
  134                 memory_list[unit].addresses_stored = 1;
  135                 break;
  136         case BKTR_MEM_VBIBUFFER:
  137                 memory_list[unit].vbibuffer = addr;
  138                 memory_list[unit].addresses_stored = 1;
  139                 break;
  140         case BKTR_MEM_BUF:
  141                 memory_list[unit].buf = addr;
  142                 memory_list[unit].addresses_stored = 1;
  143                 break;
  144         default:
  145                 printf("bktr_mem: Invalid memory type %d for bktr%d, address %p\n",
  146                         type, unit, (void *)addr);
  147                 break;
  148         }
  149 }
  150 
  151 /*************************************************************/
  152 
  153 vm_offset_t
  154 bktr_retrieve_address(int unit, int type)
  155 {
  156 
  157         if (unit < 0 || unit >= BKTR_MEM_MAX_DEVICES) {
  158                 printf("bktr_mem: Unit number %d too large for memory type %d\n",
  159                         unit, type);
  160                 return (0);
  161         }
  162         switch (type) {
  163         case BKTR_MEM_DMA_PROG:
  164                 return memory_list[unit].dma_prog;
  165         case BKTR_MEM_ODD_DMA_PROG:
  166                 return memory_list[unit].odd_dma_prog;
  167         case BKTR_MEM_VBIDATA:
  168                 return memory_list[unit].vbidata;
  169         case BKTR_MEM_VBIBUFFER:
  170                 return memory_list[unit].vbibuffer;
  171         case BKTR_MEM_BUF:
  172                 return memory_list[unit].buf;
  173         default:
  174                 printf("bktr_mem: Invalid memory type %d for bktr%d",
  175                        type, unit);
  176                 return (0);
  177         }
  178 }
  179 
  180 /*************************************************************/
  181 
  182 static moduledata_t bktr_mem_mod = {
  183         "bktr_mem",
  184         bktr_mem_modevent,
  185         0
  186 };
  187 
  188 /*
  189  * The load order is First and module type is Driver to make sure bktr_mem
  190  * loads (and initialises) before bktr when both are loaded together.
  191  */
  192 DECLARE_MODULE(bktr_mem, bktr_mem_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
  193 MODULE_VERSION(bktr_mem, 1);

Cache object: bde562c6c9386057deb22b92d379e9f1

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

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

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