xref: /openbmc/linux/drivers/char/lp.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
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  
143  static DEFINE_MUTEX(lp_mutex);
144  static struct lp_struct lp_table[LP_NO];
145  static int port_num[LP_NO];
146  
147  static unsigned int lp_count = 0;
148  static const struct class lp_class = {
149  	.name = "printer",
150  };
151  
152  #ifdef CONFIG_LP_CONSOLE
153  static 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 */
lp_claim_parport_or_block(struct lp_struct * this_lp)170  static 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 */
lp_release_parport(struct lp_struct * this_lp)178  static 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  
lp_preempt(void * handle)187  static 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   */
lp_negotiate(struct parport * port,int mode)199  static 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  
lp_reset(int minor)209  static 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  
lp_error(int minor)221  static 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  
lp_check_status(int minor)241  static 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  
lp_wait_ready(int minor,int nonblock)280  static 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  
lp_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)301  static 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  	}
410  out_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 */
lp_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)419  static 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  
lp_open(struct inode * inode,struct file * file)498  static 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;
563  out:
564  	mutex_unlock(&lp_mutex);
565  	return ret;
566  }
567  
lp_release(struct inode * inode,struct file * file)568  static 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  
lp_do_ioctl(unsigned int minor,unsigned int cmd,unsigned long arg,void __user * argp)582  static 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  
lp_set_timeout(unsigned int minor,s64 tv_sec,long tv_usec)668  static 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  
lp_set_timeout32(unsigned int minor,void __user * arg)700  static 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  
lp_set_timeout64(unsigned int minor,void __user * arg)710  static 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  
lp_ioctl(struct file * file,unsigned int cmd,unsigned long arg)724  static 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
lp_compat_ioctl(struct file * file,unsigned int cmd,unsigned long arg)752  static 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  
786  static 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  
lp_console_write(struct console * co,const char * s,unsigned count)814  static 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  
868  static 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  
878  static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
879  static char *parport[LP_NO];
880  static bool reset;
881  
882  module_param_array(parport, charp, NULL, 0);
883  module_param(reset, bool, 0);
884  
885  #ifndef MODULE
lp_setup(char * str)886  static 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  
lp_register(int nr,struct parport * port)921  static 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  
lp_attach(struct parport * port)959  static 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  
lp_detach(struct parport * port)993  static 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  
1015  static struct parport_driver lp_driver = {
1016  	.name = "lp",
1017  	.match_port = lp_attach,
1018  	.detach = lp_detach,
1019  	.devmodel = true,
1020  };
1021  
lp_init(void)1022  static 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  
1074  out_class:
1075  	class_unregister(&lp_class);
1076  out_reg:
1077  	unregister_chrdev(LP_MAJOR, "lp");
1078  	return err;
1079  }
1080  
lp_init_module(void)1081  static 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  
lp_cleanup_module(void)1109  static 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);
1122  module_init(lp_init_module);
1123  module_exit(lp_cleanup_module);
1124  
1125  MODULE_ALIAS_CHARDEV_MAJOR(LP_MAJOR);
1126  MODULE_LICENSE("GPL");
1127