ppi.c revision 1.1
1 /* 2 * Copyright (c) 1982, 1990 The Regents of the University of California. 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 the University of 16 * California, Berkeley and its contributors. 17 * 4. 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 7.3 (Berkeley) 12/16/90 34 */ 35 36 /* 37 * Printer/Plotter HPIB interface 38 */ 39 40 #include "ppi.h" 41 #if NPPI > 0 42 43 #include "sys/param.h" 44 #include "sys/errno.h" 45 #include "sys/uio.h" 46 #include "sys/malloc.h" 47 48 #include "device.h" 49 #include "ppiioctl.h" 50 51 int ppiattach(), ppistart(), ppitimo(); 52 struct driver ppidriver = { 53 ppiattach, "ppi", ppistart, 54 }; 55 56 struct ppi_softc { 57 int sc_flags; 58 struct devqueue sc_dq; 59 struct hp_device *sc_hd; 60 struct ppiparam sc_param; 61 #define sc_burst sc_param.burst 62 #define sc_timo sc_param.timo 63 #define sc_delay sc_param.delay 64 int sc_sec; 65 } ppi_softc[NPPI]; 66 67 /* sc_flags values */ 68 #define PPIF_ALIVE 0x01 69 #define PPIF_OPEN 0x02 70 #define PPIF_UIO 0x04 71 #define PPIF_TIMO 0x08 72 #define PPIF_DELAY 0x10 73 74 #define UNIT(x) minor(x) 75 76 #ifdef DEBUG 77 int ppidebug = 0x80; 78 #define PDB_FOLLOW 0x01 79 #define PDB_IO 0x02 80 #define PDB_NOCHECK 0x80 81 #endif 82 83 ppiattach(hd) 84 register struct hp_device *hd; 85 { 86 register struct ppi_softc *sc = &ppi_softc[hd->hp_unit]; 87 88 #ifdef DEBUG 89 if ((ppidebug & PDB_NOCHECK) == 0) 90 #endif 91 /* 92 * XXX: the printer/plotter doesn't seem to really return 93 * an ID but this will at least prevent us from mistaking 94 * a cs80 disk or tape for a ppi device. 95 */ 96 if (hpibid(hd->hp_ctlr, hd->hp_slave) & 0x200) 97 return(0); 98 sc->sc_flags = PPIF_ALIVE; 99 sc->sc_dq.dq_ctlr = hd->hp_ctlr; 100 sc->sc_dq.dq_unit = hd->hp_unit; 101 sc->sc_dq.dq_slave = hd->hp_slave; 102 sc->sc_dq.dq_driver = &ppidriver; 103 sc->sc_hd = hd; 104 return(1); 105 } 106 107 ppiopen(dev, flags) 108 dev_t dev; 109 { 110 register int unit = UNIT(dev); 111 register struct ppi_softc *sc = &ppi_softc[unit]; 112 113 if (unit >= NPPI || (sc->sc_flags & PPIF_ALIVE) == 0) 114 return(ENXIO); 115 #ifdef DEBUG 116 if (ppidebug & PDB_FOLLOW) 117 printf("ppiopen(%x, %x): flags %x\n", 118 dev, flags, sc->sc_flags); 119 #endif 120 if (sc->sc_flags & PPIF_OPEN) 121 return(EBUSY); 122 sc->sc_flags |= PPIF_OPEN; 123 sc->sc_burst = PPI_BURST; 124 sc->sc_timo = ppimstohz(PPI_TIMO); 125 sc->sc_delay = ppimstohz(PPI_DELAY); 126 sc->sc_sec = -1; 127 return(0); 128 } 129 130 ppiclose(dev, flags) 131 dev_t dev; 132 { 133 register int unit = UNIT(dev); 134 register struct ppi_softc *sc = &ppi_softc[unit]; 135 136 #ifdef DEBUG 137 if (ppidebug & PDB_FOLLOW) 138 printf("ppiclose(%x, %x): flags %x\n", 139 dev, flags, sc->sc_flags); 140 #endif 141 sc->sc_flags &= ~PPIF_OPEN; 142 return(0); 143 } 144 145 ppistart(unit) 146 int unit; 147 { 148 #ifdef DEBUG 149 if (ppidebug & PDB_FOLLOW) 150 printf("ppistart(%x)\n", unit); 151 #endif 152 ppi_softc[unit].sc_flags &= ~PPIF_DELAY; 153 wakeup(&ppi_softc[unit]); 154 } 155 156 ppitimo(unit) 157 int unit; 158 { 159 #ifdef DEBUG 160 if (ppidebug & PDB_FOLLOW) 161 printf("ppitimo(%x)\n", unit); 162 #endif 163 ppi_softc[unit].sc_flags &= ~(PPIF_UIO|PPIF_TIMO); 164 wakeup(&ppi_softc[unit]); 165 } 166 167 ppiread(dev, uio) 168 dev_t dev; 169 struct uio *uio; 170 { 171 172 #ifdef DEBUG 173 if (ppidebug & PDB_FOLLOW) 174 printf("ppiread(%x, %x)\n", dev, uio); 175 #endif 176 return (ppirw(dev, uio)); 177 } 178 179 ppiwrite(dev, uio) 180 dev_t dev; 181 struct uio *uio; 182 { 183 184 #ifdef DEBUG 185 if (ppidebug & PDB_FOLLOW) 186 printf("ppiwrite(%x, %x)\n", dev, uio); 187 #endif 188 return (ppirw(dev, uio)); 189 } 190 191 ppirw(dev, uio) 192 dev_t dev; 193 register struct uio *uio; 194 { 195 int unit = UNIT(dev); 196 register struct ppi_softc *sc = &ppi_softc[unit]; 197 register int s, len, cnt; 198 register char *cp; 199 int error = 0, gotdata = 0; 200 int buflen; 201 char *buf; 202 203 if (uio->uio_resid == 0) 204 return(0); 205 206 #ifdef DEBUG 207 if (ppidebug & (PDB_FOLLOW|PDB_IO)) 208 printf("ppirw(%x, %x, %c): burst %d, timo %d, resid %x\n", 209 dev, uio, uio->uio_rw == UIO_READ ? 'R' : 'W', 210 sc->sc_burst, sc->sc_timo, uio->uio_resid); 211 #endif 212 buflen = MIN(sc->sc_burst, uio->uio_resid); 213 buf = (char *)malloc(buflen, M_DEVBUF, M_WAITOK); 214 sc->sc_flags |= PPIF_UIO; 215 if (sc->sc_timo > 0) { 216 sc->sc_flags |= PPIF_TIMO; 217 timeout(ppitimo, unit, sc->sc_timo); 218 } 219 while (uio->uio_resid > 0) { 220 len = MIN(buflen, uio->uio_resid); 221 cp = buf; 222 if (uio->uio_rw == UIO_WRITE) { 223 error = uiomove(cp, len, uio); 224 if (error) 225 break; 226 } 227 again: 228 s = splbio(); 229 if ((sc->sc_flags & PPIF_UIO) && hpibreq(&sc->sc_dq) == 0) 230 sleep(sc, PRIBIO+1); 231 /* 232 * Check if we timed out during sleep or uiomove 233 */ 234 (void) splsoftclock(); 235 if ((sc->sc_flags & PPIF_UIO) == 0) { 236 #ifdef DEBUG 237 if (ppidebug & PDB_IO) 238 printf("ppirw: uiomove/sleep timo, flags %x\n", 239 sc->sc_flags); 240 #endif 241 if (sc->sc_flags & PPIF_TIMO) { 242 untimeout(ppitimo, unit); 243 sc->sc_flags &= ~PPIF_TIMO; 244 } 245 splx(s); 246 break; 247 } 248 splx(s); 249 /* 250 * Perform the operation 251 */ 252 if (uio->uio_rw == UIO_WRITE) 253 cnt = hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, 254 sc->sc_sec, cp, len); 255 else 256 cnt = hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, 257 sc->sc_sec, cp, len); 258 s = splbio(); 259 hpibfree(&sc->sc_dq); 260 #ifdef DEBUG 261 if (ppidebug & PDB_IO) 262 printf("ppirw: %s(%d, %d, %x, %x, %d) -> %d\n", 263 uio->uio_rw == UIO_READ ? "recv" : "send", 264 sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, 265 sc->sc_sec, cp, len, cnt); 266 #endif 267 splx(s); 268 if (uio->uio_rw == UIO_READ) { 269 if (cnt) { 270 error = uiomove(cp, cnt, uio); 271 if (error) 272 break; 273 gotdata++; 274 } 275 /* 276 * Didn't get anything this time, but did in the past. 277 * Consider us done. 278 */ 279 else if (gotdata) 280 break; 281 } 282 s = splsoftclock(); 283 /* 284 * Operation timeout (or non-blocking), quit now. 285 */ 286 if ((sc->sc_flags & PPIF_UIO) == 0) { 287 #ifdef DEBUG 288 if (ppidebug & PDB_IO) 289 printf("ppirw: timeout/done\n"); 290 #endif 291 splx(s); 292 break; 293 } 294 /* 295 * Implement inter-read delay 296 */ 297 if (sc->sc_delay > 0) { 298 sc->sc_flags |= PPIF_DELAY; 299 timeout(ppistart, unit, sc->sc_delay); 300 error = tsleep(sc, PCATCH|PZERO+1, "hpib", 0); 301 if (error) { 302 splx(s); 303 break; 304 } 305 } 306 splx(s); 307 /* 308 * Must not call uiomove again til we've used all data 309 * that we already grabbed. 310 */ 311 if (uio->uio_rw == UIO_WRITE && cnt != len) { 312 cp += cnt; 313 len -= cnt; 314 cnt = 0; 315 goto again; 316 } 317 } 318 s = splsoftclock(); 319 if (sc->sc_flags & PPIF_TIMO) { 320 untimeout(ppitimo, unit); 321 sc->sc_flags &= ~PPIF_TIMO; 322 } 323 if (sc->sc_flags & PPIF_DELAY) { 324 untimeout(ppistart, unit); 325 sc->sc_flags &= ~PPIF_DELAY; 326 } 327 splx(s); 328 /* 329 * Adjust for those chars that we uiomove'ed but never wrote 330 */ 331 if (uio->uio_rw == UIO_WRITE && cnt != len) { 332 uio->uio_resid += (len - cnt); 333 #ifdef DEBUG 334 if (ppidebug & PDB_IO) 335 printf("ppirw: short write, adjust by %d\n", 336 len-cnt); 337 #endif 338 } 339 free(buf, M_DEVBUF); 340 #ifdef DEBUG 341 if (ppidebug & (PDB_FOLLOW|PDB_IO)) 342 printf("ppirw: return %d, resid %d\n", error, uio->uio_resid); 343 #endif 344 return (error); 345 } 346 347 ppiioctl(dev, cmd, data, flag) 348 dev_t dev; 349 int cmd; 350 caddr_t data; 351 int flag; 352 { 353 struct ppi_softc *sc = &ppi_softc[UNIT(dev)]; 354 struct ppiparam *pp, *upp; 355 int error = 0; 356 357 switch (cmd) { 358 case PPIIOCGPARAM: 359 pp = &sc->sc_param; 360 upp = (struct ppiparam *)data; 361 upp->burst = pp->burst; 362 upp->timo = ppihztoms(pp->timo); 363 upp->delay = ppihztoms(pp->delay); 364 break; 365 case PPIIOCSPARAM: 366 pp = &sc->sc_param; 367 upp = (struct ppiparam *)data; 368 if (upp->burst < PPI_BURST_MIN || upp->burst > PPI_BURST_MAX || 369 upp->delay < PPI_DELAY_MIN || upp->delay > PPI_DELAY_MAX) 370 return(EINVAL); 371 pp->burst = upp->burst; 372 pp->timo = ppimstohz(upp->timo); 373 pp->delay = ppimstohz(upp->delay); 374 break; 375 case PPIIOCSSEC: 376 sc->sc_sec = *(int *)data; 377 break; 378 default: 379 return(EINVAL); 380 } 381 return (error); 382 } 383 384 ppihztoms(h) 385 int h; 386 { 387 extern int hz; 388 register int m = h; 389 390 if (m > 0) 391 m = m * 1000 / hz; 392 return(m); 393 } 394 395 ppimstohz(m) 396 int m; 397 { 398 extern int hz; 399 register int h = m; 400 401 if (h > 0) { 402 h = h * hz / 1000; 403 if (h == 0) 404 h = 1000 / hz; 405 } 406 return(h); 407 } 408 #endif 409
Indexes created Wed Oct 01 18:09:54 GMT 2025