1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Generic parallel printer driver 4 * 5 * Copyright (C) 1992 by Jim Weigand and Linus Torvalds 6 * Copyright (C) 1992,1993 by Michael K. Johnson 7 * - Thanks much to Gunter Windau for pointing out to me where the error 8 * 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.edu 12 * Statistics and support for slow printers by Rob Janssen, rob@knoware.nl 13 * "lp=" command line parameters added by Grant Guenther, grant@torque.net 14 * lp_read (Status readback) support added by Carsten Gross, 15 * carsten@sol.wohnheim.uni-ulm.de 16 * Support for parport by Philip Blundell <philb@gnu.org> 17 * Parport sharing hacking by Andrea Arcangeli 18 * Fixed kernel_(to/from)_user memory copy to check for errors 19 * 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 handshake 22 * by Andrea Arcangeli, 11 May 1998 23 * Full efficient handling of printer with buggy irq handshake (now I have 24 * understood the meaning of the strange handshake). This is done sending new 25 * characters if the interrupt is just happened, even if the printer say to 26 * be still BUSY. This is needed at least with Epson Stylus Color. To enable 27 * 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 with 30 * CAREFUL will block a bit after in lp_check_status(). 31 * Andrea Arcangeli, 15 Oct 1998 32 * Obsoleted and removed all the lowlevel stuff implemented in the last 33 * month to use the IEEE1284 functions (that handle the _new_ compatibilty 34 * mode fine). 35 */ 36 37/* This driver should, in theory, work with any parallel port that has an 38 * appropriate low-level driver; all I/O is done through the parport 39 * abstraction layer. 40 * 41 * If this driver is built into the kernel, you can configure it using the 42 * kernel command-line. For example: 43 * 44 * lp=parport1,none,parport2 (bind lp0 to parport1, disable lp1 and 45 * bind lp2 to parport2) 46 * 47 * lp=auto (assign lp devices to all ports that 48 * have printers attached, as determined 49 * by the IEEE-1284 autoprobe) 50 * 51 * lp=reset (reset the printer during 52 * initialisation) 53 * 54 * lp=off (disable the printer driver entirely) 55 * 56 * If the driver is loaded as a module, similar functionality is available 57 * using module parameters. The equivalent of the above commands would be: 58 * 59 * # insmod lp.o parport=1,none,2 60 * 61 * # insmod lp.o parport=auto 62 * 63 * # insmod lp.o reset=1 64 */ 65 66/* COMPATIBILITY WITH OLD KERNELS 67 * 68 * Under Linux 2.0 and previous versions, lp devices were bound to ports at 69 * particular I/O addresses, as follows: 70 * 71 * lp0 0x3bc 72 * lp1 0x378 73 * lp2 0x278 74 * 75 * The new driver, by default, binds lp devices to parport devices as it 76 * finds them. This means that if you only have one port, it will be bound 77 * to lp0 regardless of its I/O address. If you need the old behaviour, you 78 * can force it using the parameters described above. 79 */ 80 81/* 82 * The new interrupt handling code take care of the buggy handshake 83 * 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 Arcangeli 96 * 97 * My printer scanner run on an Epson Stylus Color show that such printer 98 * generates the irq on the _rising_ edge of the STROBE. Now lp handle 99 * this case fine too. 100 * 101 * 15 Oct 1998, Andrea Arcangeli 102 * 103 * The so called `buggy' handshake is really the well documented 104 * compatibility mode IEEE1284 handshake. They changed the well known 105 * Centronics handshake acking in the middle of busy expecting to not 106 * break drivers or legacy application, while they broken linux lp 107 * until I fixed it reverse engineering the protocol by hand some 108 * month ago... 109 * 110 * 14 Dec 1998, Andrea Arcangeli 111 * 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_STATS 135#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 8 142 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_CONSOLE 153static struct parport *console_registered; 154#endif /* CONFIG_LP_CONSOLE */ 155 156#undef LP_DEBUG 157 158/* Bits used to manage claiming the parport device */ 159#define LP_PREEMPT_REQUEST 1 160#define LP_PARPORT_CLAIMED 2 161 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 to 197 * 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 else 238 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 no 269 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_STATS 314 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#endif 319 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 available 333 */ 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_NONBLOCK 341 : 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_mode 383 = 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_1284 417 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_NONBLOCK 440 : 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 we 518 have commandeered O_NONBLOCK, even though it is being used in 519 a non-standard manner. This is strictly a Linux hack, and 520 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_DEBUG 589 printk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%lx\n", minor, cmd, arg); 590#endif 591 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 else 608 LP_F(minor) &= ~LP_ABORT; 609 break; 610 case LPABORTOPEN: 611 if (arg) 612 LP_F(minor) |= LP_ABORTOPEN; 613 else 614 LP_F(minor) &= ~LP_ABORTOPEN; 615 break; 616 case LPCAREFUL: 617 if (arg) 618 LP_F(minor) |= LP_CAREFUL; 619 else 620 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_STATS 647 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#endif 656 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 in 679 * a 64-bit field, capping the timeout to 1 second 680 * worth of microseconds, and capping the total at 681 * 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_COMPAT 752static 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_STATS 771 case LPGETSTATS: 772 /* FIXME: add an implementation if you set LP_STATS */ 773 ret = -EINVAL; 774 break; 775#endif 776 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#endif 785 786static const struct file_operations lp_fops = { 787 .owner = THIS_MODULE, 788 .write = lp_write, 789 .unlocked_ioctl = lp_ioctl, 790#ifdef CONFIG_COMPAT 791 .compat_ioctl = lp_compat_ioctl, 792#endif 793 .open = lp_open, 794 .release = lp_release, 795#ifdef CONFIG_PARPORT_1284 796 .read = lp_read, 797#endif 798 .llseek = noop_llseek, 799}; 800 801/* --- support for console on the line printer ----------------- */ 802 803#ifdef CONFIG_LP_CONSOLE 804 805#define CONSOLE_LP 0 806 807/* If the printer is out of paper, we can either lose the messages or 808 * stall until the printer is happy again. Define CONSOLE_LP_STRICT 809 * non-zero to get the latter behaviour. */ 810#define CONSOLE_LP_STRICT 1 811 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 MODULE 886static 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 else 904 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 else 912 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#endif 920 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_CONSOLE 944 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 } else 950 printk(KERN_ERR "lp%d: cannot run console on %s\n", 951 CONSOLE_LP, port->name); 952 } 953#endif 954 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_CONSOLE 999 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 .devmodel = true, 1020}; 1021 1022static int __init lp_init(void) 1023{ 1024 int i, err; 1025 1026 if (parport_nr[0] == LP_PARPORT_OFF) 1027 return 0; 1028 1029 for (i = 0; i < LP_NO; i++) { 1030 lp_table[i].dev = NULL; 1031 lp_table[i].flags = 0; 1032 lp_table[i].chars = LP_INIT_CHAR; 1033 lp_table[i].time = LP_INIT_TIME; 1034 lp_table[i].wait = LP_INIT_WAIT; 1035 lp_table[i].lp_buffer = NULL; 1036#ifdef LP_STATS 1037 lp_table[i].lastcall = 0; 1038 lp_table[i].runchars = 0; 1039 memset(&lp_table[i].stats, 0, sizeof(struct lp_stats)); 1040#endif 1041 lp_table[i].last_error = 0; 1042 init_waitqueue_head(&lp_table[i].waitq); 1043 init_waitqueue_head(&lp_table[i].dataq); 1044 mutex_init(&lp_table[i].port_mutex); 1045 lp_table[i].timeout = 10 * HZ; 1046 port_num[i] = -1; 1047 } 1048 1049 if (register_chrdev(LP_MAJOR, "lp", &lp_fops)) { 1050 printk(KERN_ERR "lp: unable to get major %d\n", LP_MAJOR); 1051 return -EIO; 1052 } 1053 1054 err = class_register(&lp_class); 1055 if (err) 1056 goto out_reg; 1057 1058 if (parport_register_driver(&lp_driver)) { 1059 printk(KERN_ERR "lp: unable to register with parport\n"); 1060 err = -EIO; 1061 goto out_class; 1062 } 1063 1064 if (!lp_count) { 1065 printk(KERN_INFO "lp: driver loaded but no devices found\n"); 1066#ifndef CONFIG_PARPORT_1284 1067 if (parport_nr[0] == LP_PARPORT_AUTO) 1068 printk(KERN_INFO "lp: (is IEEE 1284 support enabled?)\n"); 1069#endif 1070 } 1071 1072 return 0; 1073 1074out_class: 1075 class_unregister(&lp_class); 1076out_reg: 1077 unregister_chrdev(LP_MAJOR, "lp"); 1078 return err; 1079} 1080 1081static int __init lp_init_module(void) 1082{ 1083 if (parport[0]) { 1084 /* The user gave some parameters. Let's see what they were. */ 1085 if (!strncmp(parport[0], "auto", 4)) 1086 parport_nr[0] = LP_PARPORT_AUTO; 1087 else { 1088 int n; 1089 for (n = 0; n < LP_NO && parport[n]; n++) { 1090 if (!strncmp(parport[n], "none", 4)) 1091 parport_nr[n] = LP_PARPORT_NONE; 1092 else { 1093 char *ep; 1094 unsigned long r = simple_strtoul(parport[n], &ep, 0); 1095 if (ep != parport[n]) 1096 parport_nr[n] = r; 1097 else { 1098 printk(KERN_ERR "lp: bad port specifier `%s'\n", parport[n]); 1099 return -ENODEV; 1100 } 1101 } 1102 } 1103 } 1104 } 1105 1106 return lp_init(); 1107} 1108 1109static void lp_cleanup_module(void) 1110{ 1111 parport_unregister_driver(&lp_driver); 1112 1113#ifdef CONFIG_LP_CONSOLE 1114 unregister_console(&lpcons); 1115#endif 1116 1117 unregister_chrdev(LP_MAJOR, "lp"); 1118 class_unregister(&lp_class); 1119} 1120 1121__setup("lp=", lp_setup); 1122module_init(lp_init_module); 1123module_exit(lp_cleanup_module); 1124 1125MODULE_ALIAS_CHARDEV_MAJOR(LP_MAJOR); 1126MODULE_LICENSE("GPL"); 1127