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