The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ppbus/lpt.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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  *      From Id: lpt.c,v 1.55.2.1 1996/11/12 09:08:38 phk Exp
   50  *      From Id: nlpt.c,v 1.14 1999/02/08 13:55:43 des Exp
   51  */
   52 
   53 #include <sys/cdefs.h>
   54 __FBSDID("$FreeBSD$");
   55 
   56 /*
   57  * Device Driver for AT parallel printer port
   58  * Written by William Jolitz 12/18/90
   59  */
   60 
   61 /*
   62  * Updated for ppbus by Nicolas Souchu
   63  * [Mon Jul 28 1997]
   64  */
   65 
   66 #include "opt_lpt.h"
   67 
   68 #include <sys/param.h>
   69 #include <sys/systm.h>
   70 #include <sys/module.h>
   71 #include <sys/bus.h>
   72 #include <sys/conf.h>
   73 #include <sys/kernel.h>
   74 #include <sys/uio.h>
   75 #include <sys/syslog.h>
   76 #include <sys/malloc.h>
   77 
   78 #include <machine/bus.h>
   79 #include <machine/resource.h>
   80 #include <sys/rman.h>
   81 
   82 #include <dev/ppbus/lptio.h>
   83 #include <dev/ppbus/ppbconf.h>
   84 #include <dev/ppbus/ppb_1284.h>
   85 #include <dev/ppbus/lpt.h>
   86 #include "ppbus_if.h"
   87 #include <dev/ppbus/ppbio.h>
   88 
   89 #ifndef LPT_DEBUG
   90 #define lprintf(args)
   91 #else
   92 #define lprintf(args)                                           \
   93                 do {                                            \
   94                         if (lptflag)                            \
   95                                 printf args;                    \
   96                 } while (0)
   97 static int volatile lptflag = 1;
   98 #endif
   99 
  100 #define LPINITRDY       4       /* wait up to 4 seconds for a ready */
  101 #define LPTOUTINITIAL   10      /* initial timeout to wait for ready 1/10 s */
  102 #define LPTOUTMAX       1       /* maximal timeout 1 s */
  103 #define LPPRI           (PZERO+8)
  104 #define BUFSIZE         1024
  105 #define BUFSTATSIZE     32
  106 
  107 #define LPTUNIT(s)      ((s)&0x03)
  108 #define LPTFLAGS(s)     ((s)&0xfc)
  109 
  110 struct lpt_data {
  111 
  112         short   sc_state;
  113         /* default case: negative prime, negative ack, handshake strobe,
  114            prime once */
  115         u_char  sc_control;
  116         char    sc_flags;
  117 #define LP_POS_INIT     0x04    /* if we are a postive init signal */
  118 #define LP_POS_ACK      0x08    /* if we are a positive going ack */
  119 #define LP_NO_PRIME     0x10    /* don't prime the printer at all */
  120 #define LP_PRIMEOPEN    0x20    /* prime on every open */
  121 #define LP_AUTOLF       0x40    /* tell printer to do an automatic lf */
  122 #define LP_BYPASS       0x80    /* bypass  printer ready checks */
  123         void    *sc_inbuf;
  124         void    *sc_statbuf;
  125         short   sc_xfercnt ;
  126         char    sc_primed;
  127         char    *sc_cp ;
  128         u_short sc_irq ;        /* IRQ status of port */
  129 #define LP_HAS_IRQ      0x01    /* we have an irq available */
  130 #define LP_USE_IRQ      0x02    /* we are using our irq */
  131 #define LP_ENABLE_IRQ   0x04    /* enable IRQ on open */
  132 #define LP_ENABLE_EXT   0x10    /* we shall use advanced mode when possible */
  133         u_char  sc_backoff ;    /* time to call lptout() again */
  134 
  135         struct resource *intr_resource; /* interrupt resource */
  136         void *intr_cookie;              /* interrupt registration cookie */
  137 
  138 };
  139 
  140 #define LPT_NAME        "lpt"           /* our official name */
  141 
  142 static timeout_t lptout;
  143 static int      lpt_port_test(device_t dev, u_char data, u_char mask);
  144 static int      lpt_detect(device_t dev);
  145 
  146 #define DEVTOSOFTC(dev) \
  147         ((struct lpt_data *)device_get_softc(dev))
  148 #define UNITOSOFTC(unit) \
  149         ((struct lpt_data *)devclass_get_softc(lpt_devclass, (unit)))
  150 #define UNITODEVICE(unit) \
  151         (devclass_get_device(lpt_devclass, (unit)))
  152 
  153 static void lptintr(device_t dev);
  154 static void lpt_intr(void *arg);        /* without spls */
  155 
  156 static devclass_t lpt_devclass;
  157 
  158 
  159 /* bits for state */
  160 #define OPEN            (1<<0)  /* device is open */
  161 #define ASLP            (1<<1)  /* awaiting draining of printer */
  162 #define EERROR          (1<<2)  /* error was received from printer */
  163 #define OBUSY           (1<<3)  /* printer is busy doing output */
  164 #define LPTOUT          (1<<4)  /* timeout while not selected */
  165 #define TOUT            (1<<5)  /* timeout while not selected */
  166 #define LPTINIT         (1<<6)  /* waiting to initialize for open */
  167 #define INTERRUPTED     (1<<7)  /* write call was interrupted */
  168 
  169 #define HAVEBUS         (1<<8)  /* the driver owns the bus */
  170 
  171 
  172 /* status masks to interrogate printer status */
  173 #define RDY_MASK        (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)     /* ready ? */
  174 #define LP_READY        (LPS_SEL|LPS_NBSY|LPS_NERR)
  175 
  176 /* Printer Ready condition  - from lpa.c */
  177 /* Only used in polling code */
  178 #define LPS_INVERT      (LPS_NBSY | LPS_NACK |           LPS_SEL | LPS_NERR)
  179 #define LPS_MASK        (LPS_NBSY | LPS_NACK | LPS_OUT | LPS_SEL | LPS_NERR)
  180 #define NOT_READY(ppbus) ((ppb_rstr(ppbus)^LPS_INVERT)&LPS_MASK)
  181 
  182 #define MAX_SLEEP       (hz*5)  /* Timeout while waiting for device ready */
  183 #define MAX_SPIN        20      /* Max delay for device ready in usecs */
  184 
  185 
  186 static  d_open_t        lptopen;
  187 static  d_close_t       lptclose;
  188 static  d_write_t       lptwrite;
  189 static  d_read_t        lptread;
  190 static  d_ioctl_t       lptioctl;
  191 
  192 static struct cdevsw lpt_cdevsw = {
  193         .d_version =    D_VERSION,
  194         .d_flags =      D_NEEDGIANT,
  195         .d_open =       lptopen,
  196         .d_close =      lptclose,
  197         .d_read =       lptread,
  198         .d_write =      lptwrite,
  199         .d_ioctl =      lptioctl,
  200         .d_name =       LPT_NAME,
  201 };
  202 
  203 static int
  204 lpt_request_ppbus(device_t dev, int how)
  205 {
  206         device_t ppbus = device_get_parent(dev);
  207         struct lpt_data *sc = DEVTOSOFTC(dev);
  208         int error;
  209 
  210         if (sc->sc_state & HAVEBUS)
  211                 return (0);
  212 
  213         /* we have the bus only if the request succeded */
  214         if ((error = ppb_request_bus(ppbus, dev, how)) == 0)
  215                 sc->sc_state |= HAVEBUS;
  216 
  217         return (error);
  218 }
  219 
  220 static int
  221 lpt_release_ppbus(device_t dev)
  222 {
  223         device_t ppbus = device_get_parent(dev);
  224         struct lpt_data *sc = DEVTOSOFTC(dev);
  225         int error = 0;
  226 
  227         if ((error = ppb_release_bus(ppbus, dev)) == 0)
  228                 sc->sc_state &= ~HAVEBUS;
  229 
  230         return (error);
  231 }
  232 
  233 /*
  234  * Internal routine to lptprobe to do port tests of one byte value
  235  */
  236 static int
  237 lpt_port_test(device_t ppbus, u_char data, u_char mask)
  238 {
  239         int     temp, timeout;
  240 
  241         data = data & mask;
  242         ppb_wdtr(ppbus, data);
  243         timeout = 10000;
  244         do {
  245                 DELAY(10);
  246                 temp = ppb_rdtr(ppbus) & mask;
  247         }
  248         while (temp != data && --timeout);
  249         lprintf(("out=%x\tin=%x\ttout=%d\n", data, temp, timeout));
  250         return (temp == data);
  251 }
  252 
  253 /*
  254  * Probe simplified by replacing multiple loops with a hardcoded
  255  * test pattern - 1999/02/08 des@freebsd.org
  256  *
  257  * New lpt port probe Geoff Rehmet - Rhodes University - 14/2/94
  258  * Based partially on Rod Grimes' printer probe
  259  *
  260  * Logic:
  261  *      1) If no port address was given, use the bios detected ports
  262  *         and autodetect what ports the printers are on.
  263  *      2) Otherwise, probe the data port at the address given,
  264  *         using the method in Rod Grimes' port probe.
  265  *         (Much code ripped off directly from Rod's probe.)
  266  *
  267  * Comments from Rod's probe:
  268  * Logic:
  269  *      1) You should be able to write to and read back the same value
  270  *         to the data port.  Do an alternating zeros, alternating ones,
  271  *         walking zero, and walking one test to check for stuck bits.
  272  *
  273  *      2) You should be able to write to and read back the same value
  274  *         to the control port lower 5 bits, the upper 3 bits are reserved
  275  *         per the IBM PC technical reference manauls and different boards
  276  *         do different things with them.  Do an alternating zeros, alternating
  277  *         ones, walking zero, and walking one test to check for stuck bits.
  278  *
  279  *         Some printers drag the strobe line down when the are powered off
  280  *         so this bit has been masked out of the control port test.
  281  *
  282  *         XXX Some printers may not like a fast pulse on init or strobe, I
  283  *         don't know at this point, if that becomes a problem these bits
  284  *         should be turned off in the mask byte for the control port test.
  285  *
  286  *         We are finally left with a mask of 0x14, due to some printers
  287  *         being adamant about holding other bits high ........
  288  *
  289  *         Before probing the control port, we write a 0 to the data port -
  290  *         If not, some printers chuck out garbage when the strobe line
  291  *         gets toggled.
  292  *
  293  *      3) Set the data and control ports to a value of 0
  294  *
  295  *      This probe routine has been tested on Epson Lx-800, HP LJ3P,
  296  *      Epson FX-1170 and C.Itoh 8510RM
  297  *      printers.
  298  *      Quick exit on fail added.
  299  */
  300 static int
  301 lpt_detect(device_t dev)
  302 {
  303         device_t ppbus = device_get_parent(dev);
  304 
  305         static u_char   testbyte[18] = {
  306                 0x55,                   /* alternating zeros */
  307                 0xaa,                   /* alternating ones */
  308                 0xfe, 0xfd, 0xfb, 0xf7,
  309                 0xef, 0xdf, 0xbf, 0x7f, /* walking zero */
  310                 0x01, 0x02, 0x04, 0x08,
  311                 0x10, 0x20, 0x40, 0x80  /* walking one */
  312         };
  313         int             i, error, status;
  314 
  315         status = 1;                             /* assume success */
  316 
  317         if ((error = lpt_request_ppbus(dev, PPB_DONTWAIT))) {
  318                 printf(LPT_NAME ": cannot alloc ppbus (%d)!\n", error);
  319                 status = 0;
  320                 goto end_probe;
  321         }
  322 
  323         for (i = 0; i < 18 && status; i++)
  324                 if (!lpt_port_test(ppbus, testbyte[i], 0xff)) {
  325                         status = 0;
  326                         goto end_probe;
  327                 }
  328 
  329 end_probe:
  330         /* write 0's to control and data ports */
  331         ppb_wdtr(ppbus, 0);
  332         ppb_wctr(ppbus, 0);
  333 
  334         lpt_release_ppbus(dev);
  335 
  336         return (status);
  337 }
  338 
  339 static void
  340 lpt_identify(driver_t *driver, device_t parent)
  341 {
  342 
  343         device_t dev;
  344 
  345         dev = device_find_child(parent, LPT_NAME, -1);
  346         if (!dev)
  347                 BUS_ADD_CHILD(parent, 0, LPT_NAME, -1);
  348 }
  349 
  350 /*
  351  * lpt_probe()
  352  */
  353 static int
  354 lpt_probe(device_t dev)
  355 {
  356 
  357         if (!lpt_detect(dev))
  358                 return (ENXIO);
  359 
  360         device_set_desc(dev, "Printer");
  361 
  362         return (0);
  363 }
  364 
  365 static int
  366 lpt_attach(device_t dev)
  367 {
  368         device_t ppbus = device_get_parent(dev);
  369         struct lpt_data *sc = DEVTOSOFTC(dev);
  370         int zero = 0, unit = device_get_unit(dev);
  371         int error;
  372         intptr_t irq;
  373 
  374         sc->sc_primed = 0;      /* not primed yet */
  375 
  376         if ((error = lpt_request_ppbus(dev, PPB_DONTWAIT))) {
  377                 printf(LPT_NAME ": cannot alloc ppbus (%d)!\n", error);
  378                 return (0);
  379         }
  380 
  381         ppb_wctr(ppbus, LPC_NINIT);
  382 
  383         /* check if we can use interrupt, should be done by ppc stuff */
  384         lprintf(("oldirq %x\n", sc->sc_irq));
  385 
  386         /* retrieve the ppbus irq */
  387         BUS_READ_IVAR(ppbus, dev, PPBUS_IVAR_IRQ, &irq);
  388 
  389         if (irq > 0) {
  390                 /* declare our interrupt handler */
  391                 sc->intr_resource = bus_alloc_resource(dev, SYS_RES_IRQ,
  392                                                        &zero, irq, irq, 1, RF_SHAREABLE);
  393         }
  394         if (sc->intr_resource) {
  395                 sc->sc_irq = LP_HAS_IRQ | LP_USE_IRQ | LP_ENABLE_IRQ;
  396                 device_printf(dev, "Interrupt-driven port\n");
  397         } else {
  398                 sc->sc_irq = 0;
  399                 device_printf(dev, "Polled port\n");
  400         }
  401         lprintf(("irq %x %x\n", (int)irq, sc->sc_irq));
  402 
  403         lpt_release_ppbus(dev);
  404 
  405         make_dev(&lpt_cdevsw, unit,
  406             UID_ROOT, GID_WHEEL, 0600, LPT_NAME "%d", unit);
  407         make_dev(&lpt_cdevsw, unit | LP_BYPASS,
  408             UID_ROOT, GID_WHEEL, 0600, LPT_NAME "%d.ctl", unit);
  409         return (0);
  410 }
  411 
  412 static int
  413 lpt_detach(device_t dev)
  414 {
  415         struct lpt_data *sc = DEVTOSOFTC(dev);
  416 
  417         lpt_release_ppbus(dev);
  418         if (sc->intr_resource != 0) {
  419                 BUS_TEARDOWN_INTR(device_get_parent(dev), dev,
  420                     sc->intr_resource, sc->intr_cookie);
  421                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->intr_resource);
  422         }
  423 
  424         return (0);
  425 }
  426 
  427 static void
  428 lptout(void *arg)
  429 {
  430         device_t dev = (device_t)arg;
  431         struct lpt_data *sc = DEVTOSOFTC(dev);
  432 #ifdef LPT_DEBUG
  433         device_t ppbus = device_get_parent(dev);
  434 #endif
  435 
  436         lprintf(("T %x ", ppb_rstr(ppbus)));
  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)dev, sc->sc_backoff);
  442         } else
  443                 sc->sc_state &= ~TOUT;
  444 
  445         if (sc->sc_state & EERROR)
  446                 sc->sc_state &= ~EERROR;
  447 
  448         /*
  449          * Avoid possible hangs due to missed interrupts
  450          */
  451         if (sc->sc_xfercnt) {
  452                 lptintr(dev);
  453         } else {
  454                 sc->sc_state &= ~OBUSY;
  455                 wakeup(dev);
  456         }
  457 }
  458 
  459 /*
  460  * lptopen -- reset the printer, then wait until it's selected and not busy.
  461  *      If LP_BYPASS flag is selected, then we do not try to select the
  462  *      printer -- this is just used for passing ioctls.
  463  */
  464 
  465 static  int
  466 lptopen(struct cdev *dev, int flags, int fmt, struct thread *td)
  467 {
  468         int s;
  469         int trys, err;
  470         u_int unit = LPTUNIT(minor(dev));
  471         struct lpt_data *sc = UNITOSOFTC(unit);
  472         device_t lptdev = UNITODEVICE(unit);
  473         device_t ppbus = device_get_parent(lptdev);
  474 
  475         if (!sc)
  476                 return (ENXIO);
  477 
  478         if (sc->sc_state) {
  479                 lprintf((LPT_NAME ": still open %x\n", sc->sc_state));
  480                 return(EBUSY);
  481         } else
  482                 sc->sc_state |= LPTINIT;
  483 
  484         sc->sc_flags = LPTFLAGS(minor(dev));
  485 
  486         /* Check for open with BYPASS flag set. */
  487         if (sc->sc_flags & LP_BYPASS) {
  488                 sc->sc_state = OPEN;
  489                 return(0);
  490         }
  491 
  492         /* request the ppbus only if we don't have it already */
  493         if ((err = lpt_request_ppbus(lptdev, PPB_WAIT|PPB_INTR)) != 0) {
  494                 /* give it a chance to try later */
  495                 sc->sc_state = 0;
  496                 return (err);
  497         }
  498 
  499         s = spltty();
  500         lprintf((LPT_NAME " flags 0x%x\n", sc->sc_flags));
  501 
  502         /* set IRQ status according to ENABLE_IRQ flag
  503          */
  504         if (sc->sc_irq & LP_ENABLE_IRQ)
  505                 sc->sc_irq |= LP_USE_IRQ;
  506         else
  507                 sc->sc_irq &= ~LP_USE_IRQ;
  508 
  509         /* init printer */
  510         if ((sc->sc_flags & LP_NO_PRIME) == 0) {
  511                 if((sc->sc_flags & LP_PRIMEOPEN) || sc->sc_primed == 0) {
  512                         ppb_wctr(ppbus, 0);
  513                         sc->sc_primed++;
  514                         DELAY(500);
  515                 }
  516         }
  517 
  518         ppb_wctr(ppbus, LPC_SEL|LPC_NINIT);
  519 
  520         /* wait till ready (printer running diagnostics) */
  521         trys = 0;
  522         do {
  523                 /* ran out of waiting for the printer */
  524                 if (trys++ >= LPINITRDY*4) {
  525                         splx(s);
  526                         sc->sc_state = 0;
  527                         lprintf(("status %x\n", ppb_rstr(ppbus)));
  528 
  529                         lpt_release_ppbus(lptdev);
  530                         return (EBUSY);
  531                 }
  532 
  533                 /* wait 1/4 second, give up if we get a signal */
  534                 if (tsleep(lptdev, LPPRI|PCATCH, "lptinit", hz/4) !=
  535                     EWOULDBLOCK) {
  536                         sc->sc_state = 0;
  537                         splx(s);
  538 
  539                         lpt_release_ppbus(lptdev);
  540                         return (EBUSY);
  541                 }
  542 
  543                 /* is printer online and ready for output */
  544         } while ((ppb_rstr(ppbus) &
  545                         (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)) !=
  546                                         (LPS_SEL|LPS_NBSY|LPS_NERR));
  547 
  548         sc->sc_control = LPC_SEL|LPC_NINIT;
  549         if (sc->sc_flags & LP_AUTOLF)
  550                 sc->sc_control |= LPC_AUTOL;
  551 
  552         /* enable interrupt if interrupt-driven */
  553         if (sc->sc_irq & LP_USE_IRQ)
  554                 sc->sc_control |= LPC_ENA;
  555 
  556         ppb_wctr(ppbus, sc->sc_control);
  557 
  558         sc->sc_state = OPEN;
  559         sc->sc_inbuf = malloc(BUFSIZE, M_DEVBUF, M_WAITOK);
  560         sc->sc_statbuf = malloc(BUFSTATSIZE, M_DEVBUF, M_WAITOK);
  561         sc->sc_xfercnt = 0;
  562         splx(s);
  563 
  564         /* release the ppbus */
  565         lpt_release_ppbus(lptdev);
  566 
  567         /* only use timeout if using interrupt */
  568         lprintf(("irq %x\n", sc->sc_irq));
  569         if (sc->sc_irq & LP_USE_IRQ) {
  570                 sc->sc_state |= TOUT;
  571                 timeout(lptout, (caddr_t)lptdev,
  572                          (sc->sc_backoff = hz/LPTOUTINITIAL));
  573         }
  574 
  575         lprintf(("opened.\n"));
  576         return(0);
  577 }
  578 
  579 /*
  580  * lptclose -- close the device, free the local line buffer.
  581  *
  582  * Check for interrupted write call added.
  583  */
  584 
  585 static  int
  586 lptclose(struct cdev *dev, int flags, int fmt, struct thread *td)
  587 {
  588         u_int unit = LPTUNIT(minor(dev));
  589         struct lpt_data *sc = UNITOSOFTC(unit);
  590         device_t lptdev = UNITODEVICE(unit);
  591         device_t ppbus = device_get_parent(lptdev);
  592         int err;
  593 
  594         if(sc->sc_flags & LP_BYPASS)
  595                 goto end_close;
  596 
  597         if ((err = lpt_request_ppbus(lptdev, PPB_WAIT|PPB_INTR)) != 0)
  598                 return (err);
  599 
  600         sc->sc_state &= ~OPEN;
  601 
  602         /* if the last write was interrupted, don't complete it */
  603         if((!(sc->sc_state  & INTERRUPTED)) && (sc->sc_irq & LP_USE_IRQ))
  604                 while ((ppb_rstr(ppbus) &
  605                         (LPS_SEL|LPS_OUT|LPS_NBSY|LPS_NERR)) !=
  606                         (LPS_SEL|LPS_NBSY|LPS_NERR) || sc->sc_xfercnt)
  607                         /* wait 1/4 second, give up if we get a signal */
  608                         if (tsleep(lptdev, LPPRI|PCATCH,
  609                                 "lpclose", hz) != EWOULDBLOCK)
  610                                 break;
  611 
  612         ppb_wctr(ppbus, LPC_NINIT);
  613         free(sc->sc_inbuf, M_DEVBUF);
  614         free(sc->sc_statbuf, M_DEVBUF);
  615 
  616 end_close:
  617         /* release the bus anyway
  618          * unregistration of interrupt forced by release
  619          */
  620         lpt_release_ppbus(lptdev);
  621 
  622         sc->sc_state = 0;
  623         sc->sc_xfercnt = 0;
  624         lprintf(("closed.\n"));
  625         return(0);
  626 }
  627 
  628 /*
  629  * lpt_pushbytes()
  630  *      Workhorse for actually spinning and writing bytes to printer
  631  *      Derived from lpa.c
  632  *      Originally by ?
  633  *
  634  *      This code is only used when we are polling the port
  635  */
  636 static int
  637 lpt_pushbytes(device_t dev)
  638 {
  639         struct lpt_data *sc = DEVTOSOFTC(dev);
  640         device_t ppbus = device_get_parent(dev);
  641         int spin, err, tic;
  642         char ch;
  643 
  644         lprintf(("p"));
  645         /* loop for every character .. */
  646         while (sc->sc_xfercnt > 0) {
  647                 /* printer data */
  648                 ch = *(sc->sc_cp);
  649                 sc->sc_cp++;
  650                 sc->sc_xfercnt--;
  651 
  652                 /*
  653                  * Wait for printer ready.
  654                  * Loop 20 usecs testing BUSY bit, then sleep
  655                  * for exponentially increasing timeout. (vak)
  656                  */
  657                 for (spin = 0; NOT_READY(ppbus) && spin < MAX_SPIN; ++spin)
  658                         DELAY(1);       /* XXX delay is NOT this accurate! */
  659                 if (spin >= MAX_SPIN) {
  660                         tic = 0;
  661                         while (NOT_READY(ppbus)) {
  662                                 /*
  663                                  * Now sleep, every cycle a
  664                                  * little longer ..
  665                                  */
  666                                 tic = tic + tic + 1;
  667                                 /*
  668                                  * But no more than 10 seconds. (vak)
  669                                  */
  670                                 if (tic > MAX_SLEEP)
  671                                         tic = MAX_SLEEP;
  672                                 err = tsleep(dev, LPPRI,
  673                                         LPT_NAME "poll", tic);
  674                                 if (err != EWOULDBLOCK) {
  675                                         return (err);
  676                                 }
  677                         }
  678                 }
  679 
  680                 /* output data */
  681                 ppb_wdtr(ppbus, ch);
  682                 /* strobe */
  683                 ppb_wctr(ppbus, sc->sc_control|LPC_STB);
  684                 ppb_wctr(ppbus, sc->sc_control);
  685 
  686         }
  687         return(0);
  688 }
  689 
  690 /*
  691  * lptread --retrieve printer status in IEEE1284 NIBBLE mode
  692  */
  693 
  694 static int
  695 lptread(struct cdev *dev, struct uio *uio, int ioflag)
  696 {
  697         u_int   unit = LPTUNIT(minor(dev));
  698         struct lpt_data *sc = UNITOSOFTC(unit);
  699         device_t lptdev = UNITODEVICE(unit);
  700         device_t ppbus = device_get_parent(lptdev);
  701         int error = 0, len;
  702 
  703         if (sc->sc_flags & LP_BYPASS) {
  704                 /* we can't do reads in bypass mode */
  705                 return (EPERM);
  706         }
  707 
  708         if ((error = ppb_1284_negociate(ppbus, PPB_NIBBLE, 0)))
  709                 return (error);
  710 
  711         /* read data in an other buffer, read/write may be simultaneous */
  712         len = 0;
  713         while (uio->uio_resid) {
  714                 if ((error = ppb_1284_read(ppbus, PPB_NIBBLE,
  715                                 sc->sc_statbuf, min(BUFSTATSIZE,
  716                                 uio->uio_resid), &len))) {
  717                         goto error;
  718                 }
  719 
  720                 if (!len)
  721                         goto error;             /* no more data */
  722 
  723                 if ((error = uiomove(sc->sc_statbuf, len, uio)))
  724                         goto error;
  725         }
  726 
  727 error:
  728         ppb_1284_terminate(ppbus);
  729         return (error);
  730 }
  731 
  732 /*
  733  * lptwrite --copy a line from user space to a local buffer, then call
  734  * putc to get the chars moved to the output queue.
  735  *
  736  * Flagging of interrupted write added.
  737  */
  738 
  739 static  int
  740 lptwrite(struct cdev *dev, struct uio *uio, int ioflag)
  741 {
  742         register unsigned n;
  743         int err;
  744         u_int   unit = LPTUNIT(minor(dev));
  745         struct lpt_data *sc = UNITOSOFTC(unit);
  746         device_t lptdev = UNITODEVICE(unit);
  747         device_t ppbus = device_get_parent(lptdev);
  748 
  749         if(sc->sc_flags & LP_BYPASS) {
  750                 /* we can't do writes in bypass mode */
  751                 return(EPERM);
  752         }
  753 
  754         /* request the ppbus only if we don't have it already */
  755         /* XXX interrupt registration?! */
  756         if ((err = lpt_request_ppbus(lptdev, PPB_WAIT|PPB_INTR)) != 0)
  757                 return (err);
  758 
  759         /* if interrupts are working, register the handler */
  760         if (sc->sc_irq & LP_USE_IRQ) {
  761                 /* register our interrupt handler */
  762                 err = bus_setup_intr(lptdev, sc->intr_resource,
  763                                INTR_TYPE_TTY, NULL, lpt_intr, lptdev,
  764                                &sc->intr_cookie);
  765                 if (err) {
  766                         device_printf(lptdev, "handler registration failed, polled mode.\n");
  767                         sc->sc_irq &= ~LP_USE_IRQ;
  768                 }
  769         }
  770 
  771         sc->sc_state &= ~INTERRUPTED;
  772         while ((n = min(BUFSIZE, uio->uio_resid)) != 0) {
  773                 sc->sc_cp = sc->sc_inbuf;
  774                 uiomove(sc->sc_cp, n, uio);
  775                 sc->sc_xfercnt = n ;
  776 
  777                 if (sc->sc_irq & LP_ENABLE_EXT) {
  778                         /* try any extended mode */
  779                         err = ppb_write(ppbus, sc->sc_cp,
  780                                         sc->sc_xfercnt, 0);
  781                         switch (err) {
  782                         case 0:
  783                                 /* if not all data was sent, we could rely
  784                                  * on polling for the last bytes */
  785                                 sc->sc_xfercnt = 0;
  786                                 break;
  787                         case EINTR:
  788                                 sc->sc_state |= INTERRUPTED;    
  789                                 return(err);
  790                         case EINVAL:
  791                                 /* advanced mode not avail */
  792                                 log(LOG_NOTICE, LPT_NAME "%d: advanced mode not avail, polling\n", unit);
  793                                 break;
  794                         default:
  795                                 return(err);
  796                         }
  797                 } else while ((sc->sc_xfercnt > 0)&&(sc->sc_irq & LP_USE_IRQ)) {
  798                         lprintf(("i"));
  799                         /* if the printer is ready for a char, */
  800                         /* give it one */
  801                         if ((sc->sc_state & OBUSY) == 0){
  802                                 lprintf(("\nC %d. ", sc->sc_xfercnt));
  803                                 lptintr(lptdev);
  804                         }
  805                         lprintf(("W "));
  806                         if (sc->sc_state & OBUSY)
  807                                 if ((err = tsleep(lptdev,
  808                                          LPPRI|PCATCH, LPT_NAME "write", 0))) {
  809                                         sc->sc_state |= INTERRUPTED;
  810                                         return(err);
  811                                 }
  812                 }
  813 
  814                 /* check to see if we must do a polled write */
  815                 if(!(sc->sc_irq & LP_USE_IRQ) && (sc->sc_xfercnt)) {
  816                         lprintf(("p"));
  817 
  818                         err = lpt_pushbytes(lptdev);
  819 
  820                         if (err)
  821                                 return(err);
  822                 }
  823         }
  824 
  825         /* we have not been interrupted, release the ppbus */
  826         lpt_release_ppbus(lptdev);
  827 
  828         return(0);
  829 }
  830 
  831 /*
  832  * lpt_intr -- handle printer interrupts which occur when the printer is
  833  * ready to accept another char.
  834  *
  835  * do checking for interrupted write call.
  836  */
  837 
  838 static void
  839 lpt_intr(void *arg)
  840 {
  841         device_t lptdev = (device_t)arg;
  842         device_t ppbus = device_get_parent(lptdev);
  843         struct lpt_data *sc = DEVTOSOFTC(lptdev);
  844         int sts = 0;
  845         int i;
  846         
  847         /* we must own the bus to use it */
  848         if ((sc->sc_state & HAVEBUS) == 0)
  849                 return;
  850 
  851         /*
  852          * Is printer online and ready for output?
  853          *
  854          * Avoid falling back to lptout() too quickly.  First spin-loop
  855          * to see if the printer will become ready ``really soon now''.
  856          */
  857         for (i = 0; i < 100 &&
  858              ((sts=ppb_rstr(ppbus)) & RDY_MASK) != LP_READY; i++) ;
  859 
  860         if ((sts & RDY_MASK) == LP_READY) {
  861                 sc->sc_state = (sc->sc_state | OBUSY) & ~EERROR;
  862                 sc->sc_backoff = hz/LPTOUTINITIAL;
  863 
  864                 if (sc->sc_xfercnt) {
  865                         /* send char */
  866                         /*lprintf(("%x ", *sc->sc_cp)); */
  867                         ppb_wdtr(ppbus, *sc->sc_cp++) ;
  868                         ppb_wctr(ppbus, sc->sc_control|LPC_STB);
  869                         /* DELAY(X) */
  870                         ppb_wctr(ppbus, sc->sc_control);
  871 
  872                         /* any more data for printer */
  873                         if(--(sc->sc_xfercnt) > 0) return;
  874                 }
  875 
  876                 /*
  877                  * No more data waiting for printer.
  878                  * Wakeup is not done if write call was not interrupted.
  879                  */
  880                 sc->sc_state &= ~OBUSY;
  881 
  882                 if(!(sc->sc_state & INTERRUPTED))
  883                         wakeup(lptdev);
  884                 lprintf(("w "));
  885                 return;
  886         } else  {       /* check for error */
  887                 if(((sts & (LPS_NERR | LPS_OUT) ) != LPS_NERR) &&
  888                                 (sc->sc_state & OPEN))
  889                         sc->sc_state |= EERROR;
  890                 /* lptout() will jump in and try to restart. */
  891         }
  892         lprintf(("sts %x ", sts));
  893 }
  894 
  895 static void
  896 lptintr(device_t dev)
  897 {
  898         /* call the interrupt at required spl level */
  899         int s = spltty();
  900 
  901         lpt_intr(dev);
  902 
  903         splx(s);
  904         return;
  905 }
  906 
  907 static  int
  908 lptioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td)
  909 {
  910         int     error = 0;
  911         u_int   unit = LPTUNIT(minor(dev));
  912         struct  lpt_data *sc = UNITOSOFTC(unit);
  913         u_char  old_sc_irq;     /* old printer IRQ status */
  914 
  915         switch (cmd) {
  916         case LPT_IRQ :
  917                 if(sc->sc_irq & LP_HAS_IRQ) {
  918                         /*
  919                          * NOTE:
  920                          * If the IRQ status is changed,
  921                          * this will only be visible on the
  922                          * next open.
  923                          *
  924                          * If interrupt status changes,
  925                          * this gets syslog'd.
  926                          */
  927                         old_sc_irq = sc->sc_irq;
  928                         switch(*(int*)data) {
  929                         case 0:
  930                                 sc->sc_irq &= (~LP_ENABLE_IRQ);
  931                                 break;
  932                         case 1:
  933                                 sc->sc_irq &= (~LP_ENABLE_EXT);
  934                                 sc->sc_irq |= LP_ENABLE_IRQ;
  935                                 break;
  936                         case 2:
  937                                 /* classic irq based transfer and advanced
  938                                  * modes are in conflict
  939                                  */
  940                                 sc->sc_irq &= (~LP_ENABLE_IRQ);
  941                                 sc->sc_irq |= LP_ENABLE_EXT;
  942                                 break;
  943                         case 3:
  944                                 sc->sc_irq &= (~LP_ENABLE_EXT);
  945                                 break;
  946                         default:
  947                                 break;
  948                         }
  949                                 
  950                         if (old_sc_irq != sc->sc_irq )
  951                                 log(LOG_NOTICE, LPT_NAME "%d: switched to %s %s mode\n",
  952                                         unit,
  953                                         (sc->sc_irq & LP_ENABLE_IRQ)?
  954                                         "interrupt-driven":"polled",
  955                                         (sc->sc_irq & LP_ENABLE_EXT)?
  956                                         "extended":"standard");
  957                 } else /* polled port */
  958                         error = EOPNOTSUPP;
  959                 break;
  960         default:
  961                 error = ENODEV;
  962         }
  963 
  964         return(error);
  965 }
  966 
  967 static device_method_t lpt_methods[] = {
  968         /* device interface */
  969         DEVMETHOD(device_identify,      lpt_identify),
  970         DEVMETHOD(device_probe,         lpt_probe),
  971         DEVMETHOD(device_attach,        lpt_attach),
  972         DEVMETHOD(device_detach,        lpt_detach),
  973 
  974         { 0, 0 }
  975 };
  976 
  977 static driver_t lpt_driver = {
  978         LPT_NAME,
  979         lpt_methods,
  980         sizeof(struct lpt_data),
  981 };
  982 
  983 DRIVER_MODULE(lpt, ppbus, lpt_driver, lpt_devclass, 0, 0);
  984 MODULE_DEPEND(lpt, ppbus, 1, 1, 1);

Cache object: 24bdf0d76189cd2232f88e9a6edf86d5


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.