1127 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Generic parallel printer driver4 *5 * Copyright (C) 1992 by Jim Weigand and Linus Torvalds6 * Copyright (C) 1992,1993 by Michael K. Johnson7 * - Thanks much to Gunter Windau for pointing out to me where the error8 * checking ought to be.9 * Copyright (C) 1993 by Nigel Gamble (added interrupt code)10 * Copyright (C) 1994 by Alan Cox (Modularised it)11 * LPCAREFUL, LPABORT, LPGETSTATUS added by Chris Metcalf, metcalf@lcs.mit.edu12 * Statistics and support for slow printers by Rob Janssen, rob@knoware.nl13 * "lp=" command line parameters added by Grant Guenther, grant@torque.net14 * lp_read (Status readback) support added by Carsten Gross,15 * carsten@sol.wohnheim.uni-ulm.de16 * Support for parport by Philip Blundell <philb@gnu.org>17 * Parport sharing hacking by Andrea Arcangeli18 * Fixed kernel_(to/from)_user memory copy to check for errors19 * by Riccardo Facchetti <fizban@tin.it>20 * 22-JAN-1998 Added support for devfs Richard Gooch <rgooch@atnf.csiro.au>21 * Redesigned interrupt handling for handle printers with buggy handshake22 * by Andrea Arcangeli, 11 May 199823 * Full efficient handling of printer with buggy irq handshake (now I have24 * understood the meaning of the strange handshake). This is done sending new25 * characters if the interrupt is just happened, even if the printer say to26 * be still BUSY. This is needed at least with Epson Stylus Color. To enable27 * the new TRUST_IRQ mode read the `LP OPTIMIZATION' section below...28 * Fixed the irq on the rising edge of the strobe case.29 * Obsoleted the CAREFUL flag since a printer that doesn' t work with30 * CAREFUL will block a bit after in lp_check_status().31 * Andrea Arcangeli, 15 Oct 199832 * Obsoleted and removed all the lowlevel stuff implemented in the last33 * month to use the IEEE1284 functions (that handle the _new_ compatibilty34 * mode fine).35 */36 37/* This driver should, in theory, work with any parallel port that has an38 * appropriate low-level driver; all I/O is done through the parport39 * abstraction layer.40 *41 * If this driver is built into the kernel, you can configure it using the42 * kernel command-line. For example:43 *44 * lp=parport1,none,parport2 (bind lp0 to parport1, disable lp1 and45 * bind lp2 to parport2)46 *47 * lp=auto (assign lp devices to all ports that48 * have printers attached, as determined49 * by the IEEE-1284 autoprobe)50 *51 * lp=reset (reset the printer during52 * initialisation)53 *54 * lp=off (disable the printer driver entirely)55 *56 * If the driver is loaded as a module, similar functionality is available57 * using module parameters. The equivalent of the above commands would be:58 *59 * # insmod lp.o parport=1,none,260 *61 * # insmod lp.o parport=auto62 *63 * # insmod lp.o reset=164 */65 66/* COMPATIBILITY WITH OLD KERNELS67 *68 * Under Linux 2.0 and previous versions, lp devices were bound to ports at69 * particular I/O addresses, as follows:70 *71 * lp0 0x3bc72 * lp1 0x37873 * lp2 0x27874 *75 * The new driver, by default, binds lp devices to parport devices as it76 * finds them. This means that if you only have one port, it will be bound77 * to lp0 regardless of its I/O address. If you need the old behaviour, you78 * can force it using the parameters described above.79 */80 81/*82 * The new interrupt handling code take care of the buggy handshake83 * of some HP and Epson printer:84 * ___85 * ACK _______________ ___________86 * |__|87 * ____88 * BUSY _________ _______89 * |____________|90 *91 * I discovered this using the printer scanner that you can find at:92 *93 * ftp://e-mind.com/pub/linux/pscan/94 *95 * 11 May 98, Andrea Arcangeli96 *97 * My printer scanner run on an Epson Stylus Color show that such printer98 * generates the irq on the _rising_ edge of the STROBE. Now lp handle99 * this case fine too.100 *101 * 15 Oct 1998, Andrea Arcangeli102 *103 * The so called `buggy' handshake is really the well documented104 * compatibility mode IEEE1284 handshake. They changed the well known105 * Centronics handshake acking in the middle of busy expecting to not106 * break drivers or legacy application, while they broken linux lp107 * until I fixed it reverse engineering the protocol by hand some108 * month ago...109 *110 * 14 Dec 1998, Andrea Arcangeli111 *112 * Copyright (C) 2000 by Tim Waugh (added LPSETTIMEOUT ioctl)113 */114 115#include <linux/module.h>116#include <linux/init.h>117 118#include <linux/errno.h>119#include <linux/kernel.h>120#include <linux/major.h>121#include <linux/sched/signal.h>122#include <linux/slab.h>123#include <linux/fcntl.h>124#include <linux/delay.h>125#include <linux/poll.h>126#include <linux/console.h>127#include <linux/device.h>128#include <linux/wait.h>129#include <linux/jiffies.h>130#include <linux/mutex.h>131#include <linux/compat.h>132 133#include <linux/parport.h>134#undef LP_STATS135#include <linux/lp.h>136 137#include <asm/irq.h>138#include <linux/uaccess.h>139 140/* if you have more than 8 printers, remember to increase LP_NO */141#define LP_NO 8142 143static DEFINE_MUTEX(lp_mutex);144static struct lp_struct lp_table[LP_NO];145static int port_num[LP_NO];146 147static unsigned int lp_count = 0;148static const struct class lp_class = {149 .name = "printer",150};151 152#ifdef CONFIG_LP_CONSOLE153static struct parport *console_registered;154#endif /* CONFIG_LP_CONSOLE */155 156#undef LP_DEBUG157 158/* Bits used to manage claiming the parport device */159#define LP_PREEMPT_REQUEST 1160#define LP_PARPORT_CLAIMED 2161 162/* --- low-level port access ----------------------------------- */163 164#define r_dtr(x) (parport_read_data(lp_table[(x)].dev->port))165#define r_str(x) (parport_read_status(lp_table[(x)].dev->port))166#define w_ctr(x,y) do { parport_write_control(lp_table[(x)].dev->port, (y)); } while (0)167#define w_dtr(x,y) do { parport_write_data(lp_table[(x)].dev->port, (y)); } while (0)168 169/* Claim the parport or block trying unless we've already claimed it */170static void lp_claim_parport_or_block(struct lp_struct *this_lp)171{172 if (!test_and_set_bit(LP_PARPORT_CLAIMED, &this_lp->bits)) {173 parport_claim_or_block(this_lp->dev);174 }175}176 177/* Claim the parport or block trying unless we've already claimed it */178static void lp_release_parport(struct lp_struct *this_lp)179{180 if (test_and_clear_bit(LP_PARPORT_CLAIMED, &this_lp->bits)) {181 parport_release(this_lp->dev);182 }183}184 185 186 187static int lp_preempt(void *handle)188{189 struct lp_struct *this_lp = (struct lp_struct *)handle;190 set_bit(LP_PREEMPT_REQUEST, &this_lp->bits);191 return 1;192}193 194 195/*196 * Try to negotiate to a new mode; if unsuccessful negotiate to197 * compatibility mode. Return the mode we ended up in.198 */199static int lp_negotiate(struct parport *port, int mode)200{201 if (parport_negotiate(port, mode) != 0) {202 mode = IEEE1284_MODE_COMPAT;203 parport_negotiate(port, mode);204 }205 206 return mode;207}208 209static int lp_reset(int minor)210{211 int retval;212 lp_claim_parport_or_block(&lp_table[minor]);213 w_ctr(minor, LP_PSELECP);214 udelay(LP_DELAY);215 w_ctr(minor, LP_PSELECP | LP_PINITP);216 retval = r_str(minor);217 lp_release_parport(&lp_table[minor]);218 return retval;219}220 221static void lp_error(int minor)222{223 DEFINE_WAIT(wait);224 int polling;225 226 if (LP_F(minor) & LP_ABORT)227 return;228 229 polling = lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE;230 if (polling)231 lp_release_parport(&lp_table[minor]);232 prepare_to_wait(&lp_table[minor].waitq, &wait, TASK_INTERRUPTIBLE);233 schedule_timeout(LP_TIMEOUT_POLLED);234 finish_wait(&lp_table[minor].waitq, &wait);235 if (polling)236 lp_claim_parport_or_block(&lp_table[minor]);237 else238 parport_yield_blocking(lp_table[minor].dev);239}240 241static int lp_check_status(int minor)242{243 int error = 0;244 unsigned int last = lp_table[minor].last_error;245 unsigned char status = r_str(minor);246 if ((status & LP_PERRORP) && !(LP_F(minor) & LP_CAREFUL))247 /* No error. */248 last = 0;249 else if ((status & LP_POUTPA)) {250 if (last != LP_POUTPA) {251 last = LP_POUTPA;252 printk(KERN_INFO "lp%d out of paper\n", minor);253 }254 error = -ENOSPC;255 } else if (!(status & LP_PSELECD)) {256 if (last != LP_PSELECD) {257 last = LP_PSELECD;258 printk(KERN_INFO "lp%d off-line\n", minor);259 }260 error = -EIO;261 } else if (!(status & LP_PERRORP)) {262 if (last != LP_PERRORP) {263 last = LP_PERRORP;264 printk(KERN_INFO "lp%d on fire\n", minor);265 }266 error = -EIO;267 } else {268 last = 0; /* Come here if LP_CAREFUL is set and no269 errors are reported. */270 }271 272 lp_table[minor].last_error = last;273 274 if (last != 0)275 lp_error(minor);276 277 return error;278}279 280static int lp_wait_ready(int minor, int nonblock)281{282 int error = 0;283 284 /* If we're not in compatibility mode, we're ready now! */285 if (lp_table[minor].current_mode != IEEE1284_MODE_COMPAT) {286 return 0;287 }288 289 do {290 error = lp_check_status(minor);291 if (error && (nonblock || (LP_F(minor) & LP_ABORT)))292 break;293 if (signal_pending(current)) {294 error = -EINTR;295 break;296 }297 } while (error);298 return error;299}300 301static ssize_t lp_write(struct file *file, const char __user *buf,302 size_t count, loff_t *ppos)303{304 unsigned int minor = iminor(file_inode(file));305 struct parport *port = lp_table[minor].dev->port;306 char *kbuf = lp_table[minor].lp_buffer;307 ssize_t retv = 0;308 ssize_t written;309 size_t copy_size = count;310 int nonblock = ((file->f_flags & O_NONBLOCK) ||311 (LP_F(minor) & LP_ABORT));312 313#ifdef LP_STATS314 if (time_after(jiffies, lp_table[minor].lastcall + LP_TIME(minor)))315 lp_table[minor].runchars = 0;316 317 lp_table[minor].lastcall = jiffies;318#endif319 320 /* Need to copy the data from user-space. */321 if (copy_size > LP_BUFFER_SIZE)322 copy_size = LP_BUFFER_SIZE;323 324 if (mutex_lock_interruptible(&lp_table[minor].port_mutex))325 return -EINTR;326 327 if (copy_from_user(kbuf, buf, copy_size)) {328 retv = -EFAULT;329 goto out_unlock;330 }331 332 /* Claim Parport or sleep until it becomes available333 */334 lp_claim_parport_or_block(&lp_table[minor]);335 /* Go to the proper mode. */336 lp_table[minor].current_mode = lp_negotiate(port,337 lp_table[minor].best_mode);338 339 parport_set_timeout(lp_table[minor].dev,340 (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK341 : lp_table[minor].timeout));342 343 if ((retv = lp_wait_ready(minor, nonblock)) == 0)344 do {345 /* Write the data. */346 written = parport_write(port, kbuf, copy_size);347 if (written > 0) {348 copy_size -= written;349 count -= written;350 buf += written;351 retv += written;352 }353 354 if (signal_pending(current)) {355 if (retv == 0)356 retv = -EINTR;357 358 break;359 }360 361 if (copy_size > 0) {362 /* incomplete write -> check error ! */363 int error;364 365 parport_negotiate(lp_table[minor].dev->port,366 IEEE1284_MODE_COMPAT);367 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;368 369 error = lp_wait_ready(minor, nonblock);370 371 if (error) {372 if (retv == 0)373 retv = error;374 break;375 } else if (nonblock) {376 if (retv == 0)377 retv = -EAGAIN;378 break;379 }380 381 parport_yield_blocking(lp_table[minor].dev);382 lp_table[minor].current_mode383 = lp_negotiate(port,384 lp_table[minor].best_mode);385 386 } else if (need_resched())387 schedule();388 389 if (count) {390 copy_size = count;391 if (copy_size > LP_BUFFER_SIZE)392 copy_size = LP_BUFFER_SIZE;393 394 if (copy_from_user(kbuf, buf, copy_size)) {395 if (retv == 0)396 retv = -EFAULT;397 break;398 }399 }400 } while (count > 0);401 402 if (test_and_clear_bit(LP_PREEMPT_REQUEST,403 &lp_table[minor].bits)) {404 printk(KERN_INFO "lp%d releasing parport\n", minor);405 parport_negotiate(lp_table[minor].dev->port,406 IEEE1284_MODE_COMPAT);407 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;408 lp_release_parport(&lp_table[minor]);409 }410out_unlock:411 mutex_unlock(&lp_table[minor].port_mutex);412 413 return retv;414}415 416#ifdef CONFIG_PARPORT_1284417 418/* Status readback conforming to ieee1284 */419static ssize_t lp_read(struct file *file, char __user *buf,420 size_t count, loff_t *ppos)421{422 DEFINE_WAIT(wait);423 unsigned int minor=iminor(file_inode(file));424 struct parport *port = lp_table[minor].dev->port;425 ssize_t retval = 0;426 char *kbuf = lp_table[minor].lp_buffer;427 int nonblock = ((file->f_flags & O_NONBLOCK) ||428 (LP_F(minor) & LP_ABORT));429 430 if (count > LP_BUFFER_SIZE)431 count = LP_BUFFER_SIZE;432 433 if (mutex_lock_interruptible(&lp_table[minor].port_mutex))434 return -EINTR;435 436 lp_claim_parport_or_block(&lp_table[minor]);437 438 parport_set_timeout(lp_table[minor].dev,439 (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK440 : lp_table[minor].timeout));441 442 parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);443 if (parport_negotiate(lp_table[minor].dev->port,444 IEEE1284_MODE_NIBBLE)) {445 retval = -EIO;446 goto out;447 }448 449 while (retval == 0) {450 retval = parport_read(port, kbuf, count);451 452 if (retval > 0)453 break;454 455 if (nonblock) {456 retval = -EAGAIN;457 break;458 }459 460 /* Wait for data. */461 462 if (lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE) {463 parport_negotiate(lp_table[minor].dev->port,464 IEEE1284_MODE_COMPAT);465 lp_error(minor);466 if (parport_negotiate(lp_table[minor].dev->port,467 IEEE1284_MODE_NIBBLE)) {468 retval = -EIO;469 goto out;470 }471 } else {472 prepare_to_wait(&lp_table[minor].waitq, &wait, TASK_INTERRUPTIBLE);473 schedule_timeout(LP_TIMEOUT_POLLED);474 finish_wait(&lp_table[minor].waitq, &wait);475 }476 477 if (signal_pending(current)) {478 retval = -ERESTARTSYS;479 break;480 }481 482 cond_resched();483 }484 parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);485 out:486 lp_release_parport(&lp_table[minor]);487 488 if (retval > 0 && copy_to_user(buf, kbuf, retval))489 retval = -EFAULT;490 491 mutex_unlock(&lp_table[minor].port_mutex);492 493 return retval;494}495 496#endif /* IEEE 1284 support */497 498static int lp_open(struct inode *inode, struct file *file)499{500 unsigned int minor = iminor(inode);501 int ret = 0;502 503 mutex_lock(&lp_mutex);504 if (minor >= LP_NO) {505 ret = -ENXIO;506 goto out;507 }508 if ((LP_F(minor) & LP_EXIST) == 0) {509 ret = -ENXIO;510 goto out;511 }512 if (test_and_set_bit(LP_BUSY_BIT_POS, &LP_F(minor))) {513 ret = -EBUSY;514 goto out;515 }516 /* If ABORTOPEN is set and the printer is offline or out of paper,517 we may still want to open it to perform ioctl()s. Therefore we518 have commandeered O_NONBLOCK, even though it is being used in519 a non-standard manner. This is strictly a Linux hack, and520 should most likely only ever be used by the tunelp application. */521 if ((LP_F(minor) & LP_ABORTOPEN) && !(file->f_flags & O_NONBLOCK)) {522 int status;523 lp_claim_parport_or_block(&lp_table[minor]);524 status = r_str(minor);525 lp_release_parport(&lp_table[minor]);526 if (status & LP_POUTPA) {527 printk(KERN_INFO "lp%d out of paper\n", minor);528 LP_F(minor) &= ~LP_BUSY;529 ret = -ENOSPC;530 goto out;531 } else if (!(status & LP_PSELECD)) {532 printk(KERN_INFO "lp%d off-line\n", minor);533 LP_F(minor) &= ~LP_BUSY;534 ret = -EIO;535 goto out;536 } else if (!(status & LP_PERRORP)) {537 printk(KERN_ERR "lp%d printer error\n", minor);538 LP_F(minor) &= ~LP_BUSY;539 ret = -EIO;540 goto out;541 }542 }543 lp_table[minor].lp_buffer = kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);544 if (!lp_table[minor].lp_buffer) {545 LP_F(minor) &= ~LP_BUSY;546 ret = -ENOMEM;547 goto out;548 }549 /* Determine if the peripheral supports ECP mode */550 lp_claim_parport_or_block(&lp_table[minor]);551 if ((lp_table[minor].dev->port->modes & PARPORT_MODE_ECP) &&552 !parport_negotiate(lp_table[minor].dev->port,553 IEEE1284_MODE_ECP)) {554 printk(KERN_INFO "lp%d: ECP mode\n", minor);555 lp_table[minor].best_mode = IEEE1284_MODE_ECP;556 } else {557 lp_table[minor].best_mode = IEEE1284_MODE_COMPAT;558 }559 /* Leave peripheral in compatibility mode */560 parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);561 lp_release_parport(&lp_table[minor]);562 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;563out:564 mutex_unlock(&lp_mutex);565 return ret;566}567 568static int lp_release(struct inode *inode, struct file *file)569{570 unsigned int minor = iminor(inode);571 572 lp_claim_parport_or_block(&lp_table[minor]);573 parport_negotiate(lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);574 lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;575 lp_release_parport(&lp_table[minor]);576 kfree(lp_table[minor].lp_buffer);577 lp_table[minor].lp_buffer = NULL;578 LP_F(minor) &= ~LP_BUSY;579 return 0;580}581 582static int lp_do_ioctl(unsigned int minor, unsigned int cmd,583 unsigned long arg, void __user *argp)584{585 int status;586 int retval = 0;587 588#ifdef LP_DEBUG589 printk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg);590#endif591 if (minor >= LP_NO)592 return -ENODEV;593 if ((LP_F(minor) & LP_EXIST) == 0)594 return -ENODEV;595 switch (cmd) {596 case LPTIME:597 if (arg > UINT_MAX / HZ)598 return -EINVAL;599 LP_TIME(minor) = arg * HZ/100;600 break;601 case LPCHAR:602 LP_CHAR(minor) = arg;603 break;604 case LPABORT:605 if (arg)606 LP_F(minor) |= LP_ABORT;607 else608 LP_F(minor) &= ~LP_ABORT;609 break;610 case LPABORTOPEN:611 if (arg)612 LP_F(minor) |= LP_ABORTOPEN;613 else614 LP_F(minor) &= ~LP_ABORTOPEN;615 break;616 case LPCAREFUL:617 if (arg)618 LP_F(minor) |= LP_CAREFUL;619 else620 LP_F(minor) &= ~LP_CAREFUL;621 break;622 case LPWAIT:623 LP_WAIT(minor) = arg;624 break;625 case LPSETIRQ:626 return -EINVAL;627 case LPGETIRQ:628 if (copy_to_user(argp, &LP_IRQ(minor),629 sizeof(int)))630 return -EFAULT;631 break;632 case LPGETSTATUS:633 if (mutex_lock_interruptible(&lp_table[minor].port_mutex))634 return -EINTR;635 lp_claim_parport_or_block(&lp_table[minor]);636 status = r_str(minor);637 lp_release_parport(&lp_table[minor]);638 mutex_unlock(&lp_table[minor].port_mutex);639 640 if (copy_to_user(argp, &status, sizeof(int)))641 return -EFAULT;642 break;643 case LPRESET:644 lp_reset(minor);645 break;646#ifdef LP_STATS647 case LPGETSTATS:648 if (copy_to_user(argp, &LP_STAT(minor),649 sizeof(struct lp_stats)))650 return -EFAULT;651 if (capable(CAP_SYS_ADMIN))652 memset(&LP_STAT(minor), 0,653 sizeof(struct lp_stats));654 break;655#endif656 case LPGETFLAGS:657 status = LP_F(minor);658 if (copy_to_user(argp, &status, sizeof(int)))659 return -EFAULT;660 break;661 662 default:663 retval = -EINVAL;664 }665 return retval;666}667 668static int lp_set_timeout(unsigned int minor, s64 tv_sec, long tv_usec)669{670 long to_jiffies;671 672 /* Convert to jiffies, place in lp_table */673 if (tv_sec < 0 || tv_usec < 0)674 return -EINVAL;675 676 /*677 * we used to not check, so let's not make this fatal,678 * but deal with user space passing a 32-bit tv_nsec in679 * a 64-bit field, capping the timeout to 1 second680 * worth of microseconds, and capping the total at681 * MAX_JIFFY_OFFSET.682 */683 if (tv_usec > 999999)684 tv_usec = 999999;685 686 if (tv_sec >= MAX_SEC_IN_JIFFIES - 1) {687 to_jiffies = MAX_JIFFY_OFFSET;688 } else {689 to_jiffies = DIV_ROUND_UP(tv_usec, 1000000/HZ);690 to_jiffies += tv_sec * (long) HZ;691 }692 693 if (to_jiffies <= 0) {694 return -EINVAL;695 }696 lp_table[minor].timeout = to_jiffies;697 return 0;698}699 700static int lp_set_timeout32(unsigned int minor, void __user *arg)701{702 s32 karg[2];703 704 if (copy_from_user(karg, arg, sizeof(karg)))705 return -EFAULT;706 707 return lp_set_timeout(minor, karg[0], karg[1]);708}709 710static int lp_set_timeout64(unsigned int minor, void __user *arg)711{712 s64 karg[2];713 714 if (copy_from_user(karg, arg, sizeof(karg)))715 return -EFAULT;716 717 /* sparc64 suseconds_t is 32-bit only */718 if (IS_ENABLED(CONFIG_SPARC64) && !in_compat_syscall())719 karg[1] >>= 32;720 721 return lp_set_timeout(minor, karg[0], karg[1]);722}723 724static long lp_ioctl(struct file *file, unsigned int cmd,725 unsigned long arg)726{727 unsigned int minor;728 int ret;729 730 minor = iminor(file_inode(file));731 mutex_lock(&lp_mutex);732 switch (cmd) {733 case LPSETTIMEOUT_OLD:734 if (BITS_PER_LONG == 32) {735 ret = lp_set_timeout32(minor, (void __user *)arg);736 break;737 }738 fallthrough; /* for 64-bit */739 case LPSETTIMEOUT_NEW:740 ret = lp_set_timeout64(minor, (void __user *)arg);741 break;742 default:743 ret = lp_do_ioctl(minor, cmd, arg, (void __user *)arg);744 break;745 }746 mutex_unlock(&lp_mutex);747 748 return ret;749}750 751#ifdef CONFIG_COMPAT752static long lp_compat_ioctl(struct file *file, unsigned int cmd,753 unsigned long arg)754{755 unsigned int minor;756 int ret;757 758 minor = iminor(file_inode(file));759 mutex_lock(&lp_mutex);760 switch (cmd) {761 case LPSETTIMEOUT_OLD:762 if (!COMPAT_USE_64BIT_TIME) {763 ret = lp_set_timeout32(minor, (void __user *)arg);764 break;765 }766 fallthrough; /* for x32 mode */767 case LPSETTIMEOUT_NEW:768 ret = lp_set_timeout64(minor, (void __user *)arg);769 break;770#ifdef LP_STATS771 case LPGETSTATS:772 /* FIXME: add an implementation if you set LP_STATS */773 ret = -EINVAL;774 break;775#endif776 default:777 ret = lp_do_ioctl(minor, cmd, arg, compat_ptr(arg));778 break;779 }780 mutex_unlock(&lp_mutex);781 782 return ret;783}784#endif785 786static const struct file_operations lp_fops = {787 .owner = THIS_MODULE,788 .write = lp_write,789 .unlocked_ioctl = lp_ioctl,790#ifdef CONFIG_COMPAT791 .compat_ioctl = lp_compat_ioctl,792#endif793 .open = lp_open,794 .release = lp_release,795#ifdef CONFIG_PARPORT_1284796 .read = lp_read,797#endif798 .llseek = noop_llseek,799};800 801/* --- support for console on the line printer ----------------- */802 803#ifdef CONFIG_LP_CONSOLE804 805#define CONSOLE_LP 0806 807/* If the printer is out of paper, we can either lose the messages or808 * stall until the printer is happy again. Define CONSOLE_LP_STRICT809 * non-zero to get the latter behaviour. */810#define CONSOLE_LP_STRICT 1811 812/* The console must be locked when we get here. */813 814static void lp_console_write(struct console *co, const char *s,815 unsigned count)816{817 struct pardevice *dev = lp_table[CONSOLE_LP].dev;818 struct parport *port = dev->port;819 ssize_t written;820 821 if (parport_claim(dev))822 /* Nothing we can do. */823 return;824 825 parport_set_timeout(dev, 0);826 827 /* Go to compatibility mode. */828 parport_negotiate(port, IEEE1284_MODE_COMPAT);829 830 do {831 /* Write the data, converting LF->CRLF as we go. */832 ssize_t canwrite = count;833 char *lf = memchr(s, '\n', count);834 if (lf)835 canwrite = lf - s;836 837 if (canwrite > 0) {838 written = parport_write(port, s, canwrite);839 840 if (written <= 0)841 continue;842 843 s += written;844 count -= written;845 canwrite -= written;846 }847 848 if (lf && canwrite <= 0) {849 const char *crlf = "\r\n";850 int i = 2;851 852 /* Dodge the original '\n', and put '\r\n' instead. */853 s++;854 count--;855 do {856 written = parport_write(port, crlf, i);857 if (written > 0) {858 i -= written;859 crlf += written;860 }861 } while (i > 0 && (CONSOLE_LP_STRICT || written > 0));862 }863 } while (count > 0 && (CONSOLE_LP_STRICT || written > 0));864 865 parport_release(dev);866}867 868static struct console lpcons = {869 .name = "lp",870 .write = lp_console_write,871 .flags = CON_PRINTBUFFER,872};873 874#endif /* console on line printer */875 876/* --- initialisation code ------------------------------------- */877 878static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };879static char *parport[LP_NO];880static bool reset;881 882module_param_array(parport, charp, NULL, 0);883module_param(reset, bool, 0);884 885#ifndef MODULE886static int __init lp_setup(char *str)887{888 static int parport_ptr;889 int x;890 891 if (get_option(&str, &x)) {892 if (x == 0) {893 /* disable driver on "lp=" or "lp=0" */894 parport_nr[0] = LP_PARPORT_OFF;895 } else {896 printk(KERN_WARNING "warning: 'lp=0x%x' is deprecated, ignored\n", x);897 return 0;898 }899 } else if (!strncmp(str, "parport", 7)) {900 int n = simple_strtoul(str+7, NULL, 10);901 if (parport_ptr < LP_NO)902 parport_nr[parport_ptr++] = n;903 else904 printk(KERN_INFO "lp: too many ports, %s ignored.\n",905 str);906 } else if (!strcmp(str, "auto")) {907 parport_nr[0] = LP_PARPORT_AUTO;908 } else if (!strcmp(str, "none")) {909 if (parport_ptr < LP_NO)910 parport_nr[parport_ptr++] = LP_PARPORT_NONE;911 else912 printk(KERN_INFO "lp: too many ports, %s ignored.\n",913 str);914 } else if (!strcmp(str, "reset")) {915 reset = true;916 }917 return 1;918}919#endif920 921static int lp_register(int nr, struct parport *port)922{923 struct pardev_cb ppdev_cb;924 925 memset(&ppdev_cb, 0, sizeof(ppdev_cb));926 ppdev_cb.preempt = lp_preempt;927 ppdev_cb.private = &lp_table[nr];928 lp_table[nr].dev = parport_register_dev_model(port, "lp",929 &ppdev_cb, nr);930 if (lp_table[nr].dev == NULL)931 return 1;932 lp_table[nr].flags |= LP_EXIST;933 934 if (reset)935 lp_reset(nr);936 937 device_create(&lp_class, port->dev, MKDEV(LP_MAJOR, nr), NULL,938 "lp%d", nr);939 940 printk(KERN_INFO "lp%d: using %s (%s).\n", nr, port->name,941 (port->irq == PARPORT_IRQ_NONE)?"polling":"interrupt-driven");942 943#ifdef CONFIG_LP_CONSOLE944 if (!nr) {945 if (port->modes & PARPORT_MODE_SAFEININT) {946 register_console(&lpcons);947 console_registered = port;948 printk(KERN_INFO "lp%d: console ready\n", CONSOLE_LP);949 } else950 printk(KERN_ERR "lp%d: cannot run console on %s\n",951 CONSOLE_LP, port->name);952 }953#endif954 port_num[nr] = port->number;955 956 return 0;957}958 959static void lp_attach(struct parport *port)960{961 unsigned int i;962 963 switch (parport_nr[0]) {964 case LP_PARPORT_UNSPEC:965 case LP_PARPORT_AUTO:966 if (parport_nr[0] == LP_PARPORT_AUTO &&967 port->probe_info[0].class != PARPORT_CLASS_PRINTER)968 return;969 if (lp_count == LP_NO) {970 printk(KERN_INFO "lp: ignoring parallel port (max. %d)\n",LP_NO);971 return;972 }973 for (i = 0; i < LP_NO; i++)974 if (port_num[i] == -1)975 break;976 977 if (!lp_register(i, port))978 lp_count++;979 break;980 981 default:982 for (i = 0; i < LP_NO; i++) {983 if (port->number == parport_nr[i]) {984 if (!lp_register(i, port))985 lp_count++;986 break;987 }988 }989 break;990 }991}992 993static void lp_detach(struct parport *port)994{995 int n;996 997 /* Write this some day. */998#ifdef CONFIG_LP_CONSOLE999 if (console_registered == port) {1000 unregister_console(&lpcons);1001 console_registered = NULL;1002 }1003#endif /* CONFIG_LP_CONSOLE */1004 1005 for (n = 0; n < LP_NO; n++) {1006 if (port_num[n] == port->number) {1007 port_num[n] = -1;1008 lp_count--;1009 device_destroy(&lp_class, MKDEV(LP_MAJOR, n));1010 parport_unregister_device(lp_table[n].dev);1011 }1012 }1013}1014 1015static struct parport_driver lp_driver = {1016 .name = "lp",1017 .match_port = lp_attach,1018 .detach = lp_detach,1019};1020 1021static int __init lp_init(void)1022{1023 int i, err;1024 1025 if (parport_nr[0] == LP_PARPORT_OFF)1026 return 0;1027 1028 for (i = 0; i < LP_NO; i++) {1029 lp_table[i].dev = NULL;1030 lp_table[i].flags = 0;1031 lp_table[i].chars = LP_INIT_CHAR;1032 lp_table[i].time = LP_INIT_TIME;1033 lp_table[i].wait = LP_INIT_WAIT;1034 lp_table[i].lp_buffer = NULL;1035#ifdef LP_STATS1036 lp_table[i].lastcall = 0;1037 lp_table[i].runchars = 0;1038 memset(&lp_table[i].stats, 0, sizeof(struct lp_stats));1039#endif1040 lp_table[i].last_error = 0;1041 init_waitqueue_head(&lp_table[i].waitq);1042 init_waitqueue_head(&lp_table[i].dataq);1043 mutex_init(&lp_table[i].port_mutex);1044 lp_table[i].timeout = 10 * HZ;1045 port_num[i] = -1;1046 }1047 1048 if (register_chrdev(LP_MAJOR, "lp", &lp_fops)) {1049 printk(KERN_ERR "lp: unable to get major %d\n", LP_MAJOR);1050 return -EIO;1051 }1052 1053 err = class_register(&lp_class);1054 if (err)1055 goto out_reg;1056 1057 if (parport_register_driver(&lp_driver)) {1058 printk(KERN_ERR "lp: unable to register with parport\n");1059 err = -EIO;1060 goto out_class;1061 }1062 1063 if (!lp_count) {1064 printk(KERN_INFO "lp: driver loaded but no devices found\n");1065#ifndef CONFIG_PARPORT_12841066 if (parport_nr[0] == LP_PARPORT_AUTO)1067 printk(KERN_INFO "lp: (is IEEE 1284 support enabled?)\n");1068#endif1069 }1070 1071 return 0;1072 1073out_class:1074 class_unregister(&lp_class);1075out_reg:1076 unregister_chrdev(LP_MAJOR, "lp");1077 return err;1078}1079 1080static int __init lp_init_module(void)1081{1082 if (parport[0]) {1083 /* The user gave some parameters. Let's see what they were. */1084 if (!strncmp(parport[0], "auto", 4))1085 parport_nr[0] = LP_PARPORT_AUTO;1086 else {1087 int n;1088 for (n = 0; n < LP_NO && parport[n]; n++) {1089 if (!strncmp(parport[n], "none", 4))1090 parport_nr[n] = LP_PARPORT_NONE;1091 else {1092 char *ep;1093 unsigned long r = simple_strtoul(parport[n], &ep, 0);1094 if (ep != parport[n])1095 parport_nr[n] = r;1096 else {1097 printk(KERN_ERR "lp: bad port specifier `%s'\n", parport[n]);1098 return -ENODEV;1099 }1100 }1101 }1102 }1103 }1104 1105 return lp_init();1106}1107 1108static void lp_cleanup_module(void)1109{1110 parport_unregister_driver(&lp_driver);1111 1112#ifdef CONFIG_LP_CONSOLE1113 unregister_console(&lpcons);1114#endif1115 1116 unregister_chrdev(LP_MAJOR, "lp");1117 class_unregister(&lp_class);1118}1119 1120__setup("lp=", lp_setup);1121module_init(lp_init_module);1122module_exit(lp_cleanup_module);1123 1124MODULE_ALIAS_CHARDEV_MAJOR(LP_MAJOR);1125MODULE_DESCRIPTION("Generic parallel printer driver");1126MODULE_LICENSE("GPL");1127