Annotation of sys/arch/hp300/dev/ppi.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ppi.c,v 1.16 2006/04/13 20:08:12 miod Exp $ */
! 2: /* $NetBSD: ppi.c,v 1.13 1997/04/02 22:37:33 scottr Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1996, 1997 Jason R. Thorpe. All rights reserved.
! 6: * Copyright (c) 1982, 1990, 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. Neither the name of the University nor the names of its contributors
! 18: * may be used to endorse or promote products derived from this software
! 19: * without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 31: * SUCH DAMAGE.
! 32: *
! 33: * @(#)ppi.c 8.1 (Berkeley) 6/16/93
! 34: */
! 35:
! 36: /*
! 37: * Printer/Plotter HPIB interface
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/conf.h>
! 43: #include <sys/device.h>
! 44: #include <sys/errno.h>
! 45: #include <sys/kernel.h>
! 46: #include <sys/malloc.h>
! 47: #include <sys/proc.h>
! 48: #include <sys/timeout.h>
! 49: #include <sys/uio.h>
! 50:
! 51: #include <hp300/dev/hpibvar.h>
! 52:
! 53: #include <hp300/dev/ppiioctl.h>
! 54:
! 55: struct ppi_softc {
! 56: struct device sc_dev;
! 57: int sc_flags;
! 58: struct hpibqueue sc_hq; /* HP-IB job queue entry */
! 59: struct ppiparam sc_param;
! 60: #define sc_burst sc_param.burst
! 61: #define sc_timo sc_param.timo
! 62: #define sc_delay sc_param.delay
! 63: int sc_sec;
! 64: int sc_slave; /* HP-IB slave address */
! 65: struct timeout sc_to; /* ppitimo timeout */
! 66: struct timeout sc_start_to; /* ppistart timeout */
! 67: };
! 68:
! 69: /* sc_flags values */
! 70: #define PPIF_ALIVE 0x01
! 71: #define PPIF_OPEN 0x02
! 72: #define PPIF_UIO 0x04
! 73: #define PPIF_TIMO 0x08
! 74: #define PPIF_DELAY 0x10
! 75:
! 76: int ppimatch(struct device *, void *, void *);
! 77: void ppiattach(struct device *, struct device *, void *);
! 78:
! 79: struct cfattach ppi_ca = {
! 80: sizeof(struct ppi_softc), ppimatch, ppiattach
! 81: };
! 82:
! 83: struct cfdriver ppi_cd = {
! 84: NULL, "ppi", DV_DULL
! 85: };
! 86:
! 87: void ppistart(void *);
! 88: void ppinoop(void *);
! 89:
! 90: void ppitimo(void *);
! 91: int ppirw(dev_t, struct uio *);
! 92: int ppihztoms(int);
! 93: int ppimstohz(int);
! 94:
! 95: cdev_decl(ppi);
! 96:
! 97: #define UNIT(x) minor(x)
! 98:
! 99: #ifdef DEBUG
! 100: int ppidebug = 0x80;
! 101: #define PDB_FOLLOW 0x01
! 102: #define PDB_IO 0x02
! 103: #define PDB_NOCHECK 0x80
! 104: #endif
! 105:
! 106: int
! 107: ppimatch(parent, match, aux)
! 108: struct device *parent;
! 109: void *match, *aux;
! 110: {
! 111: struct cfdata *cf = match;
! 112: struct hpibbus_attach_args *ha = aux;
! 113:
! 114: /*
! 115: * The printer/plotter doesn't return an ID tag.
! 116: * The check below prevents us from matching a CS80
! 117: * device by mistake.
! 118: */
! 119: if (ha->ha_id & 0x200)
! 120: return (0);
! 121:
! 122: /*
! 123: * To prevent matching all unused slots on the bus, we
! 124: * don't allow wildcarded locators.
! 125: */
! 126: if (cf->hpibbuscf_slave == HPIBBUS_SLAVE_UNK ||
! 127: cf->hpibbuscf_punit == HPIBBUS_PUNIT_UNK)
! 128: return (0);
! 129:
! 130: return (1);
! 131: }
! 132:
! 133: void
! 134: ppiattach(parent, self, aux)
! 135: struct device *parent, *self;
! 136: void *aux;
! 137: {
! 138: struct ppi_softc *sc = (struct ppi_softc *)self;
! 139: struct hpibbus_attach_args *ha = aux;
! 140:
! 141: printf("\n");
! 142:
! 143: sc->sc_slave = ha->ha_slave;
! 144:
! 145: /* Initialize the hpib queue entry. */
! 146: sc->sc_hq.hq_softc = sc;
! 147: sc->sc_hq.hq_slave = sc->sc_slave;
! 148: sc->sc_hq.hq_start = ppistart;
! 149: sc->sc_hq.hq_go = ppinoop;
! 150: sc->sc_hq.hq_intr = ppinoop;
! 151:
! 152: sc->sc_flags = PPIF_ALIVE;
! 153:
! 154: /* Initialize timeout structures */
! 155: timeout_set(&sc->sc_to, ppitimo, sc);
! 156: timeout_set(&sc->sc_start_to, ppistart, sc);
! 157: }
! 158:
! 159: void
! 160: ppinoop(arg)
! 161: void *arg;
! 162: {
! 163: /* Noop! */
! 164: }
! 165:
! 166: int
! 167: ppiopen(dev, flags, fmt, p)
! 168: dev_t dev;
! 169: int flags, fmt;
! 170: struct proc *p;
! 171: {
! 172: int unit = UNIT(dev);
! 173: struct ppi_softc *sc;
! 174:
! 175: if (unit >= ppi_cd.cd_ndevs ||
! 176: (sc = ppi_cd.cd_devs[unit]) == NULL ||
! 177: (sc->sc_flags & PPIF_ALIVE) == 0)
! 178: return (ENXIO);
! 179:
! 180: #ifdef DEBUG
! 181: if (ppidebug & PDB_FOLLOW)
! 182: printf("ppiopen(%x, %x): flags %x\n",
! 183: dev, flags, sc->sc_flags);
! 184: #endif
! 185: if (sc->sc_flags & PPIF_OPEN)
! 186: return (EBUSY);
! 187: sc->sc_flags |= PPIF_OPEN;
! 188: sc->sc_burst = PPI_BURST;
! 189: sc->sc_timo = ppimstohz(PPI_TIMO);
! 190: sc->sc_delay = ppimstohz(PPI_DELAY);
! 191: sc->sc_sec = -1;
! 192: return(0);
! 193: }
! 194:
! 195: int
! 196: ppiclose(dev, flags, fmt, p)
! 197: dev_t dev;
! 198: int flags, fmt;
! 199: struct proc *p;
! 200: {
! 201: int unit = UNIT(dev);
! 202: struct ppi_softc *sc = ppi_cd.cd_devs[unit];
! 203:
! 204: #ifdef DEBUG
! 205: if (ppidebug & PDB_FOLLOW)
! 206: printf("ppiclose(%x, %x): flags %x\n",
! 207: dev, flags, sc->sc_flags);
! 208: #endif
! 209: sc->sc_flags &= ~PPIF_OPEN;
! 210: return(0);
! 211: }
! 212:
! 213: void
! 214: ppistart(arg)
! 215: void *arg;
! 216: {
! 217: struct ppi_softc *sc = arg;
! 218:
! 219: #ifdef DEBUG
! 220: if (ppidebug & PDB_FOLLOW)
! 221: printf("ppistart(%x)\n", sc->sc_dev.dv_unit);
! 222: #endif
! 223: sc->sc_flags &= ~PPIF_DELAY;
! 224: wakeup(sc);
! 225: }
! 226:
! 227: void
! 228: ppitimo(arg)
! 229: void *arg;
! 230: {
! 231: struct ppi_softc *sc = arg;
! 232:
! 233: #ifdef DEBUG
! 234: if (ppidebug & PDB_FOLLOW)
! 235: printf("ppitimo(%x)\n", sc->sc_dev.dv_unit);
! 236: #endif
! 237: sc->sc_flags &= ~(PPIF_UIO|PPIF_TIMO);
! 238: wakeup(sc);
! 239: }
! 240:
! 241: int
! 242: ppiread(dev, uio, flags)
! 243: dev_t dev;
! 244: struct uio *uio;
! 245: int flags;
! 246: {
! 247:
! 248: #ifdef DEBUG
! 249: if (ppidebug & PDB_FOLLOW)
! 250: printf("ppiread(%x, %p)\n", dev, uio);
! 251: #endif
! 252: return (ppirw(dev, uio));
! 253: }
! 254:
! 255: int
! 256: ppiwrite(dev, uio, flags)
! 257: dev_t dev;
! 258: struct uio *uio;
! 259: int flags;
! 260: {
! 261:
! 262: #ifdef DEBUG
! 263: if (ppidebug & PDB_FOLLOW)
! 264: printf("ppiwrite(%x, %p)\n", dev, uio);
! 265: #endif
! 266: return (ppirw(dev, uio));
! 267: }
! 268:
! 269: int
! 270: ppirw(dev, uio)
! 271: dev_t dev;
! 272: struct uio *uio;
! 273: {
! 274: int unit = UNIT(dev);
! 275: struct ppi_softc *sc = ppi_cd.cd_devs[unit];
! 276: int s, len, cnt;
! 277: char *cp;
! 278: int error = 0, gotdata = 0;
! 279: int buflen, ctlr, slave;
! 280: char *buf;
! 281:
! 282: if (uio->uio_resid == 0)
! 283: return(0);
! 284:
! 285: ctlr = sc->sc_dev.dv_parent->dv_unit;
! 286: slave = sc->sc_slave;
! 287:
! 288: #ifdef DEBUG
! 289: if (ppidebug & (PDB_FOLLOW|PDB_IO))
! 290: printf("ppirw(%x, %p, %c): burst %d, timo %d, resid %x\n",
! 291: dev, uio, uio->uio_rw == UIO_READ ? 'R' : 'W',
! 292: sc->sc_burst, sc->sc_timo, uio->uio_resid);
! 293: #endif
! 294: buflen = min(sc->sc_burst, uio->uio_resid);
! 295: buf = (char *)malloc(buflen, M_DEVBUF, M_WAITOK);
! 296: sc->sc_flags |= PPIF_UIO;
! 297: if (sc->sc_timo > 0) {
! 298: sc->sc_flags |= PPIF_TIMO;
! 299: timeout_add(&sc->sc_to, sc->sc_timo);
! 300: }
! 301: len = cnt = 0;
! 302: while (uio->uio_resid > 0) {
! 303: len = min(buflen, uio->uio_resid);
! 304: cp = buf;
! 305: if (uio->uio_rw == UIO_WRITE) {
! 306: error = uiomove(cp, len, uio);
! 307: if (error)
! 308: break;
! 309: }
! 310: again:
! 311: s = splbio();
! 312: if ((sc->sc_flags & PPIF_UIO) &&
! 313: hpibreq(sc->sc_dev.dv_parent, &sc->sc_hq) == 0)
! 314: tsleep(sc, PRIBIO+1, "ppirw", 0);
! 315: /*
! 316: * Check if we timed out during sleep or uiomove
! 317: */
! 318: if ((sc->sc_flags & PPIF_UIO) == 0) {
! 319: #ifdef DEBUG
! 320: if (ppidebug & PDB_IO)
! 321: printf("ppirw: uiomove/sleep timo, flags %x\n",
! 322: sc->sc_flags);
! 323: #endif
! 324: if (sc->sc_flags & PPIF_TIMO) {
! 325: timeout_del(&sc->sc_to);
! 326: sc->sc_flags &= ~PPIF_TIMO;
! 327: }
! 328: splx(s);
! 329: break;
! 330: }
! 331: /*
! 332: * Perform the operation
! 333: */
! 334: if (uio->uio_rw == UIO_WRITE)
! 335: cnt = hpibsend(ctlr, slave, sc->sc_sec, cp, len);
! 336: else
! 337: cnt = hpibrecv(ctlr, slave, sc->sc_sec, cp, len);
! 338: hpibfree(sc->sc_dev.dv_parent, &sc->sc_hq);
! 339: #ifdef DEBUG
! 340: if (ppidebug & PDB_IO)
! 341: printf("ppirw: %s(%d, %d, %x, %p, %d) -> %d\n",
! 342: uio->uio_rw == UIO_READ ? "recv" : "send",
! 343: ctlr, slave, sc->sc_sec, cp, len, cnt);
! 344: #endif
! 345: if (uio->uio_rw == UIO_READ) {
! 346: if (cnt) {
! 347: error = uiomove(cp, cnt, uio);
! 348: if (error) {
! 349: splx(s);
! 350: break;
! 351: }
! 352: gotdata++;
! 353: }
! 354: /*
! 355: * Didn't get anything this time, but did in the past.
! 356: * Consider us done.
! 357: */
! 358: else if (gotdata) {
! 359: splx(s);
! 360: break;
! 361: }
! 362: }
! 363: /*
! 364: * Operation timeout (or non-blocking), quit now.
! 365: */
! 366: if ((sc->sc_flags & PPIF_UIO) == 0) {
! 367: #ifdef DEBUG
! 368: if (ppidebug & PDB_IO)
! 369: printf("ppirw: timeout/done\n");
! 370: #endif
! 371: splx(s);
! 372: break;
! 373: }
! 374: /*
! 375: * Implement inter-read delay
! 376: */
! 377: if (sc->sc_delay > 0) {
! 378: sc->sc_flags |= PPIF_DELAY;
! 379: timeout_add(&sc->sc_start_to, sc->sc_delay);
! 380: error = tsleep(sc, (PCATCH|PZERO) + 1, "hpib", 0);
! 381: if (error) {
! 382: splx(s);
! 383: break;
! 384: }
! 385: }
! 386: /*
! 387: * Must not call uiomove again til we've used all data
! 388: * that we already grabbed.
! 389: */
! 390: if (uio->uio_rw == UIO_WRITE && cnt != len) {
! 391: cp += cnt;
! 392: len -= cnt;
! 393: cnt = 0;
! 394: splx(s);
! 395: goto again;
! 396: }
! 397: splx(s);
! 398: }
! 399: if (sc->sc_flags & PPIF_TIMO) {
! 400: timeout_del(&sc->sc_to);
! 401: sc->sc_flags &= ~PPIF_TIMO;
! 402: }
! 403: if (sc->sc_flags & PPIF_DELAY) {
! 404: timeout_del(&sc->sc_start_to);
! 405: sc->sc_flags &= ~PPIF_DELAY;
! 406: }
! 407: /*
! 408: * Adjust for those chars that we uiomove'ed but never wrote
! 409: */
! 410: if (uio->uio_rw == UIO_WRITE && cnt != len) {
! 411: uio->uio_resid += (len - cnt);
! 412: #ifdef DEBUG
! 413: if (ppidebug & PDB_IO)
! 414: printf("ppirw: short write, adjust by %d\n",
! 415: len-cnt);
! 416: #endif
! 417: }
! 418: free(buf, M_DEVBUF);
! 419: #ifdef DEBUG
! 420: if (ppidebug & (PDB_FOLLOW|PDB_IO))
! 421: printf("ppirw: return %d, resid %d\n", error, uio->uio_resid);
! 422: #endif
! 423: return (error);
! 424: }
! 425:
! 426: int
! 427: ppiioctl(dev, cmd, data, flag, p)
! 428: dev_t dev;
! 429: u_long cmd;
! 430: caddr_t data;
! 431: int flag;
! 432: struct proc *p;
! 433: {
! 434: struct ppi_softc *sc = ppi_cd.cd_devs[UNIT(dev)];
! 435: struct ppiparam *pp, *upp;
! 436: int tmp;
! 437: int error = 0;
! 438:
! 439: switch (cmd) {
! 440: case PPIIOCGPARAM:
! 441: pp = &sc->sc_param;
! 442: upp = (struct ppiparam *)data;
! 443: upp->burst = pp->burst;
! 444: upp->timo = ppihztoms(pp->timo);
! 445: upp->delay = ppihztoms(pp->delay);
! 446: break;
! 447: case PPIIOCSPARAM:
! 448: pp = &sc->sc_param;
! 449: upp = (struct ppiparam *)data;
! 450: if (upp->burst < PPI_BURST_MIN || upp->burst > PPI_BURST_MAX ||
! 451: upp->delay < PPI_DELAY_MIN || upp->delay > PPI_DELAY_MAX)
! 452: return(EINVAL);
! 453: pp->burst = upp->burst;
! 454: pp->timo = ppimstohz(upp->timo);
! 455: pp->delay = ppimstohz(upp->delay);
! 456: break;
! 457: case PPIIOCSSEC:
! 458: tmp = *(int *)data;
! 459: if (tmp == -1 || (tmp >= 0 && tmp <= 0x1f))
! 460: sc->sc_sec = tmp;
! 461: else
! 462: error = EINVAL;
! 463: break;
! 464: default:
! 465: return (ENOTTY);
! 466: }
! 467: return (error);
! 468: }
! 469:
! 470: int
! 471: ppihztoms(h)
! 472: int h;
! 473: {
! 474: int m = h;
! 475:
! 476: if (m > 0)
! 477: m = m * 1000 / hz;
! 478: return(m);
! 479: }
! 480:
! 481: int
! 482: ppimstohz(m)
! 483: int m;
! 484: {
! 485: int h = m;
! 486:
! 487: if (h > 0) {
! 488: h = h * hz / 1000;
! 489: if (h == 0)
! 490: h = 1000 / hz;
! 491: }
! 492: return(h);
! 493: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ppi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / dev