spigot.c

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

    1 /*
    2  * Video spigot capture driver.
    3  *
    4  * Copyright (c) 1995, Jim Lowe.  All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions are
    8  * met: 1. Redistributions of source code must retain the above copyright
    9  * notice, this list of conditions and the following disclaimer. 2.
   10  * Redistributions in binary form must reproduce the above copyright notice,
   11  * this list of conditions and the following disclaimer in the documentation
   12  * and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
   15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   17  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
   18  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   20  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   21  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  * This is the minimum driver code required to make a spigot work.
   27  * Unfortunatly, I can't include a real driver since the information
   28  * on the spigot is under non-disclosure.  You can pick up a library
   29  * that will work with this driver from
   30  * ftp://ftp.cs.uwm.edu/pub/FreeBSD-UWM.  The library contains the
   31  * source that I can release as well as several object modules and
   32  * functions that allows one to read spigot data.  See the code for
   33  * spigot_grab.c that is included with the library data.
   34  *
   35  * The vendor will not allow me to release the spigot library code.
   36  * Please don't ask me for it.
   37  *
   38  * To use this driver you will need the spigot library.  The library is
   39  * available from:
   40  *
   41  *      ftp.cs.uwm.edu://pub/FreeBSD-UWM/spigot/spigot.tar.gz
   42  *
   43  * Version 1.7, December 1995.
   44  *
   45  * $FreeBSD$
   46  *
   47  */
   48 
   49 #include        "spigot.h"
   50 
   51 #if NSPIGOT > 1
   52 error "Can only have 1 spigot configured."
   53 #endif
   54 
   55 #include        "opt_spigot.h"
   56 
   57 #include        <sys/param.h>
   58 #include        <sys/systm.h>
   59 #include        <sys/conf.h>
   60 #include        <sys/proc.h>
   61 #include        <sys/signalvar.h>
   62 #include        <sys/mman.h>
   63 
   64 #include        <machine/frame.h>
   65 #include        <machine/md_var.h>
   66 #include        <machine/spigot.h>
   67 #include        <machine/psl.h>
   68 
   69 #include        <i386/isa/isa_device.h>
   70 
   71 static struct spigot_softc {
   72         u_long          flags;
   73         u_long          maddr;
   74         struct proc     *p;
   75         u_long          signal_num;
   76         u_short         irq;
   77 } spigot_softc[NSPIGOT];
   78 
   79 /* flags in softc */
   80 #define OPEN            0x01
   81 #define ALIVE           0x02
   82 
   83 #define UNIT(dev) minor(dev)
   84 
   85 static int      spigot_probe(struct isa_device *id);
   86 static int      spigot_attach(struct isa_device *id);
   87 
   88 struct isa_driver       spigotdriver = {spigot_probe, spigot_attach, "spigot"};
   89 
   90 static  d_open_t        spigot_open;
   91 static  d_close_t       spigot_close;
   92 static  d_read_t        spigot_read;
   93 static  d_write_t       spigot_write;
   94 static  d_ioctl_t       spigot_ioctl;
   95 static  d_mmap_t        spigot_mmap;
   96 
   97 #define CDEV_MAJOR 11
   98 static struct cdevsw spigot_cdevsw = {
   99         /* open */      spigot_open,
  100         /* close */     spigot_close,
  101         /* read */      spigot_read,
  102         /* write */     spigot_write,
  103         /* ioctl */     spigot_ioctl,
  104         /* poll */      nopoll,
  105         /* mmap */      spigot_mmap,
  106         /* strategy */  nostrategy,
  107         /* name */      "spigot",
  108         /* maj */       CDEV_MAJOR,
  109         /* dump */      nodump,
  110         /* psize */     nopsize,
  111         /* flags */     0,
  112         /* bmaj */      -1
  113 };
  114 
  115 static ointhand2_t      spigintr;
  116 
  117 static int
  118 spigot_probe(struct isa_device *devp)
  119 {
  120 int                     status;
  121 struct  spigot_softc    *ss=(struct spigot_softc *)&spigot_softc[devp->id_unit];
  122 static int once;
  123 
  124         if (!once++)
  125                 cdevsw_add(&spigot_cdevsw);
  126 
  127         ss->flags = 0;
  128         ss->maddr = 0;
  129         ss->irq = 0;
  130 
  131         if(devp->id_iobase != 0xad6 || inb(0xad9) == 0xff) 
  132                 status = 0;     /* not found */
  133         else {
  134                 status = 1;     /* found */
  135                 ss->flags |= ALIVE;
  136         }
  137 
  138         return(status);
  139 }
  140 
  141 static int
  142 spigot_attach(struct isa_device *devp)
  143 {
  144         int     unit;
  145         struct  spigot_softc    *ss= &spigot_softc[unit = devp->id_unit];
  146 
  147         devp->id_ointr = spigintr;
  148         ss->maddr = kvtop(devp->id_maddr);
  149         ss->irq = devp->id_irq;
  150         make_dev(&spigot_cdevsw, unit, 0, 0, 0644, "spigot%d", unit);
  151         return 1;
  152 }
  153 
  154 static  int
  155 spigot_open(dev_t dev, int flags, int fmt, struct proc *p)
  156 {
  157 int                     error;
  158 struct  spigot_softc    *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)];
  159 
  160         if((ss->flags & ALIVE) == 0)
  161                 return ENXIO;
  162 
  163         if(ss->flags & OPEN)
  164                 return EBUSY;
  165 
  166 #if !defined(SPIGOT_UNSECURE)
  167         /*
  168          * Don't allow open() unless the process has sufficient privileges,
  169          * since mapping the i/o page and granting i/o privilege would
  170          * require sufficient privilege soon and nothing much can be done
  171          * without them.
  172          */
  173         error = suser(p);
  174         if (error != 0)
  175                 return error;
  176         if (securelevel > 0)
  177                 return EPERM;
  178 #endif
  179 
  180         ss->flags |= OPEN;
  181         ss->p = 0;
  182         ss->signal_num = 0;
  183 
  184         return 0;
  185 }
  186 
  187 static  int
  188 spigot_close(dev_t dev, int flags, int fmt, struct proc *p)
  189 {
  190 struct  spigot_softc    *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)];
  191 
  192         ss->flags &= ~OPEN;
  193         ss->p = 0;
  194         ss->signal_num = 0;
  195 
  196         outb(0xad6, 0);
  197 
  198         return 0;
  199 }
  200 
  201 static  int
  202 spigot_write(dev_t dev, struct uio *uio, int ioflag)
  203 {
  204         return ENXIO;
  205 }
  206 
  207 static  int
  208 spigot_read(dev_t dev, struct uio *uio, int ioflag)
  209 {
  210         return ENXIO;
  211 }
  212 
  213 
  214 static  int
  215 spigot_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
  216 {
  217 int                     error;
  218 struct  spigot_softc    *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)];
  219 struct  spigot_info     *info;
  220 
  221         if(!data) return(EINVAL);
  222         switch(cmd){
  223         case    SPIGOT_SETINT:
  224                 if (*(int *)data < 0 || *(int *)data > _SIG_MAXSIG)
  225                         return (EINVAL);
  226                 ss->p = p;
  227                 ss->signal_num = *((int *)data);
  228                 break;
  229         case    SPIGOT_IOPL_ON: /* allow access to the IO PAGE */
  230 #if !defined(SPIGOT_UNSECURE)
  231                 error = suser(p);
  232                 if (error != 0)
  233                         return error;
  234                 if (securelevel > 0)
  235                         return EPERM;
  236 #endif
  237                 p->p_md.md_regs->tf_eflags |= PSL_IOPL;
  238                 break;
  239         case    SPIGOT_IOPL_OFF: /* deny access to the IO PAGE */
  240                 p->p_md.md_regs->tf_eflags &= ~PSL_IOPL;
  241                 break;
  242         case    SPIGOT_GET_INFO:
  243                 info = (struct spigot_info *)data;
  244                 info->maddr  = ss->maddr;
  245                 info->irq = ss->irq;
  246                 break;
  247         default:
  248                 return ENOTTY;
  249         }
  250 
  251         return 0;
  252 }
  253 
  254 /*
  255  * Interrupt procedure.
  256  * Just call a user level interrupt routine.
  257  */
  258 static void
  259 spigintr(int unit)
  260 {
  261 struct  spigot_softc    *ss = (struct spigot_softc *)&spigot_softc[unit];
  262 
  263         if(ss->p && ss->signal_num)
  264                 psignal(ss->p, ss->signal_num);
  265 }
  266 
  267 static  int
  268 spigot_mmap(dev_t dev, vm_offset_t offset, int nprot)
  269 {
  270 struct  spigot_softc    *ss = (struct spigot_softc *)&spigot_softc[0];
  271 
  272         if(offset != 0) {
  273                 printf("spigot mmap failed, offset = 0x%x != 0x0\n", offset);
  274                 return -1;
  275         }
  276 
  277         if(nprot & PROT_EXEC)
  278                 return -1;
  279 
  280         return i386_btop(ss->maddr);
  281 }

Cache object: 16c73b994121a1b592a3474835d7814f

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

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

FreeBSD/Linux Kernel Cross Reference sys/i386/isa/spigot.c

FreeBSD/Linux Kernel Cross Reference
sys/i386/isa/spigot.c