sys/pc98/cbus/olpt.c

   1 /*-
   2  * Copyright (c) 1990 William F. Jolitz, TeleMuse
   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 software is a component of "386BSD" developed by
  16  *      William F. Jolitz, TeleMuse.
  17  * 4. Neither the name of the developer nor the name "386BSD"
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS A COMPONENT OF 386BSD DEVELOPED BY WILLIAM F. JOLITZ
  22  * AND IS INTENDED FOR RESEARCH AND EDUCATIONAL PURPOSES ONLY. THIS
  23  * SOFTWARE SHOULD NOT BE CONSIDERED TO BE A COMMERCIAL PRODUCT.
  24  * THE DEVELOPER URGES THAT USERS WHO REQUIRE A COMMERCIAL PRODUCT
  25  * NOT MAKE USE OF THIS WORK.
  26  *
  27  * FOR USERS WHO WISH TO UNDERSTAND THE 386BSD SYSTEM DEVELOPED
  28  * BY WILLIAM F. JOLITZ, WE RECOMMEND THE USER STUDY WRITTEN
  29  * REFERENCES SUCH AS THE  "PORTING UNIX TO THE 386" SERIES
  30  * (BEGINNING JANUARY 1991 "DR. DOBBS JOURNAL", USA AND BEGINNING
  31  * JUNE 1991 "UNIX MAGAZIN", GERMANY) BY WILLIAM F. JOLITZ AND
  32  * LYNNE GREER JOLITZ, AS WELL AS OTHER BOOKS ON UNIX AND THE
  33  * ON-LINE 386BSD USER MANUAL BEFORE USE. A BOOK DISCUSSING THE INTERNALS
  34  * OF 386BSD ENTITLED "386BSD FROM THE INSIDE OUT" WILL BE AVAILABLE LATE 1992.
  35  *
  36  * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER ``AS IS'' AND
  37  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  39  * ARE DISCLAIMED.  IN NO EVENT SHALL THE DEVELOPER BE LIABLE
  40  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  41  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  42  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  44  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  45  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46  * SUCH DAMAGE.
  47  *
  48  *      from: unknown origin, 386BSD 0.1
  49  * $FreeBSD$
  50  */
  51
  52 /*
  53  * Device Driver for AT parallel printer port
  54  * Written by William Jolitz 12/18/90
  55  */
  56
  57 /*
  58  * Parallel port TCP/IP interfaces added.  I looked at the driver from
  59  * MACH but this is a complete rewrite, and btw. incompatible, and it
  60  * should perform better too.  I have never run the MACH driver though.
  61  *
  62  * This driver sends two bytes (0x08, 0x00) in front of each packet,
  63  * to allow us to distinguish another format later.
  64  *
  65  * Now added a Linux/Crynwr compatibility mode which is enabled using
  66  * IF_LINK0 - Tim Wilkinson.
  67  *
  68  * TODO:
  69  *    Make HDLC/PPP mode, use IF_LLC1 to enable.
  70  *
  71  * Connect the two computers using a Laplink parallel cable to use this
  72  * feature:
  73  *
  74  *      +----------------------------------------+
  75  *      |A-name A-End   B-End   Descr.  Port/Bit |
  76  *      +----------------------------------------+
  77  *      |DATA0  2       15      Data    0/0x01   |
  78  *      |-ERROR 15      2               1/0x08   |
  79  *      +----------------------------------------+
  80  *      |DATA1  3       13      Data    0/0x02   |
  81  *      |+SLCT  13      3               1/0x10   |
  82  *      +----------------------------------------+
  83  *      |DATA2  4       12      Data    0/0x04   |
  84  *      |+PE    12      4               1/0x20   |
  85  *      +----------------------------------------+
  86  *      |DATA3  5       10      Strobe  0/0x08   |
  87  *      |-ACK   10      5               1/0x40   |
  88  *      +----------------------------------------+
  89  *      |DATA4  6       11      Data    0/0x10   |
  90  *      |BUSY   11      6               1/~0x80  |
  91  *      +----------------------------------------+
  92  *      |GND    18-25   18-25   GND     -        |
  93  *      +----------------------------------------+
  94  *
  95  * Expect transfer-rates up to 75 kbyte/sec.
  96  *
  97  * If GCC could correctly grok
  98  *      register int port asm("edx")
  99  * the code would be cleaner
 100  *
 101  * Poul-Henning Kamp <phk@freebsd.org>
 102  */
 103
 104 #include <sys/param.h>
 105 #include <sys/systm.h>
 106 #include <sys/conf.h>
 107 #include <sys/bus.h>
 108 #include <sys/kernel.h>
 109 #include <sys/module.h>
 110 #include <sys/uio.h>
 111 #include <sys/syslog.h>
 112 #include <sys/malloc.h>
 113
 114 #include <machine/bus.h>
 115 #include <machine/resource.h>
 116 #include <sys/rman.h>
 117
 118 #include <isa/isavar.h>
 119
 120 #include <pc98/cbus/olptreg.h>
 121 #include <dev/ppbus/lptio.h>
 122
 123 #define LPINITRDY       4       /* wait up to 4 seconds for a ready */
 124 #define LPTOUTINITIAL   10      /* initial timeout to wait for ready 1/10 s */
 125 #define LPTOUTMAX       1       /* maximal timeout 1 s */
 126 #define LPPRI           (PZERO+8)
 127 #define BUFSIZE         1024
 128
 129 #ifndef DEBUG
 130 #define lprintf(args)
 131 #else
 132 #define lprintf(args)   do {                            \
 133                                 if (lptflag)            \
 134                                         printf args;    \
 135                         } while (0)
 136 static int volatile lptflag = 1;
 137 #endif
 138
 139 #define LPTUNIT(s)      ((s)&0x03)
 140 #define LPTFLAGS(s)     ((s)&0xfc)
 141
 142 struct lpt_softc {
 143         struct resource *res_port;
 144         struct resource *res_irq;
 145         void *sc_ih;
 146
 147         int     sc_port;
 148         short   sc_state;
 149         /* default case: negative prime, negative ack, handshake strobe,
 150            prime once */
 151         u_char  sc_control;
 152         char    sc_flags;
 153 #define LP_POS_INIT     0x04    /* if we are a postive init signal */
 154 #define LP_POS_ACK      0x08    /* if we are a positive going ack */
 155 #define LP_NO_PRIME     0x10    /* don't prime the printer at all */
 156 #define LP_PRIMEOPEN    0x20    /* prime on every open */
 157 #define LP_AUTOLF       0x40    /* tell printer to do an automatic lf */
 158 #define LP_BYPASS       0x80    /* bypass  printer ready checks */
 159         void    *sc_inbuf;
 160         short   sc_xfercnt ;
 161         char    sc_primed;
 162         char    *sc_cp ;
 163         u_char  sc_irq ;        /* IRQ status of port */
 164 #define LP_HAS_IRQ      0x01    /* we have an irq available */
 165 #define LP_USE_IRQ      0x02    /* we are using our irq */
 166 #define LP_ENABLE_IRQ   0x04    /* enable IRQ on open */
 167         u_char  sc_backoff ;    /* time to call lptout() again */
 168 };
 169
 170 /* bits for state */
 171 #define OPEN            (1<<0)  /* device is open */
 172 #define ASLP            (1<<1)  /* awaiting draining of printer */
 173 #define ERROR           (1<<2)  /* error was received from printer */
 174 #define OBUSY           (1<<3)  /* printer is busy doing output */
 175 #define LPTOUT          (1<<4)  /* timeout while not selected */
 176 #define TOUT            (1<<5)  /* timeout while not selected */
 177 #define INIT            (1<<6)  /* waiting to initialize for open */
 178 #define INTERRUPTED     (1<<7)  /* write call was interrupted */
 179
 180
 181 /* status masks to interrogate printer status */
 182 #define RDY_MASK        (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)     /* ready ? */
 183 #define LP_READY        (LPS_SEL|LPS_NBSY|LPS_NERR)
 184
 185 /* Printer Ready condition  - from lpa.c */
 186 /* Only used in polling code */
 187 #define NOT_READY(x)    ((inb(x) & LPS_NBSY) != LPS_NBSY)
 188
 189 #define MAX_SLEEP       (hz*5)  /* Timeout while waiting for device ready */
 190 #define MAX_SPIN        20      /* Max delay for device ready in usecs */
 191
 192 static timeout_t lptout;
 193 static int lpt_probe(device_t);
 194 static int lpt_attach(device_t);
 195 static void lpt_intr(void *);
 196
 197 static devclass_t olpt_devclass;
 198
 199 static device_method_t olpt_methods[] = {
 200         DEVMETHOD(device_probe,         lpt_probe),
 201         DEVMETHOD(device_attach,        lpt_attach),
 202         { 0, 0 }
 203 };
 204
 205 static driver_t olpt_driver = {
 206         "olpt",
 207         olpt_methods,
 208         sizeof (struct lpt_softc),
 209 };
 210
 211 DRIVER_MODULE(olpt, isa, olpt_driver, olpt_devclass, 0, 0);
 212
 213 static  d_open_t        lptopen;
 214 static  d_close_t       lptclose;
 215 static  d_write_t       lptwrite;
 216 static  d_ioctl_t       lptioctl;
 217
 218 static struct cdevsw lpt_cdevsw = {
 219         .d_version =    D_VERSION,
 220         .d_flags =      D_NEEDGIANT,
 221         .d_open =       lptopen,
 222         .d_close =      lptclose,
 223         .d_write =      lptwrite,
 224         .d_ioctl =      lptioctl,
 225         .d_name =       "lpt",
 226 };
 227
 228 static bus_addr_t lpt_iat[] = {0, 2, 4, 6};
 229
 230 /*
 231  * New lpt port probe Geoff Rehmet - Rhodes University - 14/2/94
 232  * Based partially on Rod Grimes' printer probe
 233  *
 234  * Logic:
 235  *      1) If no port address was given, use the bios detected ports
 236  *         and autodetect what ports the printers are on.
 237  *      2) Otherwise, probe the data port at the address given,
 238  *         using the method in Rod Grimes' port probe.
 239  *         (Much code ripped off directly from Rod's probe.)
 240  *
 241  * Comments from Rod's probe:
 242  * Logic:
 243  *      1) You should be able to write to and read back the same value
 244  *         to the data port.  Do an alternating zeros, alternating ones,
 245  *         walking zero, and walking one test to check for stuck bits.
 246  *
 247  *      2) You should be able to write to and read back the same value
 248  *         to the control port lower 5 bits, the upper 3 bits are reserved
 249  *         per the IBM PC technical reference manauls and different boards
 250  *         do different things with them.  Do an alternating zeros, alternating
 251  *         ones, walking zero, and walking one test to check for stuck bits.
 252  *
 253  *         Some printers drag the strobe line down when the are powered off
 254  *         so this bit has been masked out of the control port test.
 255  *
 256  *         XXX Some printers may not like a fast pulse on init or strobe, I
 257  *         don't know at this point, if that becomes a problem these bits
 258  *         should be turned off in the mask byte for the control port test.
 259  *
 260  *         We are finally left with a mask of 0x14, due to some printers
 261  *         being adamant about holding other bits high ........
 262  *
 263  *         Before probing the control port, we write a 0 to the data port -
 264  *         If not, some printers chuck out garbage when the strobe line
 265  *         gets toggled.
 266  *
 267  *      3) Set the data and control ports to a value of 0
 268  *
 269  *      This probe routine has been tested on Epson Lx-800, HP LJ3P,
 270  *      Epson FX-1170 and C.Itoh 8510RM
 271  *      printers.
 272  *      Quick exit on fail added.
 273  */
 274
 275 int
 276 lpt_probe(device_t dev)
 277 {
 278 #define PC98_OLD_LPT 0x40
 279 #define PC98_IEEE_1284_FUNCTION 0x149
 280         int rid;
 281         struct resource *res;
 282
 283         /* Check isapnp ids */
 284         if (isa_get_vendorid(dev))
 285                 return ENXIO;
 286
 287         rid = 0;
 288         res = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid, lpt_iat, 4,
 289                                   RF_ACTIVE);
 290         if (res == NULL)
 291                 return ENXIO;
 292         isa_load_resourcev(res, lpt_iat, 4);
 293
 294         if (isa_get_port(dev) == PC98_OLD_LPT) {
 295                 unsigned int pc98_ieee_mode, tmp;
 296
 297                 tmp = inb(PC98_IEEE_1284_FUNCTION);
 298                 pc98_ieee_mode = tmp;
 299                 if ((tmp & 0x10) == 0x10) {
 300                         outb(PC98_IEEE_1284_FUNCTION, tmp & ~0x10);
 301                         tmp = inb(PC98_IEEE_1284_FUNCTION);
 302                         if ((tmp & 0x10) != 0x10) {
 303                                 outb(PC98_IEEE_1284_FUNCTION, pc98_ieee_mode);
 304                                 bus_release_resource(dev, SYS_RES_IOPORT, rid,
 305                                                      res);
 306                                 return ENXIO;
 307                         }
 308                 }
 309         }
 310
 311         bus_release_resource(dev, SYS_RES_IOPORT, rid, res);
 312         return 0;
 313 }
 314
 315 /* XXX Todo - try and detect if interrupt is working */
 316 int
 317 lpt_attach(device_t dev)
 318 {
 319         int     rid, unit;
 320         struct  lpt_softc       *sc;
 321
 322         unit = device_get_unit(dev);
 323         sc = device_get_softc(dev);
 324
 325         rid = 0;
 326         sc->res_port = isa_alloc_resourcev(dev, SYS_RES_IOPORT, &rid,
 327                                            lpt_iat, 4, RF_ACTIVE);
 328         if (sc->res_port == NULL)
 329                 return ENXIO;
 330         isa_load_resourcev(sc->res_port, lpt_iat, 4);
 331
 332         sc->sc_port = rman_get_start(sc->res_port);
 333         sc->sc_primed = 0;      /* not primed yet */
 334
 335         outb(sc->sc_port+lpt_pstb_ctrl, LPC_DIS_PSTB);  /* PSTB disable */
 336         outb(sc->sc_port+lpt_control,   LPC_MODE8255);  /* 8255 mode set */
 337         outb(sc->sc_port+lpt_control,   LPC_NIRQ8);     /* IRQ8 inactive */
 338         outb(sc->sc_port+lpt_control,   LPC_NPSTB);     /* PSTB inactive */
 339         outb(sc->sc_port+lpt_pstb_ctrl, LPC_EN_PSTB);   /* PSTB enable */
 340
 341         sc->sc_irq = 0;
 342         if (isa_get_irq(dev) != -1) {
 343                 rid = 0;
 344                 sc->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 345                                                      RF_ACTIVE);
 346                 if (sc->res_irq == NULL) {
 347                         bus_release_resource(dev, SYS_RES_IOPORT, 0,
 348                                              sc->res_port);
 349                         return ENXIO;
 350                 }
 351                 if (bus_setup_intr(dev, sc->res_irq, INTR_TYPE_TTY, NULL, lpt_intr,
 352                                    sc, &sc->sc_ih)) {
 353                         bus_release_resource(dev, SYS_RES_IOPORT, 0,
 354                                              sc->res_port);
 355                         bus_release_resource(dev, SYS_RES_IRQ, 0,
 356                                              sc->res_irq);
 357                         return ENXIO;
 358                 }
 359                 sc->sc_irq = LP_HAS_IRQ | LP_USE_IRQ | LP_ENABLE_IRQ;
 360                 device_printf(dev, "Interrupt-driven port");
 361         }
 362
 363         /* XXX what to do about the flags in the minor number? */
 364         make_dev(&lpt_cdevsw, unit, UID_ROOT, GID_WHEEL, 0600, "lpt%d", unit);
 365         make_dev(&lpt_cdevsw, unit | LP_BYPASS,
 366                         UID_ROOT, GID_WHEEL, 0600, "lpctl%d", unit);
 367
 368         return 0;
 369 }
 370
 371 /*
 372  * lptopen -- reset the printer, then wait until it's selected and not busy.
 373  *      If LP_BYPASS flag is selected, then we do not try to select the
 374  *      printer -- this is just used for passing ioctls.
 375  */
 376
 377 static  int
 378 lptopen (struct cdev *dev, int flags, int fmt, struct thread *td)
 379 {
 380         struct lpt_softc *sc;
 381         int s;
 382         int port;
 383
 384         sc = devclass_get_softc(olpt_devclass, LPTUNIT(minor(dev)));
 385         if (sc->sc_port == 0)
 386                 return (ENXIO);
 387
 388         if (sc->sc_state) {
 389                 lprintf(("lp: still open %x\n", sc->sc_state));
 390                 return(EBUSY);
 391         } else
 392                 sc->sc_state |= INIT;
 393
 394         sc->sc_flags = LPTFLAGS(minor(dev));
 395
 396         /* Check for open with BYPASS flag set. */
 397         if (sc->sc_flags & LP_BYPASS) {
 398                 sc->sc_state = OPEN;
 399                 return(0);
 400         }
 401
 402         s = spltty();
 403         lprintf(("lp flags 0x%x\n", sc->sc_flags));
 404         port = sc->sc_port;
 405
 406         /* set IRQ status according to ENABLE_IRQ flag */
 407         if (sc->sc_irq & LP_ENABLE_IRQ)
 408                 sc->sc_irq |= LP_USE_IRQ;
 409         else
 410                 sc->sc_irq &= ~LP_USE_IRQ;
 411
 412         /* init printer */
 413         sc->sc_state = OPEN;
 414         sc->sc_inbuf = malloc(BUFSIZE, M_DEVBUF, M_WAITOK);
 415         sc->sc_xfercnt = 0;
 416         splx(s);
 417
 418         /* only use timeout if using interrupt */
 419         lprintf(("irq %x\n", sc->sc_irq));
 420         if (sc->sc_irq & LP_USE_IRQ) {
 421                 sc->sc_state |= TOUT;
 422                 timeout (lptout, (caddr_t)sc,
 423                          (sc->sc_backoff = hz/LPTOUTINITIAL));
 424         }
 425
 426         lprintf(("opened.\n"));
 427         return(0);
 428 }
 429
 430 static void
 431 lptout (void *arg)
 432 {
 433         struct lpt_softc *sc = arg;
 434         int pl;
 435
 436         lprintf(("T %x ", inb(sc->sc_port+lpt_status)));
 437         if (sc->sc_state & OPEN) {
 438                 sc->sc_backoff++;
 439                 if (sc->sc_backoff > hz/LPTOUTMAX)
 440                         sc->sc_backoff = sc->sc_backoff > hz/LPTOUTMAX;
 441                 timeout (lptout, (caddr_t)sc, sc->sc_backoff);
 442         } else
 443                 sc->sc_state &= ~TOUT;
 444
 445         if (sc->sc_state & ERROR)
 446                 sc->sc_state &= ~ERROR;
 447
 448         /*
 449          * Avoid possible hangs do to missed interrupts
 450          */
 451         if (sc->sc_xfercnt) {
 452                 pl = spltty();
 453                 lpt_intr(sc);
 454                 splx(pl);
 455         } else {
 456                 sc->sc_state &= ~OBUSY;
 457                 wakeup(sc);
 458         }
 459 }
 460
 461 /*
 462  * lptclose -- close the device, free the local line buffer.
 463  *
 464  * Check for interrupted write call added.
 465  */
 466
 467 static  int
 468 lptclose(struct cdev *dev, int flags, int fmt, struct thread *td)
 469 {
 470         struct lpt_softc *sc;
 471
 472         sc = devclass_get_softc(olpt_devclass, LPTUNIT(minor(dev)));
 473         if(sc->sc_flags & LP_BYPASS)
 474                 goto end_close;
 475
 476         sc->sc_state &= ~OPEN;
 477         free(sc->sc_inbuf, M_DEVBUF);
 478
 479 end_close:
 480         sc->sc_state = 0;
 481         sc->sc_xfercnt = 0;
 482         lprintf(("closed.\n"));
 483         return(0);
 484 }
 485
 486 /*
 487  * pushbytes()
 488  *      Workhorse for actually spinning and writing bytes to printer
 489  *      Derived from lpa.c
 490  *      Originally by ?
 491  *
 492  *      This code is only used when we are polling the port
 493  */
 494 static int
 495 pushbytes(struct lpt_softc * sc)
 496 {
 497         int spin, err, tic;
 498         char ch;
 499         int port = sc->sc_port;
 500
 501         lprintf(("p"));
 502         /* loop for every character .. */
 503         while (sc->sc_xfercnt > 0) {
 504                 /* printer data */
 505                 ch = *(sc->sc_cp);
 506                 sc->sc_cp++;
 507                 sc->sc_xfercnt--;
 508
 509                 /*
 510                  * Wait for printer ready.
 511                  * Loop 20 usecs testing BUSY bit, then sleep
 512                  * for exponentially increasing timeout. (vak)
 513                  */
 514                 for (spin=0; NOT_READY(port+lpt_status) && spin<MAX_SPIN; ++spin)
 515                         DELAY(1);       /* XXX delay is NOT this accurate! */
 516                 if (spin >= MAX_SPIN) {
 517                         tic = 0;
 518                         while (NOT_READY(port+lpt_status)) {
 519                                 /*
 520                                  * Now sleep, every cycle a
 521                                  * little longer ..
 522                                  */
 523                                 tic = tic + tic + 1;
 524                                 /*
 525                                  * But no more than 10 seconds. (vak)
 526                                  */
 527                                 if (tic > MAX_SLEEP)
 528                                         tic = MAX_SLEEP;
 529                                 err = tsleep(sc, LPPRI,
 530                                         "lptpoll", tic);
 531                                 if (err != EWOULDBLOCK) {
 532                                         return (err);
 533                                 }
 534                         }
 535                 }
 536
 537                 /* output data */
 538                 outb(port+lpt_data, ch);
 539                 DELAY(1);
 540                 outb(port+lpt_control, LPC_PSTB);
 541                 DELAY(1);
 542                 outb(port+lpt_control, LPC_NPSTB);
 543         }
 544         return(0);
 545 }
 546
 547 /*
 548  * lptwrite --copy a line from user space to a local buffer, then call
 549  * putc to get the chars moved to the output queue.
 550  *
 551  * Flagging of interrupted write added.
 552  */
 553
 554 static  int
 555 lptwrite(struct cdev *dev, struct uio * uio, int ioflag)
 556 {
 557         register unsigned n;
 558         int pl, err;
 559         struct lpt_softc *sc;
 560
 561         sc = devclass_get_softc(olpt_devclass, LPTUNIT(minor(dev)));
 562         if(sc->sc_flags & LP_BYPASS) {
 563                 /* we can't do writes in bypass mode */
 564                 return(EPERM);
 565         }
 566
 567         sc->sc_state &= ~INTERRUPTED;
 568         while ((n = min(BUFSIZE, uio->uio_resid)) != 0) {
 569                 sc->sc_cp = sc->sc_inbuf;
 570                 uiomove(sc->sc_cp, n, uio);
 571                 sc->sc_xfercnt = n ;
 572                 while ((sc->sc_xfercnt > 0)&&(sc->sc_irq & LP_USE_IRQ)) {
 573                         lprintf(("i"));
 574                         /* if the printer is ready for a char, */
 575                         /* give it one */
 576                         if ((sc->sc_state & OBUSY) == 0){
 577                                 lprintf(("\nC %d. ", sc->sc_xfercnt));
 578                                 pl = spltty();
 579                                 lpt_intr(sc);
 580                                 (void) splx(pl);
 581                         }
 582                         lprintf(("W "));
 583                         if (sc->sc_state & OBUSY)
 584                                 if ((err = tsleep (sc,
 585                                          LPPRI|PCATCH, "lpwrite", 0))) {
 586                                         sc->sc_state |= INTERRUPTED;
 587                                         return(err);
 588                                 }
 589                 }
 590                 /* check to see if we must do a polled write */
 591                 if(!(sc->sc_irq & LP_USE_IRQ) && (sc->sc_xfercnt)) {
 592                         lprintf(("p"));
 593                         if((err = pushbytes(sc)))
 594                                 return(err);
 595                 }
 596         }
 597         return(0);
 598 }
 599
 600 /*
 601  * lptintr -- handle printer interrupts which occur when the printer is
 602  * ready to accept another char.
 603  *
 604  * do checking for interrupted write call.
 605  */
 606
 607 static void
 608 lpt_intr(void *arg)
 609 {
 610 }
 611
 612 static  int
 613 lptioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td)
 614 {
 615         int     error = 0;
 616         struct  lpt_softc *sc;
 617         u_int   unit = LPTUNIT(minor(dev));
 618         u_char  old_sc_irq;     /* old printer IRQ status */
 619
 620         sc = devclass_get_softc(olpt_devclass, unit);
 621
 622         switch (cmd) {
 623         case LPT_IRQ :
 624                 if(sc->sc_irq & LP_HAS_IRQ) {
 625                         /*
 626                          * NOTE:
 627                          * If the IRQ status is changed,
 628                          * this will only be visible on the
 629                          * next open.
 630                          *
 631                          * If interrupt status changes,
 632                          * this gets syslog'd.
 633                          */
 634                         old_sc_irq = sc->sc_irq;
 635                         if(*(int*)data == 0)
 636                                 sc->sc_irq &= (~LP_ENABLE_IRQ);
 637                         else
 638                                 sc->sc_irq |= LP_ENABLE_IRQ;
 639                         if (old_sc_irq != sc->sc_irq )
 640                                 log(LOG_NOTICE, "lpt%c switched to %s mode\n",
 641                                         (char)unit+'0',
 642                                         (sc->sc_irq & LP_ENABLE_IRQ)?
 643                                         "interrupt-driven":"polled");
 644                 } else /* polled port */
 645                         error = EOPNOTSUPP;
 646                 break;
 647         default:
 648                 error = ENODEV;
 649         }
 650
 651         return(error);
 652 }