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/pci/meteor.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*
    2  * Copyright (c) 1995 Mark Tinguely and Jim Lowe
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *      This product includes software developed by Mark Tinguely and Jim Lowe
   16  * 4. The name of the author may not be used to endorse or promote products 
   17  *    derived from this software without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   22  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   25  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   28  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   29  * POSSIBILITY OF SUCH DAMAGE.
   30  *
   31  * $FreeBSD: releng/5.0/sys/pci/meteor.c 92739 2002-03-20 02:08:01Z alfred $
   32  */
   33 
   34 /*              Change History:
   35         8/21/95         Release
   36         8/23/95         On advice from Stefan Esser, added volatile to PCI
   37                         memory pointers to remove PCI caching .
   38         8/29/95         Fixes suggested by Bruce Evans.
   39                         meteor_mmap should return -1 on error rather than 0.
   40                         unit # > NMETEOR should be unit # >= NMETEOR.
   41         10/24/95        Turn 50 Hz processing for SECAM and 60 Hz processing
   42                         off for AUTOMODE.
   43         11/11/95        Change UV from always begin signed to ioctl selected
   44                         to either signed or unsigned.
   45         12/07/95        Changed 7196 startup codes for 50 Hz as recommended
   46                         by Luigi Rizzo (luigi@iet.unipi.it)
   47         12/08/95        Clear SECAM bit in PAL/NTSC and set input field count
   48                         bits for 50 Hz mode (PAL/SECAM) before I was setting the
   49                         output count bits. by Luigi Rizzo (luigi@iet.unipi.it)
   50         12/18/95        Correct odd DMA field (never exceed, but good for safety
   51                         Changed 7196 startup codes for 50 Hz as recommended
   52                         by Luigi Rizzo (luigi@iet.unipi.it)
   53         12/19/95        Changed field toggle mode to enable (offset 0x3c)
   54                         recommended by luigi@iet.unipi.it
   55                         Added in prototyping, include file, staticizing,
   56                         and DEVFS changes from FreeBSD team.
   57                         Changed the default allocated pages from 151 (NTSC)
   58                         to 217 (PAL).
   59                         Cleaned up some old comments in iic_write().
   60                         Added a Field (even or odd) only capture mode to 
   61                         eliminate the high frequency problems with compression
   62                         algorithms.  Recommended by luigi@iet.unipi.it.
   63                         Changed geometry ioctl so if it couldn't allocated a
   64                         large enough contiguous space, it wouldn't free the
   65                         stuff it already had.
   66                         Added new mode called YUV_422 which delivers the
   67                         data in planer Y followed by U followed by V. This
   68                         differs from the standard YUV_PACKED mode in that
   69                         the chrominance (UV) data is in the correct (different)
   70                         order. This is for programs like vic and mpeg_encode
   71                         so they don't have to reorder the chrominance data.
   72                         Added field count to stats.
   73                         Increment frame count stat if capturing continuous on
   74                         even frame grabs.
   75                         Added my email address to these comments
   76                         (james@cs.uwm.edu) suggested by (luigi@iet.unipt.it :-).
   77                         Changed the user mode signal mechanism to allow the
   78                         user program to be interrupted at the end of a frame
   79                         in any one of the modes.  Added SSIGNAL ioctl.
   80                         Added a SFPS/GFPS ioctl so one may set the frames per
   81                         second that the card catpures.  This code needs to be
   82                         completed.
   83                         Changed the interrupt routine so synchronous capture
   84                         will work on fields or frames and the starting frame
   85                         can be either even or odd.
   86                         Added HALT_N_FRAMES and CONT_N_FRAMES so one could
   87                         stop and continue synchronous capture mode.
   88                         Change the tsleep/wakeup function to wait on mtr
   89                         rather than &read_intr_wait.
   90         1/22/96         Add option (METEOR_FreeBSD_210) for FreeBSD 2.1
   91                         to compile.
   92                         Changed intr so it only printed errors every 50 times.
   93                         Added unit number to error messages.
   94                         Added get_meteor_mem and enabled range checking.
   95         1/30/96         Added prelim test stuff for direct video dma transfers
   96                         from Amancio Hasty (hasty@rah.star-gate.com).  Until
   97                         we get some stuff sorted out, this will be ifdef'ed
   98                         with METEOR_DIRECT_VIDEO.  This is very dangerous to
   99                         use at present since we don't check the address that
  100                         is passed by the user!!!!!
  101         2/26/96         Added special SVIDEO input device type.
  102         2/27/96         Added meteor_reg.h file and associate types Converted
  103                         meteor.c over to using meteor.h file.  Prompted by
  104                         Lars Jonas Olsson <ljo@po.cwru.edu>.
  105         2/28/96         Added meteor RGB code from Lars Jonas Olsson
  106                         <ljo@po.cwru.edu>.  I make some mods to this code, so
  107                         I hope it still works as I don't have an rgb card to
  108                         test with.
  109         2/29/96         <ljo@po.cwru.edu> tested the meteor RGB and supplied
  110                         me with diffs.  Thanks, we now have a working RGB
  111                         version of the driver.  Still need to clean up this
  112                         code.
  113         3/1/96          Fixed a nasty little bug that was clearing the VTR
  114                         mode bit when the 7196 status was requested.
  115         3/15/96         Fixed bug introduced in previous version that
  116                         stopped the only fields mode from working.
  117                         Added METEOR{GS}TS ioctl, still needs work.
  118         3/25/96         Added YUV_9 and YUV_12 modes.  Cleaned up some of the
  119                         code and converted variables to use the new register
  120                         types.
  121         4/8/96          Fixed the a bug in with the range enable.  Pointed
  122                         out by Jim Bray.
  123         5/13/96         Fix the FPS ioctl so it actually sets the frames
  124                         per second.  Code supplied by ian@robots.ox.ac.uk.
  125                         The new code implements a new define:
  126                         METEOR_SYSTEM_DEFAULT  which should be defined as
  127                         METEOR_PAL, METEOR_SECAM, or METEOR_NTSC in your system
  128                         configuration file.  If METEOR_SYSTEM_DEFAULT isn't
  129                         defined, and there is not a signal when set_fps is
  130                         called, then the call has no effect.
  131                         Changed the spelling of PLANER to PLANAR as pointed
  132                         out by Paco Hope <paco@cs.virigina.edu> and define
  133                         PLANER to be PLANAR for backward compatibility.
  134         5/28/95         METEOR_INPUT_DEV_RCA -> METEOR_INPUT_DEV0, not
  135                         METEOR_GEO_DEV0.  Pointed out by Ian Reid,
  136                         <ian@robots.ox.ac.uk>.
  137                         METEOR_DEV_MASK should be 0x0000f000 and not 
  138                         0x2000f000, otherwise METEOR_RGB gets masked
  139                         out.  Pointed out by Ian Reid.
  140                         Changed the fps code to give even distribution for
  141                         low frame rates.  Code supplied by Ian Reid.
  142                         Fix some problems with the RGB version.  Patch supplied
  143                         by <ljo@po.cwru.edu>.
  144                         Added METEOR_FIELD_MODE to include files for a 
  145                         future version of this driver.
  146 */
  147 
  148 #ifdef COMPILING_LINT
  149 #warning "The meteor driver is broken and is not compiled with LINT"
  150 #else
  151 
  152 #include "meteor.h"
  153 
  154 #include "opt_meteor.h"
  155 
  156 #include <sys/param.h>
  157 #include <sys/systm.h>
  158 #include <sys/conf.h>
  159 #include <sys/kernel.h>
  160 #include <sys/signalvar.h>
  161 #include <sys/mman.h>
  162 #include <sys/uio.h>
  163 
  164 #if defined(METEOR_FreeBSD_210)
  165 #include <machine/cpu.h>        /* bootverbose */
  166 #endif
  167 
  168 #include <vm/vm.h>
  169 #include <vm/vm_kern.h>
  170 #include <vm/pmap.h>
  171 #include <vm/vm_extern.h>
  172 
  173 #include <pci/pcivar.h>
  174 #include <pci/pcireg.h>
  175 #include <machine/ioctl_meteor.h>
  176 #include <pci/meteor_reg.h>
  177 
  178 #ifndef COMPAT_OLDPCI
  179 #error "The meteor device requires the old pci compatibility shims"
  180 #endif
  181 
  182 static void meteor_intr(void *arg);
  183 
  184 /* 
  185  * Allocate enough memory for:
  186  *      768x576 RGB 16 or YUV (16 storage bits/pixel) = 884736 = 216 pages
  187  *
  188  * You may override this using the options "METEOR_ALLOC_PAGES=value" in your
  189  * kernel configuration file.
  190  */
  191 #ifndef METEOR_ALLOC_PAGES
  192 #define METEOR_ALLOC_PAGES 217
  193 #endif
  194 #define METEOR_ALLOC (METEOR_ALLOC_PAGES * PAGE_SIZE)
  195 
  196 static meteor_reg_t meteor[NMETEOR];
  197 #define METEOR_NUM(mtr) ((mtr - &meteor[0])/sizeof(meteor_reg_t))
  198 
  199 #define METPRI (PZERO+8)|PCATCH
  200 
  201 static  const char*     met_probe (pcici_t tag, pcidi_t type);
  202 static  void    met_attach(pcici_t tag, int unit);
  203 static  u_long  met_count;
  204 
  205 static struct   pci_device met_device = {
  206         "meteor",
  207         met_probe,
  208         met_attach,
  209         &met_count
  210 };
  211 
  212 COMPAT_PCI_DRIVER (meteor, met_device);
  213 
  214 #if defined(METEOR_FreeBSD_210) /* XXX */
  215 d_open_t        meteor_open;
  216 d_close_t       meteor_close;
  217 d_read_t        meteor_read;
  218 d_write_t       meteor_write;
  219 d_ioctl_t       meteor_ioctl;
  220 d_mmap_t        meteor_mmap;
  221 #else
  222 static  d_open_t        meteor_open;
  223 static  d_close_t       meteor_close;
  224 static  d_read_t        meteor_read;
  225 static  d_write_t       meteor_write;
  226 static  d_ioctl_t       meteor_ioctl;
  227 static  d_mmap_t        meteor_mmap;
  228 
  229 #define CDEV_MAJOR 67
  230 static struct cdevsw meteor_cdevsw = {
  231         /* open */      meteor_open,
  232         /* close */     meteor_close,
  233         /* read */      meteor_read,
  234         /* write */     meteor_write,
  235         /* ioctl */     meteor_ioctl,
  236         /* poll */      nopoll,
  237         /* mmap */      meteor_mmap,
  238         /* strategy */  nostrategy,
  239         /* name */      "meteor",
  240         /* maj */       CDEV_MAJOR,
  241         /* dump */      nodump,
  242         /* psize */     nopsize,
  243         /* flags */     0,
  244 };
  245 #endif
  246 
  247 static mreg_t saa7116_pci_default[sizeof(struct saa7116_regs)/sizeof(mreg_t)]={
  248                                 /* PCI Memory registers         */
  249                                 /* BITS   Type  Description     */
  250 /* 0x00 */      0x00000000,     /* 31:1   e*RW  DMA 1 (Even)
  251                                       0   RO    0x0             */
  252 /* 0x04 */      0x00000000,     /* 31:2   e*RW  DMA 2 (Even)
  253                                     1:0   RO    0x0             */
  254 /* 0x08 */      0x00000000,     /* 31:2   e*RW  DMA 3 (Even)
  255                                     1:0   RO    0x0             */
  256 /* 0x0c */      0x00000000,     /* 31:1   o*RW  DMA 1 (Odd)
  257                                       0   RO    0x0             */
  258 /* 0x10 */      0x00000000,     /* 31:2   o*RW  DMA 2 (Odd)
  259                                     1:0   RO    0x0             */
  260 /* 0x14 */      0x00000000,     /* 31:2   o*RW  DMA 3 (Odd)
  261                                     1:0   RO    0x0             */
  262 /* 0x18 */      0x00000500,     /* 15:2   e*RW  Stride 1 (Even)
  263                                     1:0   RO    0x0             */
  264 /* 0x1c */      0x00000000,     /* 15:2   e*RW  Stride 2 (Even)
  265                                     1:0   RO    0x0             */
  266 /* 0x20 */      0x00000000,     /* 15:2   e*RW  Stride 3 (Even)
  267                                     1:0   RO    0x0             */
  268 /* 0x24 */      0x00000500,     /* 15:2   o*RW  Stride 1 (Odd)
  269                                     1:0   RO    0x0             */
  270 /* 0x28 */      0x00000000,     /* 15:2   o*RW  Stride 2 (Odd)
  271                                     1:0   RO    0x0             */
  272 /* 0x2c */      0x00000000,     /* 15:2   o*RW  Stride 3 (Odd)
  273                                     1:0   RO    0x0             */
  274 /* 0x30 */      0xeeeeee01,     /* 31:8   *RW   Route (Even)
  275                                     7:0   *RW   Mode (Even)     */
  276 /* 0x34 */      0xeeeeee01,     /* 31:8   *RW   Route (Odd)
  277                                     7:0   *RW   Mode (Odd)      */
  278 /* 0x38 */      0x00200020,     /* 22:16  *RW   FIFO Trigger Planer Mode,
  279                                     6:0   *RW   FIFO Trigger Packed Mode */
  280 /* 0x3c */      0x00000107,     /*  9:8   *RW   Reserved (0x0)
  281                                       2   *RW   Field Toggle
  282                                       1   *RW   Reserved (0x1)
  283                                       0   *RW   Reserved (0x1)          */
  284 /* 0x40 */      0x000000c0,     /*    15  *RW   Range Enable
  285                                       14  *RW   Corrupt Disable
  286                                       11  *RR   Address Error (Odd)
  287                                       10  *RR   Address Error (Even)
  288                                       9   *RR   Field Corrupt (Odd)
  289                                       8   *RR   Field Corrupt (Even)
  290                                       7   *RW   Fifo Enable
  291                                       6   *RW   VRSTN#
  292                                       5   *RR   Field Done (Odd)
  293                                       4   *RR   Field Done (Even)
  294                                       3   *RS   Single Field Capture (Odd)
  295                                       2   *RS   Single Field Capture (Even)
  296                                       1   *RW   Capture (ODD) Continous
  297                                       0   *RW   Capture (Even) Continous */
  298 /* 0x44 */      0x00000000,     /*  7:0   *RW   Retry Wait Counter */
  299 /* 0x48 */      0x00000307,     /*    10  *RW   Interrupt mask, start of field
  300                                       9   *RW   Interrupt mask, end odd field
  301                                       8   *RW   Interrupt mask, end even field
  302                                       2   *RR   Interrupt status, start of field
  303                                       1   *RR   Interrupt status, end of odd
  304                                       0   *RR   Interrupt status, end of even */
  305 /* 0x4c */      0x00000001,     /* 31:0   *RW   Field Mask (Even) continous */
  306 /* 0x50 */      0x00000001,     /* 31:0   *RW   Field Mask (Odd) continous */
  307 /* 0x54 */      0x00000000,     /* 20:16  *RW   Mask Length (Odd)
  308                                     4:0   *RW   Mask Length (Even)      */
  309 /* 0x58 */      0x0005007c,     /* 22:16  *RW   FIFO almost empty
  310                                     6:0   *RW   FIFO almost full        */
  311 /* 0x5c */      0x461e1e0f,     /* 31:24  *RW   I2C Phase 4
  312                                    23:16  *RW   I2C Phase 3
  313                                    15:8   *RW   I2C Phase 2
  314                                     7:0   *RW   I2C Phase 1     */
  315 /* 0x60 */      0x00000300,     /* 31:24  *RO   I2C Read Data
  316                                    23:16  **RW  I2C Auto Address
  317                                       11  RO    I2C SCL Input
  318                                       10  RO    I2C SDA Input
  319                                       9   RR    I2C Direct Abort
  320                                       8   RR    I2C Auto Abort
  321                                       3   RW    I2C SCL Output
  322                                       2   RW    I2C SDA Output
  323                                       1   RW    I2C Bypass
  324                                       0   RW    I2C Auto Enable */
  325 /* 0x64 */      0x00000000,     /*    24  RS    I2C New Cycle
  326                                    23:16  **RW  I2C Direct Address
  327                                    15:8   **RW  I2C Direct Sub-address
  328                                     7:0   **RW  I2C Direct Write Address */
  329 /* 0x68 */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 1 (Even)
  330                                    23:16  **RW  I2C Auto Data 1 (Even)
  331                                    15:8   **RW  I2C Auto Sub-address 0 (Even)
  332                                     7:0   **RW  I2C Auto Data 0 (Even) */
  333 /* 0x6c */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 3 (Even)
  334                                    23:16  **RW  I2C Auto Data 3 (Even)
  335                                    15:8   **RW  I2C Auto Sub-address 2 (Even)
  336                                     7:0   **RW  I2C Auto Data 2 (Even) */
  337 /* 0x70 */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 5 (Even)
  338                                    23:16  **RW  I2C Auto Data 5 (Even)
  339                                    15:8   **RW  I2C Auto Sub-address 4 (Even)
  340                                     7:0   **RW  I2C Auto Data 4 (Even) */
  341 /* 0x74 */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 7 (Even)
  342                                    23:16  **RW  I2C Auto Data 7 (Even)
  343                                    15:8   **RW  I2C Auto Sub-address 6 (Even)
  344                                     7:0   **RW  I2C Auto Data 6 (Even) */
  345 /* 0x78 */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 1 (Odd)
  346                                    23:16  **RW  I2C Auto Data 1 (Odd)
  347                                    15:8   **RW  I2C Auto Sub-address 0 (Odd)
  348                                     7:0   **RW  I2C Auto Data 0 (Odd) */
  349 /* 0x7c */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 3 (Odd)
  350                                    23:16  **RW  I2C Auto Data 3 (Odd)
  351                                    15:8   **RW  I2C Auto Sub-address 2 (Odd)
  352                                     7:0   **RW  I2C Auto Data 2 (Odd) */
  353 /* 0x80 */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 5 (Odd)
  354                                    23:16  **RW  I2C Auto Data 5 (Odd)
  355                                    15:8   **RW  I2C Auto Sub-address 4 (Odd)
  356                                     7:0   **RW  I2C Auto Data 4 (Odd) */
  357 /* 0x84 */      0x00000000,     /* 31:24  **RW  I2C Auto Sub-address 7 (Odd)
  358                                    23:16  **RW  I2C Auto Data 7 (Odd)
  359                                    15:8   **RW  I2C Auto Sub-address 6 (Odd)
  360                                     7:0   **RW  I2C Auto Data 6 (Odd) */
  361 /* 0x88 */      0x00000000,     /* 23:16  **RW  I2C Register Enable (Odd)
  362                                     7:0   **RW  I2C Register Enable (Even) */
  363 /* 0x8c */      0x00000000,     /* 23:2   e*RW  DMA End (Even)
  364                                     1:0   RO    0x0     */
  365 /* 0x90 */      0x00000000      /* 23:2   e*RW  DMA End (Odd)
  366                                     1:0   RO    0x0     */
  367 };
  368 
  369 static u_char saa7196_i2c_default[NUM_SAA7196_I2C_REGS] = {
  370                         /* SAA7196 I2C bus control                      */
  371                         /* BITS Function                                */
  372 /* 00 */        0x50,   /* 7:0  Increment Delay                         */
  373 /* 01 */        0x30,   /* 7:0  Horizontal Sync Begin for 50hz          */
  374 /* 02 */        0x00,   /* 7:0  Horizontal Sync Stop for 50hz           */
  375 /* 03 */        0xe8,   /* 7:0  Horizontal Sync Clamp Start for 50hz    */
  376 /* 04 */        0xb6,   /* 7:0  Horizontal Sync Clamp Stop for 50hz     */
  377 /* 05 */        0xf4,   /* 7:0  Horizontal Sync Start after PH1 for 50hz */
  378 /* 06 */        0x46,   /*   7  Input mode =0 CVBS, =1 S-Video 
  379                              6  Pre filter
  380                            5:4  Aperture Bandpass characteristics
  381                            3:2  Coring range for high freq
  382                            1:0  Aperture bandpass filter weights        */
  383 /* 07 */        0x00,   /* 7:0  Hue                                     */
  384 /* 08 */        0x7f,   /* 7:3  Colour-killer threshold QAM (PAL, NTSC) */
  385 /* 09 */        0x7f,   /* 7:3  Colour-killer threshold SECAM           */
  386 /* 0a */        0x7f,   /* 7:0  PAL switch sensitivity                  */
  387 /* 0b */        0x7f,   /* 7:0  SECAM switch sensitivity                */
  388 /* 0c */        0x40,   /*   7  Colour-on bit
  389                            6:5  AGC filter                              */
  390 /* 0d */        0x84,   /*   7  VTR/TV mode bit = 1->VTR mode
  391                              3  Realtime output mode select bit
  392                              2  HREF position select
  393                              1  Status byte select
  394                              0  SECAM mode bit                          */
  395 /* 0e */        0x38,   /*   7  Horizontal clock PLL
  396                              5  Select interal/external clock source
  397                              4  Output enable of Horizontal/Vertical sync
  398                              3  Data output YUV enable
  399                              2  S-VHS bit
  400                              1  GPSW2
  401                              0  GPSW1                                   */
  402 /* 0f */        0x50,   /*   7  Automatic Field detection
  403                              6  Field Select 0 = 50hz, 1=60hz
  404                              5  SECAM cross-colour reduction
  405                              4  Enable sync and clamping pulse
  406                            3:1  Luminance delay compensation            */
  407 /* 10 */        0x00,   /*   2  Select HREF Position
  408                            1:0  Vertical noise reduction                */
  409 /* 11 */        0x2c,   /* 7:0  Chrominance gain conrtol for QAM        */
  410 /* 12 */        0x40,   /* 7:0  Chrominance saturation control for VRAM port */
  411 /* 13 */        0x40,   /* 7:0  Luminance contract control for VRAM port */
  412 /* 14 */        0x34,   /* 7:0  Horizontal sync begin for 60hz          */
  413 #ifdef notdef
  414 /* 15 */        0x0c,   /* 7:0  Horizontal sync stop for 60hz           */
  415 /* 16 */        0xfb,   /* 7:0  Horizontal clamp begin for 60hz         */
  416 /* 17 */        0xd4,   /* 7:0  Horizontal clamp stop for 60hz          */
  417 /* 18 */        0xec,   /* 7:0  Horizontal sync start after PH1 for 60hz */
  418 #else
  419                 0x0a, 0xf4, 0xce, 0xf4,
  420 #endif
  421 /* 19 */        0x80,   /* 7:0  Luminance brightness control for VRAM port */
  422 /* 1a */        0x00,
  423 /* 1b */        0x00,
  424 /* 1c */        0x00,
  425 /* 1d */        0x00,
  426 /* 1e */        0x00,
  427 /* 1f */        0x00,
  428 /* 20 */        0x90,   /*   7  ROM table bypass switch
  429                            6:5  Set output field mode
  430                              4  VRAM port outputs enable
  431                            3:2  First pixel position in VRO data
  432                            1:0  FIFO output register select             */
  433 /* 21 */        0x80,   /* 7:0  [7:0] Pixel number per line on output   */
  434 /* 22 */        0x80,   /* 7:0  [7:0] Pixel number per line on input    */
  435 /* 23 */        0x03,   /* 7:0  [7:0] Horizontal start position of scaling win*/
  436 /* 24 */        0x8a,   /* 7:5  Horizontal decimation filter
  437                              4  [8] Horizontal start position of scaling win
  438                            3:2  [9:8] Pixel number per line on input
  439                            1:0  [9:8] Pixel number per line on output   */
  440 /* 25 */        0xf0,   /* 7:0  [7:0] Line number per output field      */
  441 /* 26 */        0xf0,   /* 7:0  [7:0] Line number per input field       */
  442 /* 27 */        0x0f,   /* 7:0  [7:0] Vertical start of scaling window  */
  443 /* 28 */        0x80,   /*   7  Adaptive filter switch
  444                            6:5  Vertical luminance data processing
  445                              4  [8] Vertical start of scaling window 
  446                            3:2  [9:8] Line number per input field
  447                            1:0  [9:8] Line number per output field      */
  448 /* 29 */        0x16,   /* 7:0  [7:0] Vertical bypass start             */
  449 /* 2a */        0x00,   /* 7:0  [7:0] Vertical bypass count             */
  450 /* 2b */        0x00,   /*   4  [8] Vertical bypass start
  451                              2  [8] Vertical bypass count
  452                              0  Polarity, internally detected odd even flag */
  453 /* 2c */        0x80,   /* 7:0  Set lower limit V for colour-keying     */
  454 /* 2d */        0x7f,   /* 7:0  Set upper limit V for colour-keying     */
  455 /* 2e */        0x80,   /* 7:0  Set lower limit U for colour-keying     */
  456 /* 2f */        0x7f,   /* 7:0  Set upper limit U for colour-keying     */
  457 /* 30 */        0xbf    /*   7  VRAM bus output format
  458                              6  Adaptive geometrical filter
  459                              5  Luminance limiting value
  460                              4  Monochrome and two's complement output data sel
  461                              3  Line quailifier flag
  462                              2  Pixel qualifier flag
  463                              1  Transparent data transfer
  464                              0  Extended formats enable bit             */
  465 };
  466 
  467 static u_char bt254_default[NUM_BT254_REGS] = {
  468         0x00,   /* 24 bpp */
  469         0xa0,
  470         0xa0,
  471         0xa0,
  472         0x50,
  473         0x50,
  474         0x50,
  475 } ;
  476 
  477 /*
  478  * i2c_write:
  479  * Returns      0       Succesful completion.
  480  * Returns      1       If transfer aborted or timeout occured.
  481  *
  482  */
  483 static int i2c_print_err = 1;
  484 static int
  485 i2c_write(meteor_reg_t * mtr, u_char slave, u_char rw, u_char reg, u_char data)
  486 {
  487 register unsigned long  wait_counter = 0x0001ffff;
  488 register mreg_t *       iic_write_loc = &mtr->base->i2c_write;
  489 register int            err = 0;
  490 
  491 
  492         /* Write the data the the i2c write register */
  493         *iic_write_loc = SAA7116_IIC_NEW_CYCLE |
  494                 (((u_long)slave|(u_long)rw) << 16) |
  495                 ((u_long)reg << 8) | (u_long)data;
  496 
  497         /* Wait until the i2c cycle is compeleted */
  498         while((*iic_write_loc & SAA7116_IIC_NEW_CYCLE)) {
  499                 if(!wait_counter) break;
  500                 wait_counter--;
  501         }
  502 
  503         /* 1ffff should be enough delay time for the i2c cycle to complete */
  504         if(!wait_counter) {
  505                 if(i2c_print_err)
  506                         printf("meteor%d: %d i2c %s transfer timeout 0x%x",
  507                                 METEOR_NUM(mtr), slave, 
  508                                 rw ? "read" : "write", *iic_write_loc);
  509                         
  510                 err=1;
  511         } 
  512 
  513         /* Check for error on direct write, clear if any */
  514         if(mtr->base->i2c_read & SAA7116_IIC_DIRECT_TRANSFER_ABORTED){
  515                 mtr->base->i2c_read |= SAA7116_IIC_DIRECT_TRANSFER_ABORTED;
  516                 if(i2c_print_err)
  517                         printf("meteor%d: 0x%x i2c %s tranfer aborted",
  518                                 METEOR_NUM(mtr), slave,
  519                                 rw ? "read" : "write" );
  520                 err= 1;
  521         }
  522 
  523         if(err) {
  524                 if(i2c_print_err)
  525                         printf(" - reg=0x%x, value=0x%x.\n", reg, data);
  526         }
  527                 
  528         return err;
  529 }
  530 #undef i2c_print
  531 
  532 static  const char *
  533 met_probe (pcici_t tag, pcidi_t type)
  534 {
  535         
  536         switch (type) {
  537         case SAA7116_PHILIPS_ID:        /* meteor */
  538                 return("Philips SAA 7116");
  539         };
  540         return ((char *)0);
  541 }
  542 
  543         /* interrupt handling routine 
  544            complete meteor_read() if using interrupts
  545         */
  546 static void
  547 meteor_intr(void *arg)
  548 {
  549         meteor_reg_t    *mtr       = (meteor_reg_t *) arg;
  550         mreg_t          *cap       = &mtr->base->cap_cntl,
  551                         *base      = &mtr->base->dma1e,
  552                         *stat      = &mtr->base->irq_stat;
  553         u_long          status     = *stat,
  554                         cap_err    = *cap & 0x00000f00,
  555 #ifdef METEOR_CHECK_PCI_BUS
  556                         pci_err    = pci_conf_read(mtr->tag,
  557                                                 PCI_COMMAND_STATUS_REG),
  558 #endif
  559                         next_base  = (u_long)(vtophys(mtr->bigbuf));
  560 
  561         /*
  562          * Disable future interrupts if a capture mode is not selected.
  563          * This can happen when we are in the process of closing or 
  564          * changing capture modes, otherwise it shouldn't happen.
  565          */
  566         if(!(mtr->flags & METEOR_CAP_MASK)) {
  567                 *cap &= 0x8ff0; /* disable future interrupts */
  568         }
  569 #ifdef METEOR_CHECK_PCI_BUS
  570         /*
  571          * Check for pci bus errors.
  572          */
  573 #define METEOR_MASTER_ABORT     0x20000000
  574 #define METEOR_TARGET_ABORT     0x10000000
  575         if(pci_err & METEOR_MASTER_ABORT) {
  576                 printf("meteor%d: intr: pci bus master dma abort: 0x%x 0x%x.\n",
  577                         METEOR_NUM(mtr), *base, *(base+3));
  578                 pci_conf_write(mtr->tag, PCI_COMMAND_STATUS_REG, pci_err);
  579         }
  580         if(pci_err & METEOR_TARGET_ABORT) {
  581                 printf("meteor%d: intr: pci bus target dma abort: 0x%x 0x%x.\n",
  582                         METEOR_NUM(mtr), *base, *(base+3));
  583                 pci_conf_write(mtr->tag, PCI_COMMAND_STATUS_REG, pci_err);
  584         }
  585 #endif
  586         /*
  587          * Check for errors.
  588          */
  589         if (cap_err) {
  590            if (cap_err & 0x300) {
  591                 if(mtr->fifo_errors % 50 == 0) {
  592                         printf("meteor%d: capture error", METEOR_NUM(mtr));
  593                         printf(": %s FIFO overflow.\n",
  594                                 cap_err&0x0100? "even" : "odd");
  595                 }
  596                 mtr->fifo_errors++ ;    /* increment fifo capture errors cnt */
  597            }
  598            if (cap_err & 0xc00) {
  599                 if(mtr->dma_errors % 50 == 0) {
  600                         printf("meteor%d: capture error", METEOR_NUM(mtr));
  601                         printf(": %s DMA address.\n",
  602                                 cap_err&0x0400? "even" : "odd");
  603                 }
  604                 mtr->dma_errors++ ;     /* increment DMA capture errors cnt */
  605            }
  606         }
  607         *cap |= 0x0f30;         /* clear error and field done */
  608 
  609         /*
  610          * In synchronous capture mode we need to know what the address
  611          * offset for the next field/frame will be.  next_base holds the
  612          * value for the even dma buffers (for odd, one must add stride).
  613          */
  614         if((mtr->flags & METEOR_SYNCAP) && !mtr->synch_wait &&
  615            (mtr->current < mtr->frames)) { /* could be !=, but < is safer */
  616                 /* next_base is initialized to mtr->bigbuf */
  617                 next_base += mtr->frame_size * mtr->current;
  618                 if(mtr->flags & METEOR_WANT_TS)
  619                         next_base += sizeof(struct timeval) * mtr->current;
  620         }
  621 
  622         /*
  623          * Count the field and clear the field flag.
  624          *
  625          * In single mode capture, clear the continuous capture mode.
  626          *
  627          * In synchronous capture mode, if we have room for another field,
  628          * adjust DMA buffer pointers.
  629          * When we are above the hi water mark (hiwat), mtr->synch_wait will
  630          * be set and we will not bump the DMA buffer pointers.  Thus, once
  631          * we reach the hi water mark,  the driver acts like a continuous mode
  632          * capture on the mtr->current frame until we hit the low water
  633          * mark (lowat).  The user had the option of stopping or halting
  634          * the capture if this is not the desired effect.
  635          */
  636         if (status & 0x1) {             /* even field */
  637                 mtr->even_fields_captured++;
  638                 mtr->flags &= ~METEOR_WANT_EVEN;
  639                 if((mtr->flags & METEOR_SYNCAP) && !mtr->synch_wait) {
  640                         *base = next_base;
  641                         /* XXX should add adjustments for YUV_422 & PLANAR */
  642                 }
  643                 /*
  644                  * If the user requested to be notified via signal,
  645                  * let them know the field is complete.
  646                  */
  647                 if(mtr->proc && (mtr->signal & METEOR_SIG_MODE_MASK)) {
  648                         PROC_LOCK(mtr->proc);
  649                         psignal(mtr->proc, mtr->signal&(~METEOR_SIG_MODE_MASK));
  650                         PROC_UNLOCK(mtr->proc);
  651                 }
  652         }
  653         if (status & 0x2) {             /* odd field */
  654                 mtr->odd_fields_captured++;
  655                 mtr->flags &= ~METEOR_WANT_ODD;
  656                 if((mtr->flags & METEOR_SYNCAP) && !mtr->synch_wait) {
  657                         *(base+3) = next_base + *(base+6);
  658                         /* XXX should add adjustments for YUV_422 & PLANAR */
  659                 }
  660                 /*
  661                  * If the user requested to be notified via signal,
  662                  * let them know the field is complete.
  663                  */
  664                 if(mtr->proc && (mtr->signal & METEOR_SIG_MODE_MASK)) {
  665                         PROC_LOCK(mtr->proc);
  666                         psignal(mtr->proc, mtr->signal&(~METEOR_SIG_MODE_MASK));
  667                         PROC_UNLOCK(mtr->proc);
  668                 }
  669         }
  670 
  671         /*
  672          * If we have a complete frame.
  673          */
  674         if(!(mtr->flags & METEOR_WANT_MASK)) {
  675                 mtr->frames_captured++;
  676                 /*
  677                  * post the completion time. 
  678                  */
  679                 if(mtr->flags & METEOR_WANT_TS) {
  680                         struct timeval *ts;
  681                         
  682                         if(mtr->alloc_pages * PAGE_SIZE <= (mtr->frame_size +
  683                                         sizeof(struct timeval))) {
  684                                 ts =(struct timeval *)mtr->bigbuf +
  685                                                         mtr->frame_size;
  686                         /* doesn't work in synch mode except for first frame */
  687                         /* XXX */
  688                                 microtime(ts);
  689                         }
  690                 }
  691                 /*
  692                  * Wake up the user in single capture mode.
  693                  */
  694                 if(mtr->flags & METEOR_SINGLE)
  695                         wakeup((caddr_t)mtr);
  696                 /*
  697                  * If the user requested to be notified via signal,
  698                  * let them know the frame is complete.
  699                  */
  700                 if(mtr->proc && !(mtr->signal & METEOR_SIG_MODE_MASK)) {
  701                         PROC_LOCK(mtr->proc);
  702                         psignal(mtr->proc, mtr->signal&(~METEOR_SIG_MODE_MASK));
  703                         PROC_UNLOCK(mtr->proc);
  704                 }
  705                 /*
  706                  * Reset the want flags if in continuous or
  707                  * synchronous capture mode.
  708                  */
  709                 if(mtr->flags & (METEOR_CONTIN|METEOR_SYNCAP)) {
  710                         switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
  711                         case METEOR_ONLY_ODD_FIELDS:
  712                                 mtr->flags |= METEOR_WANT_ODD;
  713                                 break;
  714                         case METEOR_ONLY_EVEN_FIELDS:
  715                                 mtr->flags |= METEOR_WANT_EVEN;
  716                                 break;
  717                         default:
  718                                 mtr->flags |= METEOR_WANT_MASK;
  719                                 break;
  720                         }
  721                 }
  722                 /*
  723                  * Special handling for synchronous capture mode.
  724                  */
  725                 if(mtr->flags & METEOR_SYNCAP) {
  726                         struct meteor_mem *mm = mtr->mem;
  727                         /*
  728                          * Mark the current frame as active.  It is up to
  729                          * the user to clear this, but we will clear it
  730                          * for the user for the current frame being captured
  731                          * if we are within the water marks (see below).
  732                          */
  733                         mm->active |= 1 << (mtr->current - 1);
  734 
  735                         /*
  736                          * Since the user can muck with these values, we need
  737                          * to check and see if they are sane. If they don't
  738                          * pass the sanity check, disable the capture mode.
  739                          * This is rather rude, but then so was the user.
  740                          *
  741                          * Do we really need all of this or should we just
  742                          * eliminate the possiblity of allowing the
  743                          * user to change hi and lo water marks while it
  744                          * is running? XXX
  745                          */
  746                         if(mm->num_active_bufs < 0 ||
  747                            mm->num_active_bufs > mtr->frames ||
  748                            mm->lowat < 1 || mm->lowat >= mtr->frames ||
  749                            mm->hiwat < 1 || mm->hiwat >= mtr->frames ||
  750                            mm->lowat > mm->hiwat ) {
  751                                 *cap &= 0x8ff0;
  752                                 mtr->flags &= ~(METEOR_SYNCAP|METEOR_WANT_MASK);
  753                         } else {
  754                                 /*
  755                                  * Ok, they are sane, now we want to
  756                                  * check the water marks.
  757                                  */
  758                                 if(mm->num_active_bufs <= mm->lowat)
  759                                         mtr->synch_wait = 0;
  760                                 if(mm->num_active_bufs >= mm->hiwat)
  761                                         mtr->synch_wait = 1;
  762                                 /*
  763                                  * Clear the active frame bit for this frame
  764                                  * and advance the counters if we are within
  765                                  * the banks of the water marks. 
  766                                  */
  767                                 if(!mtr->synch_wait) {
  768                                         mm->active &= ~(1 << mtr->current);
  769                                         mtr->current++;
  770                                         if(mtr->current > mtr->frames)
  771                                                 mtr->current = 1;
  772                                         mm->num_active_bufs++;
  773                                 }
  774                         }
  775                 }
  776         }
  777 
  778         *stat |=  0x7;          /* clear interrupt status */
  779         return;
  780 }
  781 
  782 static void
  783 set_fps(meteor_reg_t *mtr, u_short fps)
  784 {
  785         struct saa7116_regs *s7116 = mtr->base;
  786         unsigned status;
  787         unsigned maxfps, mask = 0x1, length = 0;
  788 
  789         SAA7196_WRITE(mtr, SAA7196_STDC, SAA7196_REG(mtr, SAA7196_STDC) | 0x02);
  790         SAA7196_READ(mtr);
  791         status = (s7116->i2c_read & 0xff000000L) >> 24;
  792 
  793         /*
  794          * Determine if there is an input signal.  Depending on the
  795          * frequency we either have a max of 25 fps (50 hz) or 30 fps (60 hz).
  796          * If there is no input signal, then we need some defaults.  If the
  797          * user neglected to specify any defaults, just set to the fps to max.
  798          */
  799         if((status & 0x40) == 0) {      /* Is there a signal ? */
  800                 if(status & 0x20) {
  801                         maxfps = 30;    /* 60 hz system */
  802                 } else {
  803                         maxfps = 25;    /* 50 hz system */
  804                 }
  805         } else {                        /* We have no signal, check defaults */
  806 #if METEOR_SYSTEM_DEFAULT == METEOR_PAL || METEOR_SYSTEM_DEFAULT == METEOR_SECAM
  807                 maxfps = 25;
  808 #elif METEOR_SYSTEM_DEFAULT == METEOR_NTSC
  809                 maxfps = 30;
  810 #else
  811                 /* Don't really know what to do, just set max */
  812                 maxfps = 30;
  813                 fps = 30;
  814 #endif
  815         }
  816 
  817         /*
  818          * A little sanity checking...
  819          */
  820         if(fps <  1)      fps = 1;
  821         if(fps > maxfps) fps = maxfps;
  822 
  823         /*
  824          * Compute the mask/length using the fps.
  825          */
  826         if(fps == maxfps) {
  827                 mask = 0x1;
  828                 length = 0x0;
  829         } else if ((float)fps == maxfps/2.0) {  
  830                 mask = 0x1;
  831                 length = 0x1;
  832         } else if (fps > maxfps/2) {
  833                 float step, b;
  834 
  835                 mask = (1<<maxfps) - 1;
  836                 length = maxfps - 1;
  837                 step = (float)(maxfps - 1)/(float)(maxfps - fps);
  838                 for(b=step; b < maxfps; b += step) {
  839                         mask &= ~(1<<((int)b)); /* mask out the bth frame */
  840                 }
  841         } else {        /* fps < maxfps/2 */
  842                 float step, b;
  843 
  844                 mask = 0x1;
  845                 length = maxfps - 1;
  846                 step = (float)(maxfps -1)/(float)(fps);
  847                 for(b = step + 1; b < maxfps - 1; b += step) {
  848                         mask |= (1<<((int)b));  /* mask in the bth frame */
  849                 }
  850         }
  851 
  852         /*
  853          * Set the fps.
  854          */
  855         s7116->fme = s7116->fmo = mask;
  856         s7116->fml = (length << 16) | length;;
  857 
  858         mtr->fps = fps;
  859 
  860         return;
  861 
  862 }
  863 
  864 /*
  865  * There is also a problem with range checking on the 7116.
  866  * It seems to only work for 22 bits, so the max size we can allocate
  867  * is 22 bits long or 4194304 bytes assuming that we put the beginning
  868  * of the buffer on a 2^24 bit boundary.  The range registers will use
  869  * the top 8 bits of the dma start registers along with the bottom 22
  870  * bits of the range register to determine if we go out of range.
  871  * This makes getting memory a real kludge.
  872  *
  873  */
  874 #define RANGE_BOUNDARY  (1<<22)
  875 static vm_offset_t
  876 get_meteor_mem(int unit, unsigned size)
  877 {
  878 vm_offset_t     addr = 0;
  879 
  880         addr = vm_page_alloc_contig(size, 0, 0xffffffff, 1<<24);
  881         if(addr == 0)
  882                 addr = vm_page_alloc_contig(size, 0, 0xffffffff, PAGE_SIZE);
  883         if(addr == 0) {
  884                 printf("meteor%d: Unable to allocate %d bytes of memory.\n",
  885                         unit, size);
  886         }
  887 
  888         return addr;
  889 }
  890 
  891 static void
  892 bt254_write(meteor_reg_t *mtr, u_char addr, u_char data)
  893 {
  894         addr &= 0x7;                                            /* sanity? */
  895         mtr->bt254_reg[addr] = data;
  896         PCF8574_DATA_WRITE(mtr, data);                          /* set data */
  897         PCF8574_CTRL_WRITE(mtr, (PCF8574_CTRL_REG(mtr) & ~0x7) | addr);
  898         PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) & ~0x10); /* WR/ to 0 */
  899         PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x10);  /* WR to 1 */
  900         PCF8574_DATA_WRITE(mtr, 0xff);                          /* clr data */
  901 
  902 }
  903 
  904 static void
  905 bt254_init(meteor_reg_t *mtr)
  906 {
  907 int     i;
  908 
  909         PCF8574_CTRL_WRITE(mtr, 0x7f);
  910         PCF8574_DATA_WRITE(mtr, 0xff);  /* data port must be 0xff */
  911         PCF8574_CTRL_WRITE(mtr, 0x7f);
  912 
  913         /* init RGB module for 24bpp, composite input */
  914         for(i=0; i<NUM_BT254_REGS; i++)
  915                 bt254_write(mtr, i, bt254_default[i]);
  916 
  917         bt254_write(mtr, BT254_COMMAND, 0x00);  /* 24 bpp */
  918 }
  919 
  920 static void
  921 bt254_ntsc(meteor_reg_t *mtr, int arg)
  922 {
  923         if (arg){
  924           /* Set NTSC bit */
  925           PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x20);
  926         }
  927         else {
  928           /* reset NTSC bit */
  929           PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) &= ~0x20);
  930         }
  931 }
  932 
  933 static void
  934 select_bt254(meteor_reg_t *mtr)
  935 {
  936         /* disable saa7196, saaen = 1 */
  937         PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x80);
  938         /* enable Bt254, bten = 0 */
  939         PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) & ~0x40);
  940 }
  941 
  942 static void
  943 select_saa7196(meteor_reg_t *mtr)
  944 {
  945         /* disable Bt254, bten = 1 */
  946         PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) | 0x40);
  947         /* enable saa7196, saaen = 0 */
  948         PCF8574_CTRL_WRITE(mtr, PCF8574_CTRL_REG(mtr) & ~0x80);
  949 }
  950 
  951 /*
  952  * Initialize the 7116, 7196 and the RGB module.
  953  */
  954 static void
  955 meteor_init ( meteor_reg_t *mtr )
  956 {
  957         mreg_t  *vbase_addr;
  958         int     i;
  959 
  960         /*
  961          * Initialize the Philips SAA7116
  962          */
  963         mtr->base->cap_cntl = 0x00000040L;
  964         vbase_addr = &mtr->base->dma1e;
  965         for (i = 0 ; i < (sizeof(struct saa7116_regs)/sizeof(mreg_t)); i++)
  966                 *vbase_addr++ = saa7116_pci_default[i];
  967 
  968         /*
  969          * Check for the Philips SAA7196
  970          */
  971         i2c_print_err = 0;
  972         if(i2c_write(mtr, SAA7196_I2C_ADDR, SAA7116_I2C_WRITE, 0, 0xff) == 0) {
  973                 i2c_print_err = 1;
  974                 /*
  975                  * Initialize 7196
  976                  */
  977                 for (i = 0; i < NUM_SAA7196_I2C_REGS; i++) 
  978                         SAA7196_WRITE(mtr, i, saa7196_i2c_default[i]);
  979                 /*
  980                  * Get version number.
  981                  */
  982                 SAA7196_WRITE(mtr, SAA7196_STDC,
  983                         SAA7196_REG(mtr, SAA7196_STDC) & ~0x02);
  984                 SAA7196_READ(mtr);
  985                 printf("meteor%d: <Philips SAA 7196> rev 0x%x\n",
  986                         METEOR_NUM(mtr),
  987                         (unsigned)((mtr->base->i2c_read & 0xff000000L) >> 28));
  988         } else {
  989                 i2c_print_err = 1;
  990                 printf("meteor%d: <Philips SAA 7196 NOT FOUND>\n",
  991                         METEOR_NUM(mtr));
  992         }
  993         /*
  994          * Check for RGB module, initialized if found.
  995          */
  996         i2c_print_err = 0;
  997         if(i2c_write(mtr,PCF8574_DATA_I2C_ADDR,SAA7116_I2C_WRITE,0,0xff) == 0) {
  998                 i2c_print_err = 1;
  999                 printf("meteor%d: <Booktree 254 (RGB module)>\n",
 1000                         METEOR_NUM(mtr));       /* does this have a rev #? */
 1001                 bt254_init(mtr);        /* Set up RGB module */
 1002                 mtr->flags = METEOR_RGB;
 1003         } else {
 1004                 i2c_print_err = 1;
 1005                 mtr->flags = 0;
 1006         }
 1007 
 1008         set_fps(mtr, 30);
 1009 
 1010 }
 1011 
 1012 static  void
 1013 met_attach(pcici_t tag, int unit)
 1014 {
 1015 #ifdef METEOR_IRQ
 1016         u_long old_irq, new_irq;
 1017 #endif METEOR_IRQ
 1018         meteor_reg_t *mtr;
 1019         vm_offset_t buf;
 1020         u_long latency;
 1021 
 1022         if (unit >= NMETEOR) {
 1023                 printf("meteor%d: attach: only %d units configured.\n",
 1024                                 unit, NMETEOR);
 1025                 printf("meteor%d: attach: invalid unit number.\n", unit);
 1026                 return ;
 1027         }
 1028 
 1029         /*
 1030          * Check for Meteor/PPB (PCI-PCI Bridge)
 1031          * Reprogram IBM Bridge if detected.
 1032          * New Meteor cards have an IBM PCI-PCI bridge, creating a secondary
 1033          * PCI bus. The SAA chip is connected to this secondary bus.
 1034          */
 1035 
 1036         /* If we are not on PCI Bus 0, check for the Bridge */
 1037         if ( pci_get_bus_from_tag( tag ) != 0) {
 1038                 pcici_t bridge_tag;
 1039 
 1040                 /* get tag of parent bridge */
 1041                 bridge_tag = pci_get_parent_from_tag( tag );
 1042 
 1043                 /* Look for IBM 82351, 82352 or 82353 */
 1044                 if (pci_conf_read(bridge_tag, PCI_ID_REG) == 0x00221014) {
 1045 
 1046                         if ( bootverbose)
 1047                                 printf("meteor%d: PPB device detected, reprogramming IBM bridge.\n", unit);
 1048 
 1049                         /* disable SERR */
 1050                         pci_cfgwrite(bridge_tag, 0x05, 0x00, 1);
 1051                         /* set LATENCY */
 1052                         pci_cfgwrite(bridge_tag, 0x0d, 0x20, 1);
 1053                         /* write posting enable, prefetch enabled --> GRAB direction */
 1054                         pci_cfgwrite(bridge_tag, 0x42, 0x14, 1);
 1055                         /* set PRTR Primary retry timer register */
 1056                         pci_cfgwrite(bridge_tag, 0x4c, 0x10, 1);
 1057                 }
 1058         }
 1059 
 1060         mtr = &meteor[unit];
 1061         mtr->tag = tag;
 1062         pci_map_mem(tag, PCI_MAP_REG_START, (vm_offset_t *)&mtr->base,
 1063                                 &mtr->phys_base);
 1064 
 1065 #ifdef METEOR_IRQ               /* from the configuration file */
 1066         old_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
 1067         pci_conf_write(tag, PCI_INTERRUPT_REG, METEOR_IRQ);
 1068         new_irq = pci_conf_read(tag, PCI_INTERRUPT_REG);
 1069         printf("meteor%d: attach: irq changed from %d to %d\n",
 1070                 unit, (old_irq & 0xff), (new_irq & 0xff));
 1071 #endif METEOR_IRQ
 1072                                 /* setup the interrupt handling routine */
 1073         pci_map_int(tag, meteor_intr, (void*) mtr, &net_imask); 
 1074 
 1075 /*
 1076  * PCI latency timer.  32 is a good value for 4 bus mastering slots, if
 1077  * you have more than for, then 16 would probably be a better value.
 1078  *
 1079  */
 1080 #ifndef METEOR_DEF_LATENCY_VALUE
 1081 #define METEOR_DEF_LATENCY_VALUE        32      
 1082 #endif
 1083         latency = pci_conf_read(tag, PCI_LATENCY_TIMER);
 1084         latency = (latency >> 8) & 0xff;
 1085         if(bootverbose) {
 1086                 if(latency)
 1087                         printf("meteor%d: PCI bus latency is", unit);
 1088                 else
 1089                         printf("meteor%d: PCI bus latency was 0 changing to",
 1090                                 unit);
 1091         }
 1092         if(!latency) {
 1093                 latency = METEOR_DEF_LATENCY_VALUE;
 1094                 pci_conf_write(tag, PCI_LATENCY_TIMER,  latency<<8);
 1095         }
 1096         if(bootverbose) {
 1097                 printf(" %lu.\n", latency);
 1098         }
 1099 
 1100         meteor_init(mtr);       /* set up saa7116, saa7196, and rgb module */
 1101 
 1102         if(METEOR_ALLOC)
 1103                 buf = get_meteor_mem(unit, METEOR_ALLOC);
 1104         else
 1105                 buf = 0;
 1106         if(bootverbose) {
 1107                 printf("meteor%d: buffer size %d, addr 0x%x\n",
 1108                         unit, METEOR_ALLOC, vtophys(buf));
 1109         }
 1110 
 1111         mtr->bigbuf = buf;
 1112         mtr->alloc_pages = METEOR_ALLOC_PAGES;
 1113         if(buf != 0) {
 1114                 bzero((caddr_t) buf, METEOR_ALLOC);
 1115                 buf = vtophys(buf);
 1116                                         /* 640x480 RGB 16 */
 1117                 mtr->base->dma1e = buf;
 1118                 mtr->base->dma1o = buf + 0x500;
 1119                 mtr->base->dma_end_e = 
 1120                 mtr->base->dma_end_o = buf + METEOR_ALLOC;
 1121         }
 1122         /* 1 frame of 640x480 RGB 16 */
 1123         mtr->cols = 640;
 1124         mtr->rows = 480;
 1125         mtr->depth = 2;         /* two bytes per pixel */
 1126         mtr->frames = 1;        /* one frame */
 1127 
 1128         mtr->flags |= METEOR_INITALIZED | METEOR_AUTOMODE | METEOR_DEV0 |
 1129                    METEOR_RGB16;
 1130         make_dev(&meteor_cdevsw, unit, 0, 0, 0644, "meteor");
 1131 }
 1132 
 1133 #define UNIT(x) ((x) & 0x07)
 1134 
 1135 #ifdef unused
 1136 static int
 1137 meteor_reset(dev_t dev)
 1138 {
 1139 int                     unit = UNIT(minor(dev));
 1140 struct  saa7116_regs    *m;
 1141 
 1142         if(unit >= NMETEOR)
 1143                 return ENXIO;
 1144 
 1145         m = meteor[unit].base;
 1146 
 1147         m->cap_cntl = 0x0;
 1148         tsleep((caddr_t)m, METPRI, "Mreset", hz/50);
 1149 
 1150         m->cap_cntl = 0x8ff0;
 1151         m->cap_cntl = 0x80c0;
 1152         m->cap_cntl = 0x8040;
 1153         tsleep((caddr_t)m, METPRI, "Mreset", hz/10);
 1154         m->cap_cntl = 0x80c0;
 1155 
 1156         return 0;
 1157 
 1158 }
 1159 #endif
 1160 
 1161 /*---------------------------------------------------------
 1162 **
 1163 **      Meteor character device driver routines
 1164 **
 1165 **---------------------------------------------------------
 1166 */
 1167 
 1168 
 1169 int
 1170 meteor_open(dev_t dev, int flags, int fmt, struct thread *td)
 1171 {
 1172         meteor_reg_t *mtr;
 1173         int     unit; 
 1174         int     i;
 1175 
 1176         unit = UNIT(minor(dev));
 1177         if (unit >= NMETEOR)    /* unit out of range */
 1178                 return(ENXIO);
 1179 
 1180         mtr = &(meteor[unit]);
 1181 
 1182         if (!(mtr->flags & METEOR_INITALIZED))  /* device not found */
 1183                 return(ENXIO);
 1184 
 1185         if (mtr->flags & METEOR_OPEN)           /* device is busy */
 1186                 return(EBUSY);
 1187 
 1188         mtr->flags |= METEOR_OPEN;
 1189         /*
 1190          * Make sure that the i2c regs are set the same for each open.
 1191          */
 1192         for(i=0; i< NUM_SAA7196_I2C_REGS; i++) {
 1193                 SAA7196_WRITE(mtr, i, saa7196_i2c_default[i]);
 1194         }
 1195 
 1196         mtr->fifo_errors = 0;
 1197         mtr->dma_errors = 0;
 1198         mtr->frames_captured = 0;
 1199         mtr->even_fields_captured = 0;
 1200         mtr->odd_fields_captured = 0;
 1201         mtr->proc = (struct proc *)0;
 1202         set_fps(mtr, 30);
 1203 #ifdef METEOR_TEST_VIDEO
 1204         mtr->video.addr = 0;
 1205         mtr->video.width = 0;
 1206         mtr->video.banksize = 0;
 1207         mtr->video.ramsize = 0;
 1208 #endif
 1209 
 1210         return(0);
 1211 }
 1212 
 1213 int
 1214 meteor_close(dev_t dev, int flags, int fmt, struct thread *td)
 1215 {
 1216         meteor_reg_t *mtr;
 1217         int     unit; 
 1218 #ifdef METEOR_DEALLOC_ABOVE
 1219         int     temp;
 1220 #endif
 1221 
 1222         unit = UNIT(minor(dev));
 1223         if (unit >= NMETEOR)    /* unit out of range */
 1224                 return(ENXIO);
 1225 
 1226         mtr = &(meteor[unit]);
 1227         mtr->flags &= ~METEOR_OPEN;
 1228 
 1229         if(mtr->flags & METEOR_SINGLE)
 1230                                 /* this should not happen, the read capture 
 1231                                   should have completed or in the very least
 1232                                   recieved a signal before close is called. */
 1233                 wakeup((caddr_t)mtr);   /* continue read */
 1234         /*
 1235          * Turn off capture mode.
 1236          */
 1237         mtr->base->cap_cntl = 0x8ff0;
 1238         mtr->flags &= ~(METEOR_CAP_MASK|METEOR_WANT_MASK);
 1239         mtr->proc = (struct proc *)0;
 1240 
 1241 #ifdef METEOR_DEALLOC_PAGES
 1242         if (mtr->bigbuf != NULL) {
 1243                 kmem_free(kernel_map,mtr->bigbuf,(mtr->alloc_pages*PAGE_SIZE));
 1244                 mtr->bigbuf = NULL;
 1245                 mtr->alloc_pages = 0;
 1246         }
 1247 #else
 1248 #ifdef METEOR_DEALLOC_ABOVE
 1249         if (mtr->bigbuf != NULL && mtr->alloc_pages > METEOR_DEALLOC_ABOVE) {
 1250                 temp = METEOR_DEALLOC_ABOVE - mtr->alloc_pages;
 1251                 kmem_free(kernel_map,
 1252                           mtr->bigbuf+((mtr->alloc_pages - temp) * PAGE_SIZE),
 1253                           (temp * PAGE_SIZE));
 1254                 mtr->alloc_pages = METEOR_DEALLOC_ABOVE;
 1255         }
 1256 #endif
 1257 #endif
 1258 
 1259         return(0);
 1260 }
 1261 
 1262 static void
 1263 start_capture(meteor_reg_t *mtr, unsigned type)
 1264 {
 1265 mreg_t *cap = &mtr->base->cap_cntl;
 1266 
 1267         mtr->flags |= type;
 1268         switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
 1269         case METEOR_ONLY_EVEN_FIELDS:
 1270                 mtr->flags |= METEOR_WANT_EVEN;
 1271                 if(type == METEOR_SINGLE)
 1272                         *cap = 0x0ff4 | mtr->range_enable;
 1273                 else
 1274                         *cap = 0x0ff1 | mtr->range_enable;
 1275                 break;
 1276         case METEOR_ONLY_ODD_FIELDS:
 1277                 mtr->flags |= METEOR_WANT_ODD;
 1278                 if(type == METEOR_SINGLE)
 1279                         *cap = 0x0ff8 | mtr->range_enable;
 1280                 else
 1281                         *cap = 0x0ff2 | mtr->range_enable;
 1282                 break;
 1283         default:
 1284                 mtr->flags |= METEOR_WANT_MASK;
 1285                 if(type == METEOR_SINGLE)
 1286                         *cap = 0x0ffc | mtr->range_enable;
 1287                 else
 1288                         *cap = 0x0ff3 | mtr->range_enable;
 1289                 break;
 1290         }
 1291 }
 1292 
 1293 int
 1294 meteor_read(dev_t dev, struct uio *uio, int ioflag)
 1295 {
 1296         meteor_reg_t *mtr;
 1297         int     unit; 
 1298         int     status;
 1299         int     count;
 1300 
 1301         unit = UNIT(minor(dev));
 1302         if (unit >= NMETEOR)    /* unit out of range */
 1303                 return(ENXIO);
 1304 
 1305         mtr = &(meteor[unit]);
 1306         if (mtr->bigbuf == 0)/* no frame buffer allocated (ioctl failed) */
 1307                 return(ENOMEM);
 1308 
 1309         if (mtr->flags & METEOR_CAP_MASK)
 1310                 return(EIO);            /* already capturing */
 1311 
 1312         count = mtr->rows * mtr->cols * mtr->depth;
 1313         if (uio->uio_iov->iov_len < count)
 1314                 return(EINVAL);
 1315 
 1316         /* Start capture */
 1317         start_capture(mtr, METEOR_SINGLE);
 1318 
 1319         status=tsleep((caddr_t)mtr, METPRI, "capturing", 0);
 1320         if (!status)            /* successful capture */
 1321                 status = uiomove((caddr_t)mtr->bigbuf, count, uio);
 1322         else
 1323                 printf ("meteor%d: read: tsleep error %d\n", unit, status);
 1324 
 1325         mtr->flags &= ~(METEOR_SINGLE | METEOR_WANT_MASK);
 1326 
 1327         return(status);
 1328 }
 1329 
 1330 int
 1331 meteor_write(dev_t dev, struct uio *uio, int ioflag)
 1332 {
 1333         return(0);
 1334 }
 1335 
 1336 int
 1337 meteor_ioctl(dev_t dev, u_long cmd, caddr_t arg, int flag, struct thread *td)
 1338 {
 1339         int     error;  
 1340         int     unit;   
 1341         unsigned int    temp;
 1342         meteor_reg_t *mtr;
 1343         struct meteor_counts *cnt;
 1344         struct meteor_geomet *geo;
 1345         struct meteor_mem *mem;
 1346         struct meteor_capframe *frame;
 1347 #ifdef METEOR_TEST_VIDEO
 1348         struct meteor_video *video;
 1349 #endif
 1350         vm_offset_t buf;
 1351         struct saa7116_regs *base;
 1352 
 1353         error = 0;
 1354 
 1355         if (!arg) return(EINVAL);
 1356         unit = UNIT(minor(dev));
 1357         if (unit >= NMETEOR)    /* unit out of range */
 1358                 return(ENXIO);
 1359 
 1360         mtr = &(meteor[unit]);
 1361         base = mtr->base;
 1362 
 1363         switch (cmd) {
 1364         case METEORSTS:
 1365                 if(*arg)
 1366                         mtr->flags |= METEOR_WANT_TS;
 1367                 else
 1368                         mtr->flags &= ~METEOR_WANT_TS;
 1369                 break;
 1370         case METEORGTS:
 1371                 if(mtr->flags & METEOR_WANT_TS)
 1372                         *arg = 1;
 1373                 else
 1374                         *arg = 0;
 1375                 break;
 1376 #ifdef METEOR_TEST_VIDEO
 1377         case METEORGVIDEO:
 1378                 video = (struct meteor_video *)arg;
 1379                 video->addr = mtr->video.addr;
 1380                 video->width = mtr->video.width;
 1381                 video->banksize = mtr->video.banksize;
 1382                 video->ramsize = mtr->video.ramsize;
 1383                 break;
 1384         case METEORSVIDEO:
 1385                 video = (struct meteor_video *)arg;
 1386                 mtr->video.addr = video->addr;
 1387                 mtr->video.width = video->width;
 1388                 mtr->video.banksize = video->banksize;
 1389                 mtr->video.ramsize = video->ramsize;
 1390                 break;
 1391 #endif
 1392         case METEORSFPS:
 1393                 set_fps(mtr, *(u_short *)arg);
 1394                 break;
 1395         case METEORGFPS:
 1396                 *(u_short *)arg = mtr->fps;
 1397                 break;
 1398         case METEORSSIGNAL:
 1399                 mtr->signal = *(int *) arg;
 1400                 if (mtr->signal) {
 1401                   mtr->proc = td->td_proc;
 1402                 } else {
 1403                   mtr->proc = (struct proc *)0;
 1404                 }
 1405                 break;
 1406         case METEORGSIGNAL:
 1407                 *(int *)arg = mtr->signal;
 1408                 break;
 1409         case METEORSTATUS:      /* get 7196 status */
 1410                 temp = 0;
 1411                 SAA7196_WRITE(mtr, SAA7196_STDC,
 1412                         SAA7196_REG(mtr, SAA7196_STDC) | 0x02);
 1413                 SAA7196_READ(mtr);
 1414                 temp |= (base->i2c_read & 0xff000000L) >> 24;
 1415                 SAA7196_WRITE(mtr, SAA7196_STDC,
 1416                         SAA7196_REG(mtr, SAA7196_STDC) & ~0x02);
 1417                 SAA7196_READ(mtr);
 1418                 temp |= (base->i2c_read & 0xff000000L) >> 16;
 1419                 *(u_short *)arg = temp;
 1420                 break;
 1421         case METEORSHUE:        /* set hue */
 1422                 SAA7196_WRITE(mtr, SAA7196_HUEC, *(char *)arg);
 1423                 break;
 1424         case METEORGHUE:        /* get hue */
 1425                 *(char *)arg = SAA7196_REG(mtr, SAA7196_HUEC);
 1426                 break;
 1427         case METEORSCHCV:       /* set chrominance gain */
 1428                 SAA7196_WRITE(mtr, SAA7196_CGAINR, *(char *)arg);
 1429                 break;
 1430         case METEORGCHCV:       /* get chrominance gain */
 1431                 *(char *)arg = SAA7196_REG(mtr, SAA7196_CGAINR);
 1432                 break;
 1433         case METEORSBRIG:       /* set brightness */
 1434                 SAA7196_WRITE(mtr, SAA7196_BRIG, *(char *)arg);
 1435                 break;
 1436         case METEORGBRIG:       /* get brightness */
 1437                 *(char *)arg = SAA7196_REG(mtr, SAA7196_BRIG);
 1438                 break;
 1439         case METEORSCSAT:       /* set chroma saturation */
 1440                 SAA7196_WRITE(mtr, SAA7196_CSAT, *(char *)arg);
 1441                 break;
 1442         case METEORGCSAT:       /* get chroma saturation */
 1443                 *(char *)arg = SAA7196_REG(mtr, SAA7196_CSAT);
 1444                 break;
 1445         case METEORSCONT:       /* set contrast */
 1446                 SAA7196_WRITE(mtr, SAA7196_CONT, *(char *)arg);
 1447                 break;
 1448         case METEORGCONT:       /* get contrast */
 1449                 *(char *)arg = SAA7196_REG(mtr, SAA7196_CONT);
 1450                 break;
 1451         case METEORSBT254:
 1452                 if((mtr->flags & METEOR_RGB) == 0)
 1453                         return EINVAL;
 1454                 temp = *(unsigned short *)arg;
 1455                 bt254_write(mtr, temp & 0xf, (temp & 0x0ff0) >> 4);
 1456                 break;
 1457         case METEORGBT254:
 1458                 if((mtr->flags & METEOR_RGB) == 0)
 1459                         return EINVAL;
 1460                 temp = *(unsigned short *)arg & 0x7;
 1461                 *(unsigned short *)arg = mtr->bt254_reg[temp] << 4 | temp;
 1462                 break;
 1463         case METEORSHWS:        /* set horizontal window start */
 1464                 SAA7196_WRITE(mtr, SAA7196_HWS, *(char *)arg);
 1465                 break;
 1466         case METEORGHWS:        /* get horizontal window start */
 1467                 *(char *)arg = SAA7196_REG(mtr, SAA7196_HWS);
 1468                 break;
 1469         case METEORSVWS:        /* set vertical window start */
 1470                 SAA7196_WRITE(mtr, SAA7196_VWS, *(char *)arg);
 1471                 break;
 1472         case METEORGVWS:        /* get vertical window start */
 1473                 *(char *)arg = SAA7196_REG(mtr, SAA7196_VWS);
 1474                 break;
 1475         case METEORSINPUT:      /* set input device */
 1476                 switch(*(unsigned long *)arg & METEOR_DEV_MASK) {
 1477                 case 0:                 /* default */
 1478                 case METEOR_INPUT_DEV0:
 1479                         if(mtr->flags & METEOR_RGB)
 1480                                 select_saa7196(mtr);
 1481                         mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
 1482                                 | METEOR_DEV0;
 1483                         SAA7196_WRITE(mtr, 0x0e,
 1484                                 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x0);
 1485                         SAA7196_WRITE(mtr, 0x06,
 1486                                 (SAA7196_REG(mtr, 0x06) & ~0x80));
 1487                         break;
 1488                 case METEOR_INPUT_DEV1:
 1489                         if(mtr->flags & METEOR_RGB)
 1490                                 select_saa7196(mtr);
 1491                         mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
 1492                                                | METEOR_DEV1;
 1493                         SAA7196_WRITE(mtr, 0x0e,
 1494                                 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x1);
 1495                         SAA7196_WRITE(mtr, 0x06,
 1496                                 (SAA7196_REG(mtr, 0x06) & ~0x80));
 1497                         break;
 1498                 case METEOR_INPUT_DEV2:
 1499                         if(mtr->flags & METEOR_RGB)
 1500                                 select_saa7196(mtr);
 1501                         mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
 1502                                                | METEOR_DEV2;
 1503                         SAA7196_WRITE(mtr, 0x0e,
 1504                                 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x2);
 1505                         SAA7196_WRITE(mtr, 0x06,
 1506                                 (SAA7196_REG(mtr, 0x06) & ~0x80));
 1507                         break;
 1508                 case METEOR_INPUT_DEV3:
 1509                         if(mtr->flags & METEOR_RGB)
 1510                                 select_saa7196(mtr);
 1511                         mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
 1512                                                | METEOR_DEV3;
 1513                         SAA7196_WRITE(mtr, 0x0e,
 1514                                 (SAA7196_REG(mtr, 0x0e) | 0x3));
 1515                         SAA7196_WRITE(mtr, 0x06,
 1516                                 (SAA7196_REG(mtr, 0x06) & ~0x80) );
 1517                         break;
 1518                 case METEOR_INPUT_DEV_SVIDEO:
 1519                         if(mtr->flags & METEOR_RGB)
 1520                                 select_saa7196(mtr);
 1521                         mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
 1522                                                | METEOR_DEV_SVIDEO;
 1523                         SAA7196_WRITE(mtr, 0x0e,
 1524                                 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x2);
 1525                         SAA7196_WRITE(mtr, 0x06,
 1526                                 (SAA7196_REG(mtr, 0x06) & ~0x80) | 0x80);
 1527                         break;
 1528                 case METEOR_INPUT_DEV_RGB:
 1529                         if((mtr->flags & METEOR_RGB) == 0)
 1530                                 return EINVAL;
 1531                         mtr->flags = (mtr->flags & ~METEOR_DEV_MASK)
 1532                                                | METEOR_DEV_RGB;
 1533                         SAA7196_WRITE(mtr, 0x0e,
 1534                                 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x3);
 1535                         SAA7196_WRITE(mtr, 0x06,
 1536                                 (SAA7196_REG(mtr, 0x06) & ~0x80));
 1537                         select_bt254(mtr);
 1538                         SAA7196_WRITE(mtr, 0x0e,        /* chn 3 for synch */
 1539                                 (SAA7196_REG(mtr, 0x0e) & ~0x3) | 0x3);
 1540                         break;
 1541                 default:
 1542                         return EINVAL;
 1543                 }
 1544                 break;
 1545         case METEORGINPUT:      /* get input device */
 1546                 *(u_long *)arg = mtr->flags & METEOR_DEV_MASK;
 1547                 break;
 1548         case METEORSFMT:        /* set input format */
 1549                 switch(*(unsigned long *)arg & METEOR_FORM_MASK ) {
 1550                 case 0:                 /* default */
 1551                 case METEOR_FMT_NTSC:
 1552                         mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
 1553                                 METEOR_NTSC;
 1554                         SAA7196_WRITE(mtr, SAA7196_STDC, 
 1555                                 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01));
 1556                         SAA7196_WRITE(mtr, 0x0f,
 1557                                 (SAA7196_REG(mtr, 0x0f) & ~0xe0) | 0x40);
 1558                         SAA7196_WRITE(mtr, 0x22, 0x80);
 1559                         SAA7196_WRITE(mtr, 0x24, 
 1560                                 (SAA7196_REG(mtr, 0x24) & ~0x0c) | 0x08);
 1561                         SAA7196_WRITE(mtr, 0x26, 0xf0);
 1562                         SAA7196_WRITE(mtr, 0x28, 
 1563                                 (SAA7196_REG(mtr, 0x28) & ~0x0c)) ;
 1564                         if(mtr->flags & METEOR_RGB){
 1565                           bt254_ntsc(mtr, 1);                     
 1566                         }
 1567                 break;
 1568                 case METEOR_FMT_PAL:
 1569                         mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
 1570                                 METEOR_PAL;
 1571                         SAA7196_WRITE(mtr, SAA7196_STDC, 
 1572                                 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01));
 1573                         SAA7196_WRITE(mtr, 0x0f, 
 1574                                 (SAA7196_REG(mtr, 0x0f) & ~0xe0));
 1575                         SAA7196_WRITE(mtr, 0x22, 0x00);
 1576                         SAA7196_WRITE(mtr, 0x24, 
 1577                                 (SAA7196_REG(mtr, 0x24) | 0x0c));
 1578                         SAA7196_WRITE(mtr, 0x26, 0x20);
 1579                         SAA7196_WRITE(mtr, 0x28, 
 1580                                 (SAA7196_REG(mtr, 0x28) & ~0x0c) | 0x04) ;
 1581                         if(mtr->flags & METEOR_RGB){
 1582                           bt254_ntsc(mtr, 0);                     
 1583                         }
 1584                 break;
 1585                 case METEOR_FMT_SECAM:
 1586                         mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
 1587                                 METEOR_SECAM;
 1588                         SAA7196_WRITE(mtr, SAA7196_STDC, 
 1589                                 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01) | 0x1);
 1590                         SAA7196_WRITE(mtr, 0x0f, 
 1591                                 (SAA7196_REG(mtr, 0x0f) & ~0xe0) | 0x20);
 1592                         SAA7196_WRITE(mtr, 0x22, 0x00);
 1593                         SAA7196_WRITE(mtr, 0x24, 
 1594                                 (SAA7196_REG(mtr, 0x24) | 0x0c));
 1595                         SAA7196_WRITE(mtr, 0x26, 0x20);
 1596                         SAA7196_WRITE(mtr, 0x28, 
 1597                                 (SAA7196_REG(mtr, 0x28) & ~0x0c) | 0x04) ;
 1598                         if(mtr->flags & METEOR_RGB){
 1599                           bt254_ntsc(mtr, 0);
 1600                         }
 1601                 break;
 1602                 case METEOR_FMT_AUTOMODE:
 1603                         mtr->flags = (mtr->flags & ~METEOR_FORM_MASK) |
 1604                                 METEOR_AUTOMODE;
 1605                         SAA7196_WRITE(mtr, SAA7196_STDC, 
 1606                                 (SAA7196_REG(mtr, SAA7196_STDC) & ~0x01));
 1607                         SAA7196_WRITE(mtr, 0x0f, 
 1608                                 (SAA7196_REG(mtr, 0x0f) & ~0xe0) | 0x80);
 1609                 break;
 1610                 default:
 1611                         return EINVAL;
 1612                 }
 1613                 break;
 1614         case METEORGFMT:        /* get input format */
 1615                 *(u_long *)arg = mtr->flags & METEOR_FORM_MASK;
 1616                 break;
 1617         case METEORCAPTUR:
 1618                 temp = mtr->flags;
 1619                 switch (*(int *) arg) {
 1620                 case METEOR_CAP_SINGLE:
 1621                         if (mtr->bigbuf==0)     /* no frame buffer allocated */
 1622                                 return(ENOMEM);
 1623 
 1624                         if (temp & METEOR_CAP_MASK)
 1625                                 return(EIO);            /* already capturing */
 1626 
 1627                         start_capture(mtr, METEOR_SINGLE);
 1628 
 1629                         /* wait for capture to complete */
 1630                         error=tsleep((caddr_t)mtr, METPRI, "capturing", 0);
 1631                         if(error)
 1632                                 printf("meteor%d: ioctl: tsleep error %d\n",
 1633                                         unit, error);
 1634                         mtr->flags &= ~(METEOR_SINGLE|METEOR_WANT_MASK);
 1635                         break;
 1636                 case METEOR_CAP_CONTINOUS:
 1637                         if (mtr->bigbuf==0)     /* no frame buffer allocated */
 1638                                 return(ENOMEM);
 1639 
 1640                         if (temp & METEOR_CAP_MASK)
 1641                                 return(EIO);            /* already capturing */
 1642 
 1643                         start_capture(mtr, METEOR_CONTIN);
 1644 
 1645                         break;
 1646                 case METEOR_CAP_STOP_CONT:
 1647                         if (mtr->flags & METEOR_CONTIN) {
 1648                                                         /* turn off capture */
 1649                                 base->cap_cntl = 0x8ff0;
 1650                                 mtr->flags &= ~(METEOR_CONTIN|METEOR_WANT_MASK);
 1651                         }
 1652                         break;
 1653         
 1654                 default:
 1655                         error = EINVAL;
 1656                         break;
 1657                 }
 1658                 break;
 1659         case METEORCAPFRM:
 1660             frame = (struct meteor_capframe *) arg;
 1661             if (!frame) 
 1662                 return(EINVAL);
 1663             switch (frame->command) {
 1664             case METEOR_CAP_N_FRAMES:
 1665                 if (mtr->flags & METEOR_CAP_MASK)
 1666                         return(EIO);
 1667                 if (mtr->flags & (METEOR_YUV_PLANAR | METEOR_YUV_422)) /* XXX */
 1668                         return(EINVAL); /* should fix intr so we allow these */
 1669                 if (mtr->bigbuf == 0)
 1670                         return(ENOMEM);
 1671                 if ((mtr->frames < 2) ||
 1672                     (frame->lowat < 1 || frame->lowat >= mtr->frames) ||
 1673                     (frame->hiwat < 1 || frame->hiwat >= mtr->frames) ||
 1674                     (frame->lowat > frame->hiwat)) 
 1675                         return(EINVAL);
 1676                         /* meteor_mem structure is on the page after the data */
 1677                 mem = mtr->mem = (struct meteor_mem *) (mtr->bigbuf +
 1678                                 (round_page(mtr->frame_size * mtr->frames)));
 1679                 mtr->current = 1;
 1680                 mtr->synch_wait = 0;
 1681                 mem->num_bufs = mtr->frames;
 1682                 mem->frame_size= mtr->frame_size;
 1683                 /* user and kernel change these */ 
 1684                 mem->lowat = frame->lowat;
 1685                 mem->hiwat = frame->hiwat;
 1686                 mem->active = 0;
 1687                 mem->num_active_bufs = 0;
 1688                 /* Start capture */
 1689                 start_capture(mtr, METEOR_SYNCAP);
 1690                 break;
 1691             case METEOR_CAP_STOP_FRAMES:
 1692                 if (mtr->flags & METEOR_SYNCAP) {
 1693                                                 /* turn off capture */
 1694                         base->cap_cntl = 0x8ff0;
 1695                         mtr->flags &= ~(METEOR_SYNCAP|METEOR_WANT_MASK);
 1696                 }
 1697                 break;
 1698             case METEOR_HALT_N_FRAMES:
 1699                 if(mtr->flags & METEOR_SYNCAP) {
 1700                         base->cap_cntl = 0x8ff0;
 1701                         mtr->flags &= ~(METEOR_WANT_MASK);
 1702                 }
 1703                 break;
 1704             case METEOR_CONT_N_FRAMES:
 1705                 if(!(mtr->flags & METEOR_SYNCAP)) {
 1706                         error = EINVAL;
 1707                         break;
 1708                 }
 1709                 start_capture(mtr, METEOR_SYNCAP);
 1710                 break;
 1711             default:
 1712                 error = EINVAL;
 1713                 break;
 1714             }
 1715             break;
 1716  
 1717         case METEORSETGEO:
 1718                 geo = (struct meteor_geomet *) arg;
 1719 
 1720                 /* Either even or odd, if even & odd, then these a zero */
 1721                 if((geo->oformat & METEOR_GEO_ODD_ONLY) &&
 1722                         (geo->oformat & METEOR_GEO_EVEN_ONLY)) {
 1723                         printf("meteor%d: ioctl: Geometry odd or even only.\n",
 1724                                 unit);
 1725                         return EINVAL;
 1726                 }
 1727                 /* set/clear even/odd flags */
 1728                 if(geo->oformat & METEOR_GEO_ODD_ONLY)
 1729                         mtr->flags |= METEOR_ONLY_ODD_FIELDS;
 1730                 else
 1731                         mtr->flags &= ~METEOR_ONLY_ODD_FIELDS;
 1732                 if(geo->oformat & METEOR_GEO_EVEN_ONLY)
 1733                         mtr->flags |= METEOR_ONLY_EVEN_FIELDS;
 1734                 else
 1735                         mtr->flags &= ~METEOR_ONLY_EVEN_FIELDS;
 1736 
 1737                 /* can't change parameters while capturing */
 1738                 if (mtr->flags & METEOR_CAP_MASK)
 1739                         return(EBUSY);
 1740 
 1741                 if ((geo->columns & 0x3fe) != geo->columns) {
 1742                         printf(
 1743                         "meteor%d: ioctl: %d: columns too large or not even.\n",
 1744                                 unit, geo->columns);
 1745                         error = EINVAL;
 1746                 }
 1747                 if (((geo->rows & 0x7fe) != geo->rows) ||
 1748                         ((geo->oformat & METEOR_GEO_FIELD_MASK) &&
 1749                                 ((geo->rows & 0x3fe) != geo->rows)) ) {
 1750                         printf(
 1751                         "meteor%d: ioctl: %d: rows too large or not even.\n",
 1752                                 unit, geo->rows);
 1753                         error = EINVAL;
 1754                 }
 1755                 if (geo->frames > 32) {
 1756                         printf("meteor%d: ioctl: too many frames.\n", unit);
 1757                         error = EINVAL;
 1758                 }
 1759                 if(error) return error;
 1760 
 1761                 if ((temp=geo->rows * geo->columns * geo->frames * 2) != 0) {
 1762                         if (geo->oformat & METEOR_GEO_RGB24) temp = temp * 2;
 1763 
 1764                         /* meteor_mem structure for SYNC Capture */
 1765                         if (geo->frames > 1) temp += PAGE_SIZE;
 1766 
 1767                         temp = btoc(temp);
 1768                         if (temp > mtr->alloc_pages
 1769 #ifdef METEOR_TEST_VIDEO
 1770                             && mtr->video.addr == 0
 1771 #endif
 1772                         ) {
 1773                                 buf = get_meteor_mem(unit, temp*PAGE_SIZE);
 1774                                 if(buf != 0) {
 1775                                         kmem_free(kernel_map, mtr->bigbuf,
 1776                                           (mtr->alloc_pages * PAGE_SIZE));
 1777                                         mtr->bigbuf = buf;
 1778                                         mtr->alloc_pages = temp;
 1779                                         if(bootverbose)
 1780                                                 printf(
 1781                                 "meteor%d: ioctl: Allocating %d bytes\n",
 1782                                                         unit, temp*PAGE_SIZE);
 1783                                 } else {
 1784                                         error = ENOMEM;
 1785                                 }
 1786                         }
 1787                 }
 1788                 if(error) return error;
 1789 
 1790                 mtr->rows = geo->rows;
 1791                 mtr->cols = geo->columns;
 1792                 mtr->frames = geo->frames;
 1793 
 1794 #ifdef METEOR_TEST_VIDEO
 1795                 if(mtr->video.addr)
 1796                         buf = vtophys(mtr->video.addr);
 1797                 else
 1798 #endif
 1799                         buf = vtophys(mtr->bigbuf);
 1800 
 1801                 /* set defaults and end of buffer locations */
 1802                 base->dma1e = buf;
 1803                 base->dma2e = buf;
 1804                 base->dma3e = buf;
 1805                 base->dma1o = buf;
 1806                 base->dma2o = buf;
 1807                 base->dma3o = buf;
 1808                 base->stride1e = 0;
 1809                 base->stride2e = 0;
 1810                 base->stride3e = 0;
 1811                 base->stride1o = 0;
 1812                 base->stride2o = 0;
 1813                 base->stride3o = 0;
 1814                                 /* set end of DMA location, even/odd */
 1815                 base->dma_end_e =
 1816                 base->dma_end_o = buf + mtr->alloc_pages * PAGE_SIZE;
 1817 
 1818                 /*
 1819                  * Determine if we can use the hardware range detect.
 1820                  */
 1821                 if(mtr->alloc_pages * PAGE_SIZE < RANGE_BOUNDARY &&
 1822                   ((buf & 0xff000000) | base->dma_end_e) ==
 1823                         (buf + mtr->alloc_pages * PAGE_SIZE) )
 1824                         mtr->range_enable = 0x8000;
 1825                 else {
 1826                         mtr->range_enable = 0x0;
 1827                         base->dma_end_e =
 1828                         base->dma_end_o = 0xffffffff;
 1829                 }
 1830 
 1831 
 1832                 switch (geo->oformat & METEOR_GEO_OUTPUT_MASK) {
 1833                 case 0:                 /* default */
 1834                 case METEOR_GEO_RGB16:
 1835                         mtr->depth = 2;
 1836                         mtr->frame_size = mtr->rows * mtr->cols * mtr->depth;
 1837                         mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
 1838                         mtr->flags |= METEOR_RGB16;
 1839                         temp = mtr->cols * mtr->depth;
 1840                         /* recal stride and starting point */
 1841                         switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
 1842                         case METEOR_ONLY_ODD_FIELDS:
 1843                                 base->dma1o = buf;
 1844 #ifdef METEOR_TEST_VIDEO
 1845                                 if(mtr->video.addr && mtr->video.width) 
 1846                                         base->stride1o = mtr->video.width-temp;
 1847 #endif
 1848                                 SAA7196_WRITE(mtr, 0x20, 0xd0);
 1849                                 break;
 1850                         case METEOR_ONLY_EVEN_FIELDS:
 1851                                 base->dma1e = buf;
 1852 #ifdef METEOR_TEST_VIDEO
 1853                                 if(mtr->video.addr && mtr->video.width) 
 1854                                         base->stride1e = mtr->video.width-temp;
 1855 #endif
 1856                                 SAA7196_WRITE(mtr, 0x20, 0xf0);
 1857                                 break;
 1858                         default: /* interlaced even/odd */
 1859                                 base->dma1e = buf;              
 1860                                 base->dma1o = buf + temp;
 1861                                 base->stride1e = base->stride1o = temp;
 1862 #ifdef METEOR_TEST_VIDEO
 1863                                 if(mtr->video.addr && mtr->video.width) {
 1864                                         base->dma1o = buf + mtr->video.width;
 1865                                         base->stride1e = base->stride1o =
 1866                                                 mtr->video.width -
 1867                                                 temp + mtr->video.width;
 1868                                 }
 1869 #endif
 1870                                 SAA7196_WRITE(mtr, 0x20, 0x90);
 1871                                 break;
 1872                         }
 1873                         base->routee = base->routeo  = 0xeeeeee01;
 1874                         break;
 1875                 case METEOR_GEO_RGB24:
 1876                         mtr->depth = 4;
 1877                         mtr->frame_size = mtr->rows * mtr->cols * mtr->depth;
 1878                         mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
 1879                         mtr->flags |= METEOR_RGB24;
 1880                         temp = mtr->cols * mtr->depth;
 1881                         /* recal stride and starting point */
 1882                         switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
 1883                         case METEOR_ONLY_ODD_FIELDS:
 1884                                 base->dma1o = buf;
 1885 #ifdef METEOR_TEST_VIDEO
 1886                                 if(mtr->video.addr && mtr->video.width) 
 1887                                         base->stride1o = mtr->video.width-temp;
 1888 #endif
 1889                                 SAA7196_WRITE(mtr, 0x20, 0xd2);
 1890                                 break;
 1891                         case METEOR_ONLY_EVEN_FIELDS:
 1892                                 base->dma1e = buf;
 1893 #ifdef METEOR_TEST_VIDEO
 1894                                 if(mtr->video.addr && mtr->video.width) 
 1895                                         base->stride1e = mtr->video.width-temp;
 1896 #endif
 1897                                 SAA7196_WRITE(mtr, 0x20, 0xf2);
 1898                                 break;
 1899                         default: /* interlaced even/odd */
 1900                                 base->dma1e = buf;
 1901                                 base->dma1o = buf + mtr->cols * mtr->depth;
 1902                                 base->stride1e = base->stride1o =
 1903                                         mtr->cols * mtr->depth;
 1904 #ifdef METEOR_TEST_VIDEO
 1905                                 if(mtr->video.addr && mtr->video.width) {
 1906                                         base->dma1o = buf + mtr->video.width;
 1907                                         base->stride1e = base->stride1o = 
 1908                                                 mtr->video.width -
 1909                                                 temp + mtr->video.width;
 1910                                 }
 1911 #endif
 1912                                 SAA7196_WRITE(mtr, 0x20, 0x92);
 1913                                 break;
 1914                         }
 1915                         base->routee= base->routeo= 0x39393900;
 1916                         break;
 1917                 case METEOR_GEO_YUV_PLANAR:
 1918                         mtr->depth = 2;
 1919                         temp = mtr->rows * mtr->cols;   /* compute frame size */
 1920                         mtr->frame_size = temp * mtr->depth;
 1921                         mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
 1922                         mtr->flags |= METEOR_YUV_PLANAR;
 1923                         /* recal stride and starting point */
 1924                         switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
 1925                         case METEOR_ONLY_ODD_FIELDS:
 1926                                 base->dma1o = buf;              /* Y Odd */
 1927                                 base->dma2o = buf + temp;       /* U Odd */
 1928                                 temp >>= 1;
 1929                                 base->dma3o = base->dma2o + temp; /* V Odd */
 1930                                 SAA7196_WRITE(mtr, 0x20, 0xd1);
 1931                                 break;
 1932                         case METEOR_ONLY_EVEN_FIELDS:
 1933                                 base->dma1e = buf;              /* Y Even */
 1934                                 base->dma2e = buf + temp;       /* U Even */
 1935                                 temp >>= 1;
 1936                                 base->dma2e= base->dma2e + temp; /* V Even */
 1937                                 SAA7196_WRITE(mtr, 0x20, 0xf1);
 1938                                 break;
 1939                         default: /* interlaced even/odd */
 1940                                 base->dma1e = buf;              /* Y Even */
 1941                                 base->dma2e = buf + temp;       /* U Even */
 1942                                 temp >>= 2;
 1943                                 base->dma3e = base->dma2e + temp; /* V Even */
 1944                                 base->dma1o = base->dma1e+mtr->cols;/* Y Odd */
 1945                                 base->dma2o = base->dma3e + temp; /* U Odd */
 1946                                 base->dma3o = base->dma2o + temp; /* V Odd */
 1947                                 base->stride1e = base->stride1o = mtr->cols;
 1948                                 SAA7196_WRITE(mtr, 0x20, 0x91);
 1949                                 break;
 1950                         }
 1951                         switch (geo->oformat &
 1952                                 (METEOR_GEO_YUV_12 | METEOR_GEO_YUV_9)) {
 1953                                 case METEOR_GEO_YUV_9:
 1954                                         base->routee=base->routeo = 0xaaaaffc3;
 1955                                         break;
 1956                                 case METEOR_GEO_YUV_12:
 1957                                         base->routee=base->routeo = 0xaaaaffc2;
 1958                                         break;
 1959                                 default:
 1960                                         base->routee=base->routeo = 0xaaaaffc1;
 1961                                         break;
 1962                         }
 1963                         break;
 1964                 case METEOR_GEO_YUV_422:/* same as planer, different uv order */
 1965                         mtr->depth = 2;
 1966                         temp = mtr->rows * mtr->cols;   /* compute frame size */
 1967                         mtr->frame_size = temp * mtr->depth;
 1968                         mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
 1969                         mtr->flags |= METEOR_YUV_422;
 1970                         switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
 1971                         case METEOR_ONLY_ODD_FIELDS:
 1972                                 base->dma1o = buf;
 1973                                 base->dma2o = buf + temp;
 1974                                 base->dma3o = base->dma2o  + (temp >> 1);
 1975                                 SAA7196_WRITE(mtr, 0x20, 0xd1);
 1976                                 break;
 1977                         case METEOR_ONLY_EVEN_FIELDS:
 1978                                 base->dma1e = buf;
 1979                                 base->dma2e = buf + temp;
 1980                                 base->dma3e = base->dma2e + (temp >> 1);
 1981                                 SAA7196_WRITE(mtr, 0x20, 0xf1);
 1982                                 break;
 1983                         default: /* interlaced even/odd */
 1984                                 base->dma1e = buf;              /* Y even */
 1985                                 base->dma2e = buf + temp;       /* U even */
 1986                                 base->dma3e =
 1987                                         base->dma2e + (temp >> 1);/* V even */
 1988                                 base->dma1o = base->dma1e+mtr->cols;/* Y odd */
 1989                                 temp = mtr->cols >> 1;
 1990                                 base->dma2o = base->dma2e+temp; /* U odd */
 1991                                 base->dma3o = base->dma3e+temp; /* V odd */
 1992                                 base->stride1e =
 1993                                 base->stride1o = mtr->cols;     /* Y stride */
 1994                                 base->stride2e = 
 1995                                 base->stride2o = temp;          /* U stride */
 1996                                 base->stride3e =
 1997                                 base->stride3o = temp;          /* V stride */
 1998                                 SAA7196_WRITE(mtr, 0x20, 0x91);
 1999                                 break;
 2000                         }
 2001                         switch (geo->oformat &
 2002                                 (METEOR_GEO_YUV_12 | METEOR_GEO_YUV_9)) {
 2003                                 case METEOR_GEO_YUV_9:
 2004                                         base->routee=base->routeo = 0xaaaaffc3;
 2005                                         break;
 2006                                 case METEOR_GEO_YUV_12:
 2007                                         base->routee=base->routeo = 0xaaaaffc2;
 2008                                         break;
 2009                                 default:
 2010                                         base->routee=base->routeo = 0xaaaaffc1;
 2011                                         break;
 2012                         }
 2013                         break;
 2014                 case METEOR_GEO_YUV_PACKED:
 2015                         mtr->depth = 2;
 2016                         mtr->frame_size = mtr->rows * mtr->cols * mtr->depth;
 2017                         mtr->flags &= ~METEOR_OUTPUT_FMT_MASK;
 2018                         mtr->flags |= METEOR_YUV_PACKED;
 2019                         /* recal stride and odd starting point */
 2020                         switch(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
 2021                         case METEOR_ONLY_ODD_FIELDS:
 2022                                 base->dma1o = buf;
 2023                                 SAA7196_WRITE(mtr, 0x20, 0xd1);
 2024                                 break;
 2025                         case METEOR_ONLY_EVEN_FIELDS:
 2026                                 base->dma1e = buf;
 2027                                 SAA7196_WRITE(mtr, 0x20, 0xf1);
 2028                                 break;
 2029                         default: /* interlaced even/odd */
 2030                                 base->dma1e = buf;
 2031                                 base->dma1o = buf + mtr->cols * mtr->depth;
 2032                                 base->stride1e = base->stride1o =
 2033                                         mtr->cols * mtr->depth;
 2034                                 SAA7196_WRITE(mtr, 0x20, 0x91);
 2035                                 break;
 2036                         }
 2037                         base->routee = base->routeo = 0xeeeeee41;
 2038                         break;
 2039                 default:
 2040                         error = EINVAL; /* invalid argument */
 2041                         printf("meteor%d: ioctl: invalid output format\n",unit);
 2042                         break;
 2043                 }
 2044                 /* set cols */
 2045                 SAA7196_WRITE(mtr, 0x21, mtr->cols & 0xff);
 2046                 SAA7196_WRITE(mtr, 0x24,
 2047                                 ((SAA7196_REG(mtr, 0x24) & ~0x03) |
 2048                                 ((mtr->cols >> 8) & 0x03)));
 2049                 /* set rows */
 2050                 if(mtr->flags & METEOR_ONLY_FIELDS_MASK) {
 2051                         SAA7196_WRITE(mtr, 0x25, ((mtr->rows) & 0xff));
 2052                         SAA7196_WRITE(mtr, 0x28,
 2053                                         ((SAA7196_REG(mtr, 0x28) & ~0x03) |
 2054                                         ((mtr->rows >> 8) & 0x03)));
 2055                 } else {        /* Interlaced */
 2056                         SAA7196_WRITE(mtr, 0x25, ((mtr->rows >> 1) & 0xff));
 2057                         SAA7196_WRITE(mtr, 0x28,
 2058                                         ((SAA7196_REG(mtr, 0x28) & ~0x03) |
 2059                                         ((mtr->rows >> 9) & 0x03)));
 2060                 }
 2061                 /* set signed/unsigned chrominance */
 2062                 SAA7196_WRITE(mtr, 0x30, (SAA7196_REG(mtr, 0x30) & ~0x10) |
 2063                                 ((geo->oformat&METEOR_GEO_UNSIGNED)?0:0x10));
 2064                 break;
 2065         case METEORGETGEO:
 2066                 geo = (struct meteor_geomet *) arg;
 2067                 geo->rows = mtr->rows;
 2068                 geo->columns = mtr->cols;
 2069                 geo->frames = mtr->frames;
 2070                 geo->oformat = (mtr->flags & METEOR_OUTPUT_FMT_MASK) |
 2071                                (mtr->flags & METEOR_ONLY_FIELDS_MASK) |
 2072                                (SAA7196_REG(mtr, 0x30) & 0x10 ? 
 2073                                 0:METEOR_GEO_UNSIGNED);
 2074                 switch(base->routee & 0xff) {
 2075                 case    0xc3:
 2076                         geo->oformat |=  METEOR_GEO_YUV_9;
 2077                         break;
 2078                 case    0xc2:
 2079                         geo->oformat |=  METEOR_GEO_YUV_12;
 2080                         break;
 2081                 default:
 2082                         break;
 2083                 }
 2084                 break;
 2085         case METEORSCOUNT:      /* (re)set error counts */
 2086                 cnt = (struct meteor_counts *) arg;
 2087                 mtr->fifo_errors = cnt->fifo_errors;
 2088                 mtr->dma_errors = cnt->dma_errors;
 2089                 mtr->frames_captured = cnt->frames_captured;
 2090                 mtr->even_fields_captured = cnt->even_fields_captured;
 2091                 mtr->odd_fields_captured = cnt->odd_fields_captured;
 2092                 break;
 2093         case METEORGCOUNT:      /* get error counts */
 2094                 cnt = (struct meteor_counts *) arg;
 2095                 cnt->fifo_errors = mtr->fifo_errors;
 2096                 cnt->dma_errors = mtr->dma_errors;
 2097                 cnt->frames_captured = mtr->frames_captured;
 2098                 cnt->even_fields_captured = mtr->even_fields_captured;
 2099                 cnt->odd_fields_captured = mtr->odd_fields_captured;
 2100                 break;
 2101         default:
 2102                 printf("meteor%d: ioctl: invalid ioctl request\n", unit);
 2103                 error = ENOTTY;
 2104                 break;
 2105         }
 2106         return(error);
 2107 }
 2108 
 2109 int
 2110 meteor_mmap(dev_t dev, vm_offset_t offset, int nprot)
 2111 {
 2112 
 2113         int     unit;
 2114         meteor_reg_t *mtr;
 2115 
 2116         unit = UNIT(minor(dev));
 2117         if (unit >= NMETEOR)            /* at this point could this happen? */
 2118                 return(-1);
 2119 
 2120         mtr = &(meteor[unit]);
 2121 
 2122 
 2123         if(nprot & PROT_EXEC)
 2124                 return -1;
 2125 
 2126         if(offset >= mtr->alloc_pages * PAGE_SIZE)
 2127                 return -1;
 2128 
 2129         return i386_btop(vtophys(mtr->bigbuf) + offset);
 2130 }
 2131 #endif

Cache object: 46067fd94463007676dc77a55459fcfc


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