开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
lp.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：25k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

lp.c：源码内容
  1. /*
  2.  * Generic parallel printer driver
  3.  *
  4.  * Copyright (C) 1992 by Jim Weigand and Linus Torvalds
  5.  * Copyright (C) 1992,1993 by Michael K. Johnson
  6.  * - Thanks much to Gunter Windau for pointing out to me where the error
  7.  *   checking ought to be.
  8.  * Copyright (C) 1993 by Nigel Gamble (added interrupt code)
  9.  * Copyright (C) 1994 by Alan Cox (Modularised it)
  10.  * LPCAREFUL, LPABORT, LPGETSTATUS added by Chris Metcalf, metcalf@lcs.mit.edu
  11.  * Statistics and support for slow printers by Rob Janssen, rob@knoware.nl
  12.  * "lp=" command line parameters added by Grant Guenther, grant@torque.net
  13.  * lp_read (Status readback) support added by Carsten Gross,
  14.  *                                             carsten@sol.wohnheim.uni-ulm.de
  15.  * Support for parport by Philip Blundell <Philip.Blundell@pobox.com>
  16.  * Parport sharing hacking by Andrea Arcangeli
  17.  * Fixed kernel_(to/from)_user memory copy to check for errors
  18.  *  by Riccardo Facchetti <fizban@tin.it>
  19.  * 22-JAN-1998  Added support for devfs  Richard Gooch <rgooch@atnf.csiro.au>
  20.  * Redesigned interrupt handling for handle printers with buggy handshake
  21.  * by Andrea Arcangeli, 11 May 1998
  22.  * Full efficient handling of printer with buggy irq handshake (now I have
  23.  * understood the meaning of the strange handshake). This is done sending new
  24.  * characters if the interrupt is just happened, even if the printer say to
  25.  * be still BUSY. This is needed at least with Epson Stylus Color. To enable
  26.  * the new TRUST_IRQ mode read the `LP OPTIMIZATION' section below...
  27.  * Fixed the irq on the rising edge of the strobe case.
  28.  * Obsoleted the CAREFUL flag since a printer that doesn' t work with
  29.  * CAREFUL will block a bit after in lp_check_status().
  30.  * Andrea Arcangeli, 15 Oct 1998
  31.  * Obsoleted and removed all the lowlevel stuff implemented in the last
  32.  * month to use the IEEE1284 functions (that handle the _new_ compatibilty
  33.  * mode fine).
  34.  */
  36. /* This driver should, in theory, work with any parallel port that has an
  37.  * appropriate low-level driver; all I/O is done through the parport
  38.  * abstraction layer.
  39.  *
  40.  * If this driver is built into the kernel, you can configure it using the
  41.  * kernel command-line.  For example:
  42.  *
  43.  * lp=parport1,none,parport2 (bind lp0 to parport1, disable lp1 and
  44.  *  bind lp2 to parport2)
  45.  *
  46.  * lp=auto (assign lp devices to all ports that
  47.  *          have printers attached, as determined
  48.  *  by the IEEE-1284 autoprobe)
  49.  * 
  50.  * lp=reset (reset the printer during 
  51.  *  initialisation)
  52.  *
  53.  * lp=off (disable the printer driver entirely)
  54.  *
  55.  * If the driver is loaded as a module, similar functionality is available
  56.  * using module parameters.  The equivalent of the above commands would be:
  57.  *
  58.  * # insmod lp.o parport=1,none,2
  59.  *
  60.  * # insmod lp.o parport=auto
  61.  *
  62.  * # insmod lp.o reset=1
  63.  */
  65. /* COMPATIBILITY WITH OLD KERNELS
  66.  *
  67.  * Under Linux 2.0 and previous versions, lp devices were bound to ports at
  68.  * particular I/O addresses, as follows:
  69.  *
  70.  * lp0 0x3bc
  71.  * lp1 0x378
  72.  * lp2 0x278
  73.  *
  74.  * The new driver, by default, binds lp devices to parport devices as it
  75.  * finds them.  This means that if you only have one port, it will be bound
  76.  * to lp0 regardless of its I/O address.  If you need the old behaviour, you
  77.  * can force it using the parameters described above.
  78.  */
  80. /*
  81.  * The new interrupt handling code take care of the buggy handshake
  82.  * of some HP and Epson printer:
  83.  * ___
  84.  * ACK    _______________    ___________
  85.  *                       |__|
  86.  * ____
  87.  * BUSY   _________              _______
  88.  *                 |____________|
  89.  *
  90.  * I discovered this using the printer scanner that you can find at:
  91.  *
  92.  * ftp://e-mind.com/pub/linux/pscan/
  93.  *
  94.  * 11 May 98, Andrea Arcangeli
  95.  *
  96.  * My printer scanner run on an Epson Stylus Color show that such printer
  97.  * generates the irq on the _rising_ edge of the STROBE. Now lp handle
  98.  * this case fine too.
  99.  *
  100.  * 15 Oct 1998, Andrea Arcangeli
  101.  *
  102.  * The so called `buggy' handshake is really the well documented
  103.  * compatibility mode IEEE1284 handshake. They changed the well known
  104.  * Centronics handshake acking in the middle of busy expecting to not
  105.  * break drivers or legacy application, while they broken linux lp
  106.  * until I fixed it reverse engineering the protocol by hand some
  107.  * month ago...
  108.  *
  109.  *                                     14 Dec 1998, Andrea Arcangeli
  110.  *
  111.  * Copyright (C) 2000 by Tim Waugh (added LPSETTIMEOUT ioctl)
  112.  */
  114. #include <linux/module.h>
  115. #include <linux/init.h>
  117. #include <linux/config.h>
  118. #include <linux/errno.h>
  119. #include <linux/kernel.h>
  120. #include <linux/major.h>
  121. #include <linux/sched.h>
  122. #include <linux/smp_lock.h>
  123. #include <linux/devfs_fs_kernel.h>
  124. #include <linux/slab.h>
  125. #include <linux/fcntl.h>
  126. #include <linux/delay.h>
  127. #include <linux/poll.h>
  128. #include <linux/console.h>
  130. #include <linux/parport.h>
  131. #undef LP_STATS
  132. #include <linux/lp.h>
  134. #include <asm/irq.h>
  135. #include <asm/uaccess.h>
  136. #include <asm/system.h>
  138. /* if you have more than 8 printers, remember to increase LP_NO */
  139. #define LP_NO 8
  141. /* ROUND_UP macro from fs/select.c */
  142. #define ROUND_UP(x,y) (((x)+(y)-1)/(y))
  144. static devfs_handle_t devfs_handle = NULL;
  146. struct lp_struct lp_table[LP_NO];
  148. static unsigned int lp_count = 0;
  150. #ifdef CONFIG_LP_CONSOLE
  151. static struct parport *console_registered; // initially NULL
  152. #endif /* CONFIG_LP_CONSOLE */
  154. #undef LP_DEBUG
  156. /* Bits used to manage claiming the parport device */
  157. #define LP_PREEMPT_REQUEST 1
  158. #define LP_PARPORT_CLAIMED 2
  160. /* --- low-level port access ----------------------------------- */
  162. #define r_dtr(x) (parport_read_data(lp_table[(x)].dev->port))
  163. #define r_str(x) (parport_read_status(lp_table[(x)].dev->port))
  164. #define w_ctr(x,y) do { parport_write_control(lp_table[(x)].dev->port, (y)); } while (0)
  165. #define w_dtr(x,y) do { parport_write_data(lp_table[(x)].dev->port, (y)); } while (0)
  167. /* Claim the parport or block trying unless we've already claimed it */
  168. static void lp_claim_parport_or_block(struct lp_struct *this_lp)
  169. {
  170. if (!test_and_set_bit(LP_PARPORT_CLAIMED, &this_lp->bits)) {
  171. parport_claim_or_block (this_lp->dev);
  172. }
  173. }
  175. /* Claim the parport or block trying unless we've already claimed it */
  176. static void lp_release_parport(struct lp_struct *this_lp)
  177. {
  178. if (test_and_clear_bit(LP_PARPORT_CLAIMED, &this_lp->bits)) {
  179. parport_release (this_lp->dev);
  180. }
  181. }
  185. static int lp_preempt(void *handle)
  186. {
  187. struct lp_struct *this_lp = (struct lp_struct *)handle;
  188. set_bit(LP_PREEMPT_REQUEST, &this_lp->bits);
  189. return (1);
  190. }
  193. /* 
  194.  * Try to negotiate to a new mode; if unsuccessful negotiate to
  195.  * compatibility mode.  Return the mode we ended up in.
  196.  */
  197. static int lp_negotiate(struct parport * port, int mode)
  198. {
  199. if (parport_negotiate (port, mode) != 0) {
  200. mode = IEEE1284_MODE_COMPAT;
  201. parport_negotiate (port, mode);
  202. }
  204. return (mode);
  205. }
  207. static int lp_reset(int minor)
  208. {
  209. int retval;
  210. lp_claim_parport_or_block (&lp_table[minor]);
  211. w_ctr(minor, LP_PSELECP);
  212. udelay (LP_DELAY);
  213. w_ctr(minor, LP_PSELECP | LP_PINITP);
  214. retval = r_str(minor);
  215. lp_release_parport (&lp_table[minor]);
  216. return retval;
  217. }
  219. static void lp_error (int minor)
  220. {
  221. int polling;
  223. if (LP_F(minor) & LP_ABORT)
  224. return;
  226. polling = lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE;
  227. if (polling) lp_release_parport (&lp_table[minor]);
  228. interruptible_sleep_on_timeout (&lp_table[minor].waitq,
  229. LP_TIMEOUT_POLLED);
  230. if (polling) lp_claim_parport_or_block (&lp_table[minor]);
  231. else parport_yield_blocking (lp_table[minor].dev);
  232. }
  234. static int lp_check_status(int minor)
  235. {
  236. int error = 0;
  237. unsigned int last = lp_table[minor].last_error;
  238. unsigned char status = r_str(minor);
  239. if ((status & LP_PERRORP) && !(LP_F(minor) & LP_CAREFUL))
  240. /* No error. */
  241. last = 0;
  242. else if ((status & LP_POUTPA)) {
  243. if (last != LP_POUTPA) {
  244. last = LP_POUTPA;
  245. printk(KERN_INFO "lp%d out of papern", minor);
  246. }
  247. error = -ENOSPC;
  248. } else if (!(status & LP_PSELECD)) {
  249. if (last != LP_PSELECD) {
  250. last = LP_PSELECD;
  251. printk(KERN_INFO "lp%d off-linen", minor);
  252. }
  253. error = -EIO;
  254. } else if (!(status & LP_PERRORP)) {
  255. if (last != LP_PERRORP) {
  256. last = LP_PERRORP;
  257. printk(KERN_INFO "lp%d on firen", minor);
  258. }
  259. error = -EIO;
  260. } else {
  261. last = 0; /* Come here if LP_CAREFUL is set and no
  262.                              errors are reported. */
  263. }
  265. lp_table[minor].last_error = last;
  267. if (last != 0)
  268. lp_error(minor);
  270. return error;
  271. }
  273. static int lp_wait_ready(int minor, int nonblock)
  274. {
  275. int error = 0;
  277. /* If we're not in compatibility mode, we're ready now! */
  278. if (lp_table[minor].current_mode != IEEE1284_MODE_COMPAT) {
  279.   return (0);
  280. }
  282. do {
  283. error = lp_check_status (minor);
  284. if (error && (nonblock || (LP_F(minor) & LP_ABORT)))
  285. break;
  286. if (signal_pending (current)) {
  287. error = -EINTR;
  288. break;
  289. }
  290. } while (error);
  291. return error;
  292. }
  294. static ssize_t lp_write(struct file * file, const char * buf,
  295.         size_t count, loff_t *ppos)
  296. {
  297. unsigned int minor = MINOR(file->f_dentry->d_inode->i_rdev);
  298. struct parport *port = lp_table[minor].dev->port;
  299. char *kbuf = lp_table[minor].lp_buffer;
  300. ssize_t retv = 0;
  301. ssize_t written;
  302. size_t copy_size = count;
  303. int nonblock = ((file->f_flags & O_NONBLOCK) ||
  304. (LP_F(minor) & LP_ABORT));
  306. #ifdef LP_STATS
  307. if (jiffies-lp_table[minor].lastcall > LP_TIME(minor))
  308. lp_table[minor].runchars = 0;
  310. lp_table[minor].lastcall = jiffies;
  311. #endif
  313. /* Need to copy the data from user-space. */
  314. if (copy_size > LP_BUFFER_SIZE)
  315. copy_size = LP_BUFFER_SIZE;
  317. if (copy_from_user (kbuf, buf, copy_size))
  318. return -EFAULT;
  320. if (down_interruptible (&lp_table[minor].port_mutex))
  321. return -EINTR;
  323.   /* Claim Parport or sleep until it becomes available
  324.    */
  325. lp_claim_parport_or_block (&lp_table[minor]);
  326. /* Go to the proper mode. */
  327. lp_table[minor].current_mode = lp_negotiate (port, 
  328.      lp_table[minor].best_mode);
  330. parport_set_timeout (lp_table[minor].dev,
  331.      (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK
  332.       : lp_table[minor].timeout));
  334. if ((retv = lp_wait_ready (minor, nonblock)) == 0)
  335. do {
  336. /* Write the data. */
  337. written = parport_write (port, kbuf, copy_size);
  338. if (written >= 0) {
  339. copy_size -= written;
  340. count -= written;
  341. buf  += written;
  342. retv += written;
  343. }
  345. if (signal_pending (current)) {
  346. if (retv == 0)
  347. retv = -EINTR;
  349. break;
  350. }
  352. if (copy_size > 0) {
  353. /* incomplete write -> check error ! */
  354. int error;
  356. parport_negotiate (lp_table[minor].dev->port, 
  357.    IEEE1284_MODE_COMPAT);
  358. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  360. error = lp_wait_ready (minor, nonblock);
  362. if (error) {
  363. if (retv == 0)
  364. retv = error;
  365. break;
  366. } else if (nonblock) {
  367. if (retv == 0)
  368. retv = -EAGAIN;
  369. break;
  370. }
  372. parport_yield_blocking (lp_table[minor].dev);
  373. lp_table[minor].current_mode 
  374.   = lp_negotiate (port, 
  375.   lp_table[minor].best_mode);
  377. } else if (current->need_resched)
  378. schedule ();
  380. if (count) {
  381. copy_size = count;
  382. if (copy_size > LP_BUFFER_SIZE)
  383. copy_size = LP_BUFFER_SIZE;
  385. if (copy_from_user(kbuf, buf, copy_size)) {
  386. if (retv == 0)
  387. retv = -EFAULT;
  388. break;
  389. }
  390. }
  391. } while (count > 0);
  393. if (test_and_clear_bit(LP_PREEMPT_REQUEST, 
  394.        &lp_table[minor].bits)) {
  395. printk(KERN_INFO "lp%d releasing parportn", minor);
  396. parport_negotiate (lp_table[minor].dev->port, 
  397.    IEEE1284_MODE_COMPAT);
  398. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  399. lp_release_parport (&lp_table[minor]);
  400. }
  402. up (&lp_table[minor].port_mutex);
  404.   return retv;
  405. }
  407. #ifdef CONFIG_PARPORT_1284
  409. /* Status readback conforming to ieee1284 */
  410. static ssize_t lp_read(struct file * file, char * buf,
  411.        size_t count, loff_t *ppos)
  412. {
  413. unsigned int minor=MINOR(file->f_dentry->d_inode->i_rdev);
  414. struct parport *port = lp_table[minor].dev->port;
  415. ssize_t retval = 0;
  416. char *kbuf = lp_table[minor].lp_buffer;
  417. int nonblock = ((file->f_flags & O_NONBLOCK) ||
  418. (LP_F(minor) & LP_ABORT));
  420. if (count > LP_BUFFER_SIZE)
  421. count = LP_BUFFER_SIZE;
  423. if (down_interruptible (&lp_table[minor].port_mutex))
  424. return -EINTR;
  426. lp_claim_parport_or_block (&lp_table[minor]);
  428. parport_set_timeout (lp_table[minor].dev,
  429.      (nonblock ? PARPORT_INACTIVITY_O_NONBLOCK
  430.       : lp_table[minor].timeout));
  432. parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
  433. if (parport_negotiate (lp_table[minor].dev->port,
  434.        IEEE1284_MODE_NIBBLE)) {
  435. retval = -EIO;
  436. goto out;
  437. }
  439. while (retval == 0) {
  440. retval = parport_read (port, kbuf, count);
  442. if (retval > 0)
  443. break;
  445. if (nonblock) {
  446. retval = -EAGAIN;
  447. break;
  448. }
  450. /* Wait for data. */
  452. if (lp_table[minor].dev->port->irq == PARPORT_IRQ_NONE) {
  453. parport_negotiate (lp_table[minor].dev->port,
  454.    IEEE1284_MODE_COMPAT);
  455. lp_error (minor);
  456. if (parport_negotiate (lp_table[minor].dev->port,
  457.        IEEE1284_MODE_NIBBLE)) {
  458. retval = -EIO;
  459. goto out;
  460. }
  461. } else
  462. interruptible_sleep_on_timeout (&lp_table[minor].waitq,
  463. LP_TIMEOUT_POLLED);
  465. if (signal_pending (current)) {
  466. retval = -ERESTARTSYS;
  467. break;
  468. }
  470. if (current->need_resched)
  471. schedule ();
  472. }
  473. parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
  474.  out:
  475. lp_release_parport (&lp_table[minor]);
  477. if (retval > 0 && copy_to_user (buf, kbuf, retval))
  478. retval = -EFAULT;
  480. up (&lp_table[minor].port_mutex);
  482. return retval;
  483. }
  485. #endif /* IEEE 1284 support */
  487. static int lp_open(struct inode * inode, struct file * file)
  488. {
  489. unsigned int minor = MINOR(inode->i_rdev);
  491. if (minor >= LP_NO)
  492. return -ENXIO;
  493. if ((LP_F(minor) & LP_EXIST) == 0)
  494. return -ENXIO;
  495. if (test_and_set_bit(LP_BUSY_BIT_POS, &LP_F(minor)))
  496. return -EBUSY;
  498. /* If ABORTOPEN is set and the printer is offline or out of paper,
  499.    we may still want to open it to perform ioctl()s.  Therefore we
  500.    have commandeered O_NONBLOCK, even though it is being used in
  501.    a non-standard manner.  This is strictly a Linux hack, and
  502.    should most likely only ever be used by the tunelp application. */
  503. if ((LP_F(minor) & LP_ABORTOPEN) && !(file->f_flags & O_NONBLOCK)) {
  504. int status;
  505. lp_claim_parport_or_block (&lp_table[minor]);
  506. status = r_str(minor);
  507. lp_release_parport (&lp_table[minor]);
  508. if (status & LP_POUTPA) {
  509. printk(KERN_INFO "lp%d out of papern", minor);
  510. LP_F(minor) &= ~LP_BUSY;
  511. return -ENOSPC;
  512. } else if (!(status & LP_PSELECD)) {
  513. printk(KERN_INFO "lp%d off-linen", minor);
  514. LP_F(minor) &= ~LP_BUSY;
  515. return -EIO;
  516. } else if (!(status & LP_PERRORP)) {
  517. printk(KERN_ERR "lp%d printer errorn", minor);
  518. LP_F(minor) &= ~LP_BUSY;
  519. return -EIO;
  520. }
  521. }
  522. lp_table[minor].lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
  523. if (!lp_table[minor].lp_buffer) {
  524. LP_F(minor) &= ~LP_BUSY;
  525. return -ENOMEM;
  526. }
  527. /* Determine if the peripheral supports ECP mode */
  528. lp_claim_parport_or_block (&lp_table[minor]);
  529. if ( (lp_table[minor].dev->port->modes & PARPORT_MODE_ECP) &&
  530.              !parport_negotiate (lp_table[minor].dev->port, 
  531.                                  IEEE1284_MODE_ECP)) {
  532. printk (KERN_INFO "lp%d: ECP moden", minor);
  533. lp_table[minor].best_mode = IEEE1284_MODE_ECP;
  534. } else {
  535. lp_table[minor].best_mode = IEEE1284_MODE_COMPAT;
  536. }
  537. /* Leave peripheral in compatibility mode */
  538. parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
  539. lp_release_parport (&lp_table[minor]);
  540. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  541. return 0;
  542. }
  544. static int lp_release(struct inode * inode, struct file * file)
  545. {
  546. unsigned int minor = MINOR(inode->i_rdev);
  548. lp_claim_parport_or_block (&lp_table[minor]);
  549. parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
  550. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  551. lp_release_parport (&lp_table[minor]);
  552. lock_kernel();
  553. kfree(lp_table[minor].lp_buffer);
  554. lp_table[minor].lp_buffer = NULL;
  555. LP_F(minor) &= ~LP_BUSY;
  556. unlock_kernel();
  557. return 0;
  558. }
  560. static int lp_ioctl(struct inode *inode, struct file *file,
  561.     unsigned int cmd, unsigned long arg)
  562. {
  563. unsigned int minor = MINOR(inode->i_rdev);
  564. int status;
  565. int retval = 0;
  567. #ifdef LP_DEBUG
  568. printk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%lxn", minor, cmd, arg);
  569. #endif
  570. if (minor >= LP_NO)
  571. return -ENODEV;
  572. if ((LP_F(minor) & LP_EXIST) == 0)
  573. return -ENODEV;
  574. switch ( cmd ) {
  575. struct timeval par_timeout;
  576. long to_jiffies;
  578. case LPTIME:
  579. LP_TIME(minor) = arg * HZ/100;
  580. break;
  581. case LPCHAR:
  582. LP_CHAR(minor) = arg;
  583. break;
  584. case LPABORT:
  585. if (arg)
  586. LP_F(minor) |= LP_ABORT;
  587. else
  588. LP_F(minor) &= ~LP_ABORT;
  589. break;
  590. case LPABORTOPEN:
  591. if (arg)
  592. LP_F(minor) |= LP_ABORTOPEN;
  593. else
  594. LP_F(minor) &= ~LP_ABORTOPEN;
  595. break;
  596. case LPCAREFUL:
  597. if (arg)
  598. LP_F(minor) |= LP_CAREFUL;
  599. else
  600. LP_F(minor) &= ~LP_CAREFUL;
  601. break;
  602. case LPWAIT:
  603. LP_WAIT(minor) = arg;
  604. break;
  605. case LPSETIRQ: 
  606. return -EINVAL;
  607. break;
  608. case LPGETIRQ:
  609. if (copy_to_user((int *) arg, &LP_IRQ(minor),
  610. sizeof(int)))
  611. return -EFAULT;
  612. break;
  613. case LPGETSTATUS:
  614. lp_claim_parport_or_block (&lp_table[minor]);
  615. status = r_str(minor);
  616. lp_release_parport (&lp_table[minor]);
  618. if (copy_to_user((int *) arg, &status, sizeof(int)))
  619. return -EFAULT;
  620. break;
  621. case LPRESET:
  622. lp_reset(minor);
  623. break;
  624. #ifdef LP_STATS
  625. case LPGETSTATS:
  626. if (copy_to_user((int *) arg, &LP_STAT(minor),
  627. sizeof(struct lp_stats)))
  628. return -EFAULT;
  629. if (capable(CAP_SYS_ADMIN))
  630. memset(&LP_STAT(minor), 0,
  631. sizeof(struct lp_stats));
  632. break;
  633. #endif
  634.   case LPGETFLAGS:
  635.   status = LP_F(minor);
  636. if (copy_to_user((int *) arg, &status, sizeof(int)))
  637. return -EFAULT;
  638. break;
  640. case LPSETTIMEOUT:
  641. if (copy_from_user (&par_timeout,
  642.     (struct timeval *) arg,
  643.     sizeof (struct timeval))) {
  644. return -EFAULT;
  645. }
  646. /* Convert to jiffies, place in lp_table */
  647. if ((par_timeout.tv_sec < 0) ||
  648.     (par_timeout.tv_usec < 0)) {
  649. return -EINVAL;
  650. }
  651. to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
  652. to_jiffies += par_timeout.tv_sec * (long) HZ;
  653. if (to_jiffies <= 0) {
  654. return -EINVAL;
  655. }
  656. lp_table[minor].timeout = to_jiffies;
  657. break;
  659. default:
  660. retval = -EINVAL;
  661. }
  662. return retval;
  663. }
  665. static struct file_operations lp_fops = {
  666. owner: THIS_MODULE,
  667. write: lp_write,
  668. ioctl: lp_ioctl,
  669. open: lp_open,
  670. release: lp_release,
  671. #ifdef CONFIG_PARPORT_1284
  672. read: lp_read,
  673. #endif
  674. };
  676. /* --- support for console on the line printer ----------------- */
  678. #ifdef CONFIG_LP_CONSOLE
  680. #define CONSOLE_LP 0
  682. /* If the printer is out of paper, we can either lose the messages or
  683.  * stall until the printer is happy again.  Define CONSOLE_LP_STRICT
  684.  * non-zero to get the latter behaviour. */
  685. #define CONSOLE_LP_STRICT 1
  687. /* The console must be locked when we get here. */
  689. static void lp_console_write (struct console *co, const char *s,
  690.       unsigned count)
  691. {
  692. struct pardevice *dev = lp_table[CONSOLE_LP].dev;
  693. struct parport *port = dev->port;
  694. ssize_t written;
  696. if (parport_claim (dev))
  697. /* Nothing we can do. */
  698. return;
  700. parport_set_timeout (dev, 0);
  702. /* Go to compatibility mode. */
  703. parport_negotiate (port, IEEE1284_MODE_COMPAT);
  705. do {
  706. /* Write the data, converting LF->CRLF as we go. */
  707. ssize_t canwrite = count;
  708. char *lf = memchr (s, 'n', count);
  709. if (lf)
  710. canwrite = lf - s;
  712. if (canwrite > 0) {
  713. written = parport_write (port, s, canwrite);
  715. if (written <= 0)
  716. continue;
  718. s += written;
  719. count -= written;
  720. canwrite -= written;
  721. }
  723. if (lf && canwrite <= 0) {
  724. const char *crlf = "rn";
  725. int i = 2;
  727. /* Dodge the original 'n', and put 'rn' instead. */
  728. s++;
  729. count--;
  730. do {
  731. written = parport_write (port, crlf, i);
  732. if (written > 0)
  733. i -= written, crlf += written;
  734. } while (i > 0 && (CONSOLE_LP_STRICT || written > 0));
  735. }
  736. } while (count > 0 && (CONSOLE_LP_STRICT || written > 0));
  738. parport_release (dev);
  739. }
  741. static kdev_t lp_console_device (struct console *c)
  742. {
  743. return MKDEV(LP_MAJOR, CONSOLE_LP);
  744. }
  746. static struct console lpcons = {
  747. name: "lp",
  748. write: lp_console_write,
  749. device: lp_console_device,
  750. flags: CON_PRINTBUFFER,
  751. };
  753. #endif /* console on line printer */
  755. /* --- initialisation code ------------------------------------- */
  757. static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
  758. static char *parport[LP_NO] = { NULL,  };
  759. static int reset = 0;
  761. MODULE_PARM(parport, "1-" __MODULE_STRING(LP_NO) "s");
  762. MODULE_PARM(reset, "i");
  764. #ifndef MODULE
  765. static int __init lp_setup (char *str)
  766. {
  767. static int parport_ptr; // initially zero
  768. int x;
  770. if (get_option (&str, &x)) {
  771. if (x == 0) {
  772. /* disable driver on "lp=" or "lp=0" */
  773. parport_nr[0] = LP_PARPORT_OFF;
  774. } else {
  775. printk(KERN_WARNING "warning: 'lp=0x%x' is deprecated, ignoredn", x);
  776. return 0;
  777. }
  778. } else if (!strncmp(str, "parport", 7)) {
  779. int n = simple_strtoul(str+7, NULL, 10);
  780. if (parport_ptr < LP_NO)
  781. parport_nr[parport_ptr++] = n;
  782. else
  783. printk(KERN_INFO "lp: too many ports, %s ignored.n",
  784.        str);
  785. } else if (!strcmp(str, "auto")) {
  786. parport_nr[0] = LP_PARPORT_AUTO;
  787. } else if (!strcmp(str, "none")) {
  788. parport_nr[parport_ptr++] = LP_PARPORT_NONE;
  789. } else if (!strcmp(str, "reset")) {
  790. reset = 1;
  791. }
  792. return 1;
  793. }
  794. #endif
  796. static int lp_register(int nr, struct parport *port)
  797. {
  798. char name[8];
  800. lp_table[nr].dev = parport_register_device(port, "lp", 
  801.    lp_preempt, NULL, NULL, 0,
  802.    (void *) &lp_table[nr]);
  803. if (lp_table[nr].dev == NULL)
  804. return 1;
  805. lp_table[nr].flags |= LP_EXIST;
  807. if (reset)
  808. lp_reset(nr);
  810. sprintf (name, "%d", nr);
  811. devfs_register (devfs_handle, name,
  812. DEVFS_FL_DEFAULT, LP_MAJOR, nr,
  813. S_IFCHR | S_IRUGO | S_IWUGO,
  814. &lp_fops, NULL);
  816. printk(KERN_INFO "lp%d: using %s (%s).n", nr, port->name, 
  817.        (port->irq == PARPORT_IRQ_NONE)?"polling":"interrupt-driven");
  819. #ifdef CONFIG_LP_CONSOLE
  820. if (!nr) {
  821. if (port->modes & PARPORT_MODE_SAFEININT) {
  822. register_console (&lpcons);
  823. console_registered = port;
  824. printk (KERN_INFO "lp%d: console readyn", CONSOLE_LP);
  825. } else
  826. printk (KERN_ERR "lp%d: cannot run console on %sn",
  827. CONSOLE_LP, port->name);
  828. }
  829. #endif
  831. return 0;
  832. }
  834. static void lp_attach (struct parport *port)
  835. {
  836. unsigned int i;
  838. switch (parport_nr[0])
  839. {
  840. case LP_PARPORT_UNSPEC:
  841. case LP_PARPORT_AUTO:
  842. if (parport_nr[0] == LP_PARPORT_AUTO &&
  843.     port->probe_info[0].class != PARPORT_CLASS_PRINTER)
  844. return;
  845. if (lp_count == LP_NO) {
  846. printk("lp: ignoring parallel port (max. %d)n",LP_NO);
  847. return;
  848. }
  849. if (!lp_register(lp_count, port))
  850. lp_count++;
  851. break;
  853. default:
  854. for (i = 0; i < LP_NO; i++) {
  855. if (port->number == parport_nr[i]) {
  856. if (!lp_register(i, port))
  857. lp_count++;
  858. break;
  859. }
  860. }
  861. break;
  862. }
  863. }
  865. static void lp_detach (struct parport *port)
  866. {
  867. /* Write this some day. */
  868. #ifdef CONFIG_LP_CONSOLE
  869. if (console_registered == port) {
  870. unregister_console (&lpcons);
  871. console_registered = NULL;
  872. }
  873. #endif /* CONFIG_LP_CONSOLE */
  874. }
  876. static struct parport_driver lp_driver = {
  877. "lp",
  878. lp_attach,
  879. lp_detach,
  880. NULL
  881. };
  883. int __init lp_init (void)
  884. {
  885. int i;
  887. if (parport_nr[0] == LP_PARPORT_OFF)
  888. return 0;
  890. for (i = 0; i < LP_NO; i++) {
  891. lp_table[i].dev = NULL;
  892. lp_table[i].flags = 0;
  893. lp_table[i].chars = LP_INIT_CHAR;
  894. lp_table[i].time = LP_INIT_TIME;
  895. lp_table[i].wait = LP_INIT_WAIT;
  896. lp_table[i].lp_buffer = NULL;
  897. #ifdef LP_STATS
  898. lp_table[i].lastcall = 0;
  899. lp_table[i].runchars = 0;
  900. memset (&lp_table[i].stats, 0, sizeof (struct lp_stats));
  901. #endif
  902. lp_table[i].last_error = 0;
  903. init_waitqueue_head (&lp_table[i].waitq);
  904. init_waitqueue_head (&lp_table[i].dataq);
  905. init_MUTEX (&lp_table[i].port_mutex);
  906. lp_table[i].timeout = 10 * HZ;
  907. }
  909. if (devfs_register_chrdev (LP_MAJOR, "lp", &lp_fops)) {
  910. printk ("lp: unable to get major %dn", LP_MAJOR);
  911. return -EIO;
  912. }
  914. devfs_handle = devfs_mk_dir (NULL, "printers", NULL);
  916. if (parport_register_driver (&lp_driver)) {
  917. printk ("lp: unable to register with parportn");
  918. return -EIO;
  919. }
  921. if (!lp_count) {
  922. printk (KERN_INFO "lp: driver loaded but no devices foundn");
  923. #ifndef CONFIG_PARPORT_1284
  924. if (parport_nr[0] == LP_PARPORT_AUTO)
  925. printk (KERN_INFO "lp: (is IEEE 1284 support enabled?)n");
  926. #endif
  927. }
  929. return 0;
  930. }
  932. static int __init lp_init_module (void)
  933. {
  934. if (parport[0]) {
  935. /* The user gave some parameters.  Let's see what they were.  */
  936. if (!strncmp(parport[0], "auto", 4))
  937. parport_nr[0] = LP_PARPORT_AUTO;
  938. else {
  939. int n;
  940. for (n = 0; n < LP_NO && parport[n]; n++) {
  941. if (!strncmp(parport[n], "none", 4))
  942. parport_nr[n] = LP_PARPORT_NONE;
  943. else {
  944. char *ep;
  945. unsigned long r = simple_strtoul(parport[n], &ep, 0);
  946. if (ep != parport[n]) 
  947. parport_nr[n] = r;
  948. else {
  949. printk(KERN_ERR "lp: bad port specifier `%s'n", parport[n]);
  950. return -ENODEV;
  951. }
  952. }
  953. }
  954. }
  955. }
  957. return lp_init();
  958. }
  960. static void lp_cleanup_module (void)
  961. {
  962. unsigned int offset;
  964. parport_unregister_driver (&lp_driver);
  966. #ifdef CONFIG_LP_CONSOLE
  967. unregister_console (&lpcons);
  968. #endif
  970. devfs_unregister (devfs_handle);
  971. devfs_unregister_chrdev(LP_MAJOR, "lp");
  972. for (offset = 0; offset < LP_NO; offset++) {
  973. if (lp_table[offset].dev == NULL)
  974. continue;
  975. parport_unregister_device(lp_table[offset].dev);
  976. }
  977. }
  979. __setup("lp=", lp_setup);
  980. module_init(lp_init_module);
  981. module_exit(lp_cleanup_module);
  983. MODULE_LICENSE("GPL");
  984. EXPORT_NO_SYMBOLS;