sys/dev/mvme/lpt_mvme.c

   1 /*      $NetBSD: lpt_mvme.c,v 1.15 2009/03/14 15:36:19 dsl Exp $        */
   2
   3 /*-
   4  * Copyright (c) 1999, 2002 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Steve C. Woodford.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Copyright (c) 1993, 1994 Charles M. Hannum.
  34  * Copyright (c) 1990 William F. Jolitz, TeleMuse
  35  * All rights reserved.
  36  *
  37  * Redistribution and use in source and binary forms, with or without
  38  * modification, are permitted provided that the following conditions
  39  * are met:
  40  * 1. Redistributions of source code must retain the above copyright
  41  *    notice, this list of conditions and the following disclaimer.
  42  * 2. Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in the
  44  *    documentation and/or other materials provided with the distribution.
  45  * 3. All advertising materials mentioning features or use of this software
  46  *    must display the following acknowledgement:
  47  *      This software is a component of "386BSD" developed by
  48  *      William F. Jolitz, TeleMuse.
  49  * 4. Neither the name of the developer nor the name "386BSD"
  50  *    may be used to endorse or promote products derived from this software
  51  *    without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS A COMPONENT OF 386BSD DEVELOPED BY WILLIAM F. JOLITZ
  54  * AND IS INTENDED FOR RESEARCH AND EDUCATIONAL PURPOSES ONLY. THIS
  55  * SOFTWARE SHOULD NOT BE CONSIDERED TO BE A COMMERCIAL PRODUCT.
  56  * THE DEVELOPER URGES THAT USERS WHO REQUIRE A COMMERCIAL PRODUCT
  57  * NOT MAKE USE OF THIS WORK.
  58  *
  59  * FOR USERS WHO WISH TO UNDERSTAND THE 386BSD SYSTEM DEVELOPED
  60  * BY WILLIAM F. JOLITZ, WE RECOMMEND THE USER STUDY WRITTEN
  61  * REFERENCES SUCH AS THE  "PORTING UNIX TO THE 386" SERIES
  62  * (BEGINNING JANUARY 1991 "DR. DOBBS JOURNAL", USA AND BEGINNING
  63  * JUNE 1991 "UNIX MAGAZIN", GERMANY) BY WILLIAM F. JOLITZ AND
  64  * LYNNE GREER JOLITZ, AS WELL AS OTHER BOOKS ON UNIX AND THE
  65  * ON-LINE 386BSD USER MANUAL BEFORE USE. A BOOK DISCUSSING THE INTERNALS
  66  * OF 386BSD ENTITLED "386BSD FROM THE INSIDE OUT" WILL BE AVAILABLE LATE 1992.
  67  *
  68  * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER ``AS IS'' AND
  69  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  70  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  71  * ARE DISCLAIMED.  IN NO EVENT SHALL THE DEVELOPER BE LIABLE
  72  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  73  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  74  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  75  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  76  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  77  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  78  * SUCH DAMAGE.
  79  */
  80
  81 /*
  82  * Device Driver for an MVME68K/MVME88K board's parallel printer port
  83  * This driver attaches above the board-specific back-end.
  84  */
  85
  86 #include <sys/cdefs.h>
  87 __KERNEL_RCSID(0, "$NetBSD: lpt_mvme.c,v 1.15 2009/03/14 15:36:19 dsl Exp $");
  88
  89 #include <sys/param.h>
  90 #include <sys/systm.h>
  91 #include <sys/proc.h>
  92 #include <sys/buf.h>
  93 #include <sys/kernel.h>
  94 #include <sys/ioctl.h>
  95 #include <sys/uio.h>
  96 #include <sys/device.h>
  97 #include <sys/conf.h>
  98 #include <sys/syslog.h>
  99
 100 #include <sys/cpu.h>
 101 #include <sys/bus.h>
 102
 103 #include <dev/mvme/lptvar.h>
 104
 105
 106 #define TIMEOUT         hz*16   /* wait up to 16 seconds for a ready */
 107 #define STEP            hz/4
 108
 109 #define LPTPRI          (PZERO+8)
 110 #define LPT_BSIZE       1024
 111
 112 #if !defined(DEBUG) || !defined(notdef)
 113 #define LPRINTF(a)
 114 #else
 115 #define LPRINTF         if (lptdebug) aprint_verbose_dev a
 116 int lptdebug = 1;
 117 #endif
 118
 119 #define LPTUNIT(s)      (minor(s) & 0x0f)
 120 #define LPTFLAGS(s)     (minor(s) & 0xf0)
 121
 122 static void lpt_wakeup(void *arg);
 123 static int pushbytes(struct lpt_softc *);
 124
 125 extern struct cfdriver lpt_cd;
 126
 127 dev_type_open(lptopen);
 128 dev_type_close(lptclose);
 129 dev_type_write(lptwrite);
 130 dev_type_ioctl(lptioctl);
 131
 132 const struct cdevsw lpt_cdevsw = {
 133         lptopen, lptclose, noread, lptwrite, lptioctl,
 134         nostop, notty, nopoll, nommap, nokqfilter,
 135 };
 136
 137 void
 138 lpt_attach_subr(struct lpt_softc *sc)
 139 {
 140
 141         sc->sc_state = 0;
 142         callout_init(&sc->sc_wakeup_ch, 0);
 143 }
 144
 145 /*
 146  * Reset the printer, then wait until it's selected and not busy.
 147  */
 148 int
 149 lptopen(dev_t dev, int flag, int mode, struct lwp *l)
 150 {
 151         u_char flags;
 152         struct lpt_softc *sc;
 153         int error;
 154         int spin;
 155
 156         flags = LPTFLAGS(dev);
 157
 158         sc = device_lookup_private(&lpt_cd, LPTUNIT(dev));
 159         if (!sc)
 160                 return (ENXIO);
 161
 162 #ifdef DIAGNOSTIC
 163         if (sc->sc_state)
 164                 aprint_verbose_dev(sc->sc_dev, "stat=0x%x not zero\n",
 165                     sc->sc_state);
 166 #endif
 167
 168         if (sc->sc_state)
 169                 return (EBUSY);
 170
 171         sc->sc_state = LPT_INIT;
 172         sc->sc_flags = flags;
 173         LPRINTF((sc->sc_dev, "open: flags=0x%x\n", flags));
 174
 175         if ((flags & LPT_NOPRIME) == 0) {
 176                 /* assert Input Prime for 100 usec to start up printer */
 177                 (sc->sc_funcs->lf_iprime) (sc);
 178         }
 179
 180         /* select fast or slow strobe depending on minor device number */
 181         if (flags & LPT_FAST_STROBE)
 182                 (sc->sc_funcs->lf_speed) (sc, LPT_STROBE_FAST);
 183         else
 184                 (sc->sc_funcs->lf_speed) (sc, LPT_STROBE_SLOW);
 185
 186         /* wait till ready (printer running diagnostics) */
 187         for (spin = 0; (sc->sc_funcs->lf_notrdy) (sc, 1); spin += STEP) {
 188                 if (spin >= TIMEOUT) {
 189                         sc->sc_state = 0;
 190                         return (EBUSY);
 191                 }
 192                 /* wait 1/4 second, give up if we get a signal */
 193                 error = tsleep((void *) sc, LPTPRI | PCATCH, "lptopen", STEP);
 194                 if (error != EWOULDBLOCK) {
 195                         sc->sc_state = 0;
 196                         return (error);
 197                 }
 198         }
 199
 200         sc->sc_inbuf = geteblk(LPT_BSIZE);
 201         sc->sc_count = 0;
 202         sc->sc_state = LPT_OPEN;
 203
 204         if ((sc->sc_flags & LPT_NOINTR) == 0)
 205                 lpt_wakeup(sc);
 206
 207         (sc->sc_funcs->lf_open) (sc, sc->sc_flags & LPT_NOINTR);
 208
 209         LPRINTF((sc->sc_dev, "opened\n"));
 210         return (0);
 211 }
 212
 213 void
 214 lpt_wakeup(void *arg)
 215 {
 216         struct lpt_softc *sc;
 217         int s;
 218
 219         sc = arg;
 220
 221         s = spltty();
 222         lpt_intr(sc);
 223         splx(s);
 224
 225         callout_reset(&sc->sc_wakeup_ch, STEP, lpt_wakeup, sc);
 226 }
 227
 228 /*
 229  * Close the device, and free the local line buffer.
 230  */
 231 int
 232 lptclose(dev_t dev, int flag, int mode, struct lwp *l)
 233 {
 234         struct lpt_softc *sc;
 235
 236         sc = device_lookup_private(&lpt_cd, LPTUNIT(dev));
 237
 238         if (sc->sc_count)
 239                 (void) pushbytes(sc);
 240
 241         if ((sc->sc_flags & LPT_NOINTR) == 0)
 242                 callout_stop(&sc->sc_wakeup_ch);
 243
 244         (sc->sc_funcs->lf_close) (sc);
 245
 246         sc->sc_state = 0;
 247         brelse(sc->sc_inbuf, 0);
 248
 249         LPRINTF((sc->sc_dev, "%s: closed\n"));
 250         return (0);
 251 }
 252
 253 int
 254 pushbytes(struct lpt_softc *sc)
 255 {
 256         int s, error, spin, tic;
 257
 258         if (sc->sc_flags & LPT_NOINTR) {
 259                 while (sc->sc_count > 0) {
 260                         spin = 0;
 261                         while ((sc->sc_funcs->lf_notrdy) (sc, 0)) {
 262                                 if (++spin < sc->sc_spinmax)
 263                                         continue;
 264                                 tic = 0;
 265                                 /* adapt busy-wait algorithm */
 266                                 sc->sc_spinmax++;
 267                                 while ((sc->sc_funcs->lf_notrdy) (sc, 1)) {
 268                                         /* exponential backoff */
 269                                         tic = tic + tic + 1;
 270                                         if (tic > TIMEOUT)
 271                                                 tic = TIMEOUT;
 272                                         error = tsleep((void *) sc,
 273                                             LPTPRI | PCATCH, "lptpsh", tic);
 274                                         if (error != EWOULDBLOCK)
 275                                                 return (error);
 276                                 }
 277                                 break;
 278                         }
 279
 280                         (sc->sc_funcs->lf_wrdata) (sc, *sc->sc_cp++);
 281                         sc->sc_count--;
 282
 283                         /* adapt busy-wait algorithm */
 284                         if (spin * 2 + 16 < sc->sc_spinmax)
 285                                 sc->sc_spinmax--;
 286                 }
 287         } else {
 288                 while (sc->sc_count > 0) {
 289                         /* if the printer is ready for a char, give it one */
 290                         if ((sc->sc_state & LPT_OBUSY) == 0) {
 291                                 LPRINTF((sc->sc_dev, "write %d\n",
 292                                         sc->sc_count));
 293                                 s = spltty();
 294                                 (void) lpt_intr(sc);
 295                                 splx(s);
 296                         }
 297                         error = tsleep((void *) sc, LPTPRI | PCATCH,
 298                             "lptwrite2", 0);
 299                         if (error)
 300                                 return (error);
 301                 }
 302         }
 303         return (0);
 304 }
 305
 306 /*
 307  * Copy a line from user space to a local buffer, then call putc to get the
 308  * chars moved to the output queue.
 309  */
 310 int
 311 lptwrite(dev_t dev, struct uio *uio, int flags)
 312 {
 313         struct lpt_softc *sc;
 314         size_t n;
 315         int error;
 316
 317         sc = device_lookup_private(&lpt_cd, LPTUNIT(dev));
 318         error = 0;
 319
 320         while ((n = min(LPT_BSIZE, uio->uio_resid)) != 0) {
 321                 uiomove(sc->sc_cp = sc->sc_inbuf->b_data, n, uio);
 322                 sc->sc_count = n;
 323                 error = pushbytes(sc);
 324                 if (error) {
 325                         /*
 326                          * Return accurate residual if interrupted or timed
 327                          * out.
 328                          */
 329                         uio->uio_resid += sc->sc_count;
 330                         sc->sc_count = 0;
 331                         return (error);
 332                 }
 333         }
 334         return (0);
 335 }
 336
 337 /*
 338  * Handle printer interrupts which occur when the printer is ready to accept
 339  * another char.
 340  */
 341 int
 342 lpt_intr(struct lpt_softc *sc)
 343 {
 344
 345         if (sc->sc_count) {
 346                 /* send char */
 347                 (sc->sc_funcs->lf_wrdata) (sc, *sc->sc_cp++);
 348                 sc->sc_count--;
 349                 sc->sc_state |= LPT_OBUSY;
 350         } else
 351                 sc->sc_state &= ~LPT_OBUSY;
 352
 353         if (sc->sc_count == 0) {
 354                 /* none, wake up the top half to get more */
 355                 wakeup((void *) sc);
 356         }
 357
 358         return (1);
 359 }
 360
 361 /* ARGSUSED */
 362 int
 363 lptioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
 364 {
 365
 366         return (ENODEV);
 367 }