| 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: src/sys/i386/isa/spigot.c,v 1.44 2000/01/29 16:17:36 peter Exp $ |
| 46 | * $DragonFly: src/sys/dev/misc/spigot/spigot.c,v 1.3 2003/06/25 03:55:54 dillon Exp $ |
| 47 | * |
| 48 | */ |
| 49 | |
| 50 | #include "spigot.h" |
| 51 | |
| 52 | #if NSPIGOT > 1 |
| 53 | error "Can only have 1 spigot configured." |
| 54 | #endif |
| 55 | |
| 56 | #include "opt_spigot.h" |
| 57 | |
| 58 | #include <sys/param.h> |
| 59 | #include <sys/systm.h> |
| 60 | #include <sys/conf.h> |
| 61 | #include <sys/proc.h> |
| 62 | #include <sys/signalvar.h> |
| 63 | #include <sys/mman.h> |
| 64 | |
| 65 | #include <machine/frame.h> |
| 66 | #include <machine/md_var.h> |
| 67 | #include <machine/spigot.h> |
| 68 | #include <machine/psl.h> |
| 69 | |
| 70 | #include <i386/isa/isa_device.h> |
| 71 | |
| 72 | static struct spigot_softc { |
| 73 | u_long flags; |
| 74 | u_long maddr; |
| 75 | struct proc *p; |
| 76 | u_long signal_num; |
| 77 | u_short irq; |
| 78 | } spigot_softc[NSPIGOT]; |
| 79 | |
| 80 | /* flags in softc */ |
| 81 | #define OPEN 0x01 |
| 82 | #define ALIVE 0x02 |
| 83 | |
| 84 | #define UNIT(dev) minor(dev) |
| 85 | |
| 86 | static int spigot_probe(struct isa_device *id); |
| 87 | static int spigot_attach(struct isa_device *id); |
| 88 | |
| 89 | struct isa_driver spigotdriver = {spigot_probe, spigot_attach, "spigot"}; |
| 90 | |
| 91 | static d_open_t spigot_open; |
| 92 | static d_close_t spigot_close; |
| 93 | static d_read_t spigot_read; |
| 94 | static d_write_t spigot_write; |
| 95 | static d_ioctl_t spigot_ioctl; |
| 96 | static d_mmap_t spigot_mmap; |
| 97 | |
| 98 | #define CDEV_MAJOR 11 |
| 99 | static struct cdevsw spigot_cdevsw = { |
| 100 | /* open */ spigot_open, |
| 101 | /* close */ spigot_close, |
| 102 | /* read */ spigot_read, |
| 103 | /* write */ spigot_write, |
| 104 | /* ioctl */ spigot_ioctl, |
| 105 | /* poll */ nopoll, |
| 106 | /* mmap */ spigot_mmap, |
| 107 | /* strategy */ nostrategy, |
| 108 | /* name */ "spigot", |
| 109 | /* maj */ CDEV_MAJOR, |
| 110 | /* dump */ nodump, |
| 111 | /* psize */ nopsize, |
| 112 | /* flags */ 0, |
| 113 | /* bmaj */ -1 |
| 114 | }; |
| 115 | |
| 116 | static ointhand2_t spigintr; |
| 117 | |
| 118 | static int |
| 119 | spigot_probe(struct isa_device *devp) |
| 120 | { |
| 121 | int status; |
| 122 | struct spigot_softc *ss=(struct spigot_softc *)&spigot_softc[devp->id_unit]; |
| 123 | static int once; |
| 124 | |
| 125 | if (!once++) |
| 126 | cdevsw_add(&spigot_cdevsw); |
| 127 | |
| 128 | ss->flags = 0; |
| 129 | ss->maddr = 0; |
| 130 | ss->irq = 0; |
| 131 | |
| 132 | if(devp->id_iobase != 0xad6 || inb(0xad9) == 0xff) |
| 133 | status = 0; /* not found */ |
| 134 | else { |
| 135 | status = 1; /* found */ |
| 136 | ss->flags |= ALIVE; |
| 137 | } |
| 138 | |
| 139 | return(status); |
| 140 | } |
| 141 | |
| 142 | static int |
| 143 | spigot_attach(struct isa_device *devp) |
| 144 | { |
| 145 | int unit; |
| 146 | struct spigot_softc *ss= &spigot_softc[unit = devp->id_unit]; |
| 147 | |
| 148 | devp->id_ointr = spigintr; |
| 149 | ss->maddr = kvtop(devp->id_maddr); |
| 150 | ss->irq = devp->id_irq; |
| 151 | make_dev(&spigot_cdevsw, unit, 0, 0, 0644, "spigot%d", unit); |
| 152 | return 1; |
| 153 | } |
| 154 | |
| 155 | static int |
| 156 | spigot_open(dev_t dev, int flags, int fmt, struct proc *p) |
| 157 | { |
| 158 | int error; |
| 159 | struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; |
| 160 | |
| 161 | if((ss->flags & ALIVE) == 0) |
| 162 | return ENXIO; |
| 163 | |
| 164 | if(ss->flags & OPEN) |
| 165 | return EBUSY; |
| 166 | |
| 167 | #if !defined(SPIGOT_UNSECURE) |
| 168 | /* |
| 169 | * Don't allow open() unless the process has sufficient privileges, |
| 170 | * since mapping the i/o page and granting i/o privilege would |
| 171 | * require sufficient privilege soon and nothing much can be done |
| 172 | * without them. |
| 173 | */ |
| 174 | error = suser(td); |
| 175 | if (error != 0) |
| 176 | return error; |
| 177 | if (securelevel > 0) |
| 178 | return EPERM; |
| 179 | #endif |
| 180 | |
| 181 | ss->flags |= OPEN; |
| 182 | ss->p = 0; |
| 183 | ss->signal_num = 0; |
| 184 | |
| 185 | return 0; |
| 186 | } |
| 187 | |
| 188 | static int |
| 189 | spigot_close(dev_t dev, int flags, int fmt, struct proc *p) |
| 190 | { |
| 191 | struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; |
| 192 | |
| 193 | ss->flags &= ~OPEN; |
| 194 | ss->p = 0; |
| 195 | ss->signal_num = 0; |
| 196 | |
| 197 | outb(0xad6, 0); |
| 198 | |
| 199 | return 0; |
| 200 | } |
| 201 | |
| 202 | static int |
| 203 | spigot_write(dev_t dev, struct uio *uio, int ioflag) |
| 204 | { |
| 205 | return ENXIO; |
| 206 | } |
| 207 | |
| 208 | static int |
| 209 | spigot_read(dev_t dev, struct uio *uio, int ioflag) |
| 210 | { |
| 211 | return ENXIO; |
| 212 | } |
| 213 | |
| 214 | |
| 215 | static int |
| 216 | spigot_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) |
| 217 | { |
| 218 | int error; |
| 219 | struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[UNIT(dev)]; |
| 220 | struct spigot_info *info; |
| 221 | |
| 222 | if(!data) return(EINVAL); |
| 223 | switch(cmd){ |
| 224 | case SPIGOT_SETINT: |
| 225 | ss->p = p; |
| 226 | ss->signal_num = *((int *)data); |
| 227 | break; |
| 228 | case SPIGOT_IOPL_ON: /* allow access to the IO PAGE */ |
| 229 | #if !defined(SPIGOT_UNSECURE) |
| 230 | error = suser(td); |
| 231 | if (error != 0) |
| 232 | return error; |
| 233 | if (securelevel > 0) |
| 234 | return EPERM; |
| 235 | #endif |
| 236 | p->p_md.md_regs->tf_eflags |= PSL_IOPL; |
| 237 | break; |
| 238 | case SPIGOT_IOPL_OFF: /* deny access to the IO PAGE */ |
| 239 | p->p_md.md_regs->tf_eflags &= ~PSL_IOPL; |
| 240 | break; |
| 241 | case SPIGOT_GET_INFO: |
| 242 | info = (struct spigot_info *)data; |
| 243 | info->maddr = ss->maddr; |
| 244 | info->irq = ss->irq; |
| 245 | break; |
| 246 | default: |
| 247 | return ENOTTY; |
| 248 | } |
| 249 | |
| 250 | return 0; |
| 251 | } |
| 252 | |
| 253 | /* |
| 254 | * Interrupt procedure. |
| 255 | * Just call a user level interrupt routine. |
| 256 | */ |
| 257 | static void |
| 258 | spigintr(int unit) |
| 259 | { |
| 260 | struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[unit]; |
| 261 | |
| 262 | if(ss->p && ss->signal_num) |
| 263 | psignal(ss->p, ss->signal_num); |
| 264 | } |
| 265 | |
| 266 | static int |
| 267 | spigot_mmap(dev_t dev, vm_offset_t offset, int nprot) |
| 268 | { |
| 269 | struct spigot_softc *ss = (struct spigot_softc *)&spigot_softc[0]; |
| 270 | |
| 271 | if(offset != 0) { |
| 272 | printf("spigot mmap failed, offset = 0x%x != 0x0\n", offset); |
| 273 | return -1; |
| 274 | } |
| 275 | |
| 276 | if(nprot & PROT_EXEC) |
| 277 | return -1; |
| 278 | |
| 279 | return i386_btop(ss->maddr); |
| 280 | } |