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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
lp.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：23k
源码类别：

嵌入式Linux

开发平台：

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)
  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 && (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;
  304. #ifdef LP_STATS
  305. if (jiffies-lp_table[minor].lastcall > LP_TIME(minor))
  306. lp_table[minor].runchars = 0;
  308. lp_table[minor].lastcall = jiffies;
  309. #endif
  311. /* Need to copy the data from user-space. */
  312. if (copy_size > LP_BUFFER_SIZE)
  313. copy_size = LP_BUFFER_SIZE;
  315. if (copy_from_user (kbuf, buf, copy_size))
  316. return -EFAULT;
  318. if (down_interruptible (&lp_table[minor].port_mutex))
  319. return -EINTR;
  321.   /* Claim Parport or sleep until it becomes available
  322.    */
  323. lp_claim_parport_or_block (&lp_table[minor]);
  324. /* Go to the proper mode. */
  325. lp_table[minor].current_mode = lp_negotiate (port, 
  326.      lp_table[minor].best_mode);
  328. parport_set_timeout (lp_table[minor].dev,
  329.      lp_table[minor].timeout);
  331. if ((retv = lp_wait_ready (minor)) == 0)
  332. do {
  333. /* Write the data. */
  334. written = parport_write (port, kbuf, copy_size);
  335. if (written >= 0) {
  336. copy_size -= written;
  337. count -= written;
  338. buf  += written;
  339. retv += written;
  340. }
  342. if (signal_pending (current)) {
  343. if (retv == 0)
  344. retv = -EINTR;
  346. break;
  347. }
  349. if (copy_size > 0) {
  350. /* incomplete write -> check error ! */
  351. int error;
  353. parport_negotiate (lp_table[minor].dev->port, 
  354.    IEEE1284_MODE_COMPAT);
  355. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  357. error = lp_wait_ready (minor);
  359. if (error) {
  360. if (retv == 0)
  361. retv = error;
  362. break;
  363. }
  365. parport_yield_blocking (lp_table[minor].dev);
  366. lp_table[minor].current_mode 
  367.   = lp_negotiate (port, 
  368.   lp_table[minor].best_mode);
  370. } else if (current->need_resched)
  371. schedule ();
  373. if (count) {
  374. copy_size = count;
  375. if (copy_size > LP_BUFFER_SIZE)
  376. copy_size = LP_BUFFER_SIZE;
  378. if (copy_from_user(kbuf, buf, copy_size)) {
  379. if (retv == 0)
  380. retv = -EFAULT;
  381. break;
  382. }
  383. }
  384. } while (count > 0);
  386. if (test_and_clear_bit(LP_PREEMPT_REQUEST, 
  387.        &lp_table[minor].bits)) {
  388. printk(KERN_INFO "lp%d releasing parportn", minor);
  389. parport_negotiate (lp_table[minor].dev->port, 
  390.    IEEE1284_MODE_COMPAT);
  391. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  392. lp_release_parport (&lp_table[minor]);
  393. }
  395. up (&lp_table[minor].port_mutex);
  397.   return retv;
  398. }
  400. #ifdef CONFIG_PARPORT_1284
  402. /* Status readback conforming to ieee1284 */
  403. static ssize_t lp_read(struct file * file, char * buf,
  404.        size_t count, loff_t *ppos)
  405. {
  406. unsigned int minor=MINOR(file->f_dentry->d_inode->i_rdev);
  407. struct parport *port = lp_table[minor].dev->port;
  408. ssize_t retval = 0;
  409. char *kbuf = lp_table[minor].lp_buffer;
  411. if (count > LP_BUFFER_SIZE)
  412. count = LP_BUFFER_SIZE;
  414. if (down_interruptible (&lp_table[minor].port_mutex))
  415. return -EINTR;
  417. lp_claim_parport_or_block (&lp_table[minor]);
  418. retval = parport_read (port, kbuf, count);
  419. lp_release_parport (&lp_table[minor]);
  421. if (retval > 0 && copy_to_user (buf, kbuf, retval))
  422. retval = -EFAULT;
  424. up (&lp_table[minor].port_mutex);
  426. return retval;
  427. }
  429. #endif /* IEEE 1284 support */
  431. static int lp_open(struct inode * inode, struct file * file)
  432. {
  433. unsigned int minor = MINOR(inode->i_rdev);
  435. if (minor >= LP_NO)
  436. return -ENXIO;
  437. if ((LP_F(minor) & LP_EXIST) == 0)
  438. return -ENXIO;
  439. if (test_and_set_bit(LP_BUSY_BIT_POS, &LP_F(minor)))
  440. return -EBUSY;
  442. /* If ABORTOPEN is set and the printer is offline or out of paper,
  443.    we may still want to open it to perform ioctl()s.  Therefore we
  444.    have commandeered O_NONBLOCK, even though it is being used in
  445.    a non-standard manner.  This is strictly a Linux hack, and
  446.    should most likely only ever be used by the tunelp application. */
  447. if ((LP_F(minor) & LP_ABORTOPEN) && !(file->f_flags & O_NONBLOCK)) {
  448. int status;
  449. lp_claim_parport_or_block (&lp_table[minor]);
  450. status = r_str(minor);
  451. lp_release_parport (&lp_table[minor]);
  452. if (status & LP_POUTPA) {
  453. printk(KERN_INFO "lp%d out of papern", minor);
  454. LP_F(minor) &= ~LP_BUSY;
  455. return -ENOSPC;
  456. } else if (!(status & LP_PSELECD)) {
  457. printk(KERN_INFO "lp%d off-linen", minor);
  458. LP_F(minor) &= ~LP_BUSY;
  459. return -EIO;
  460. } else if (!(status & LP_PERRORP)) {
  461. printk(KERN_ERR "lp%d printer errorn", minor);
  462. LP_F(minor) &= ~LP_BUSY;
  463. return -EIO;
  464. }
  465. }
  466. lp_table[minor].lp_buffer = (char *) kmalloc(LP_BUFFER_SIZE, GFP_KERNEL);
  467. if (!lp_table[minor].lp_buffer) {
  468. LP_F(minor) &= ~LP_BUSY;
  469. return -ENOMEM;
  470. }
  471. /* Determine if the peripheral supports ECP mode */
  472. lp_claim_parport_or_block (&lp_table[minor]);
  473. if ( (lp_table[minor].dev->port->modes & PARPORT_MODE_ECP) &&
  474.              !parport_negotiate (lp_table[minor].dev->port, 
  475.                                  IEEE1284_MODE_ECP)) {
  476. printk (KERN_INFO "lp%d: ECP moden", minor);
  477. lp_table[minor].best_mode = IEEE1284_MODE_ECP;
  478. } else {
  479. printk (KERN_INFO "lp%d: compatibility moden", minor);
  480. lp_table[minor].best_mode = IEEE1284_MODE_COMPAT;
  481. }
  482. /* Leave peripheral in compatibility mode */
  483. parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
  484. lp_release_parport (&lp_table[minor]);
  485. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  486. return 0;
  487. }
  489. static int lp_release(struct inode * inode, struct file * file)
  490. {
  491. unsigned int minor = MINOR(inode->i_rdev);
  493. lp_claim_parport_or_block (&lp_table[minor]);
  494. parport_negotiate (lp_table[minor].dev->port, IEEE1284_MODE_COMPAT);
  495. lp_table[minor].current_mode = IEEE1284_MODE_COMPAT;
  496. lp_release_parport (&lp_table[minor]);
  497. lock_kernel();
  498. kfree(lp_table[minor].lp_buffer);
  499. lp_table[minor].lp_buffer = NULL;
  500. LP_F(minor) &= ~LP_BUSY;
  501. unlock_kernel();
  502. return 0;
  503. }
  505. static int lp_ioctl(struct inode *inode, struct file *file,
  506.     unsigned int cmd, unsigned long arg)
  507. {
  508. unsigned int minor = MINOR(inode->i_rdev);
  509. int status;
  510. int retval = 0;
  512. #ifdef LP_DEBUG
  513. printk(KERN_DEBUG "lp%d ioctl, cmd: 0x%x, arg: 0x%lxn", minor, cmd, arg);
  514. #endif
  515. if (minor >= LP_NO)
  516. return -ENODEV;
  517. if ((LP_F(minor) & LP_EXIST) == 0)
  518. return -ENODEV;
  519. switch ( cmd ) {
  520. struct timeval par_timeout;
  521. long to_jiffies;
  523. case LPTIME:
  524. LP_TIME(minor) = arg * HZ/100;
  525. break;
  526. case LPCHAR:
  527. LP_CHAR(minor) = arg;
  528. break;
  529. case LPABORT:
  530. if (arg)
  531. LP_F(minor) |= LP_ABORT;
  532. else
  533. LP_F(minor) &= ~LP_ABORT;
  534. break;
  535. case LPABORTOPEN:
  536. if (arg)
  537. LP_F(minor) |= LP_ABORTOPEN;
  538. else
  539. LP_F(minor) &= ~LP_ABORTOPEN;
  540. break;
  541. case LPCAREFUL:
  542. if (arg)
  543. LP_F(minor) |= LP_CAREFUL;
  544. else
  545. LP_F(minor) &= ~LP_CAREFUL;
  546. break;
  547. case LPWAIT:
  548. LP_WAIT(minor) = arg;
  549. break;
  550. case LPSETIRQ: 
  551. return -EINVAL;
  552. break;
  553. case LPGETIRQ:
  554. if (copy_to_user((int *) arg, &LP_IRQ(minor),
  555. sizeof(int)))
  556. return -EFAULT;
  557. break;
  558. case LPGETSTATUS:
  559. lp_claim_parport_or_block (&lp_table[minor]);
  560. status = r_str(minor);
  561. lp_release_parport (&lp_table[minor]);
  563. if (copy_to_user((int *) arg, &status, sizeof(int)))
  564. return -EFAULT;
  565. break;
  566. case LPRESET:
  567. lp_reset(minor);
  568. break;
  569. #ifdef LP_STATS
  570. case LPGETSTATS:
  571. if (copy_to_user((int *) arg, &LP_STAT(minor),
  572. sizeof(struct lp_stats)))
  573. return -EFAULT;
  574. if (capable(CAP_SYS_ADMIN))
  575. memset(&LP_STAT(minor), 0,
  576. sizeof(struct lp_stats));
  577. break;
  578. #endif
  579.   case LPGETFLAGS:
  580.   status = LP_F(minor);
  581. if (copy_to_user((int *) arg, &status, sizeof(int)))
  582. return -EFAULT;
  583. break;
  585. case LPSETTIMEOUT:
  586. if (copy_from_user (&par_timeout,
  587.     (struct timeval *) arg,
  588.     sizeof (struct timeval))) {
  589. return -EFAULT;
  590. }
  591. /* Convert to jiffies, place in lp_table */
  592. if ((par_timeout.tv_sec < 0) ||
  593.     (par_timeout.tv_usec < 0)) {
  594. return -EINVAL;
  595. }
  596. to_jiffies = ROUND_UP(par_timeout.tv_usec, 1000000/HZ);
  597. to_jiffies += par_timeout.tv_sec * (long) HZ;
  598. if (to_jiffies <= 0) {
  599. return -EINVAL;
  600. }
  601. lp_table[minor].timeout = to_jiffies;
  602. break;
  604. default:
  605. retval = -EINVAL;
  606. }
  607. return retval;
  608. }
  610. static struct file_operations lp_fops = {
  611. owner: THIS_MODULE,
  612. write: lp_write,
  613. ioctl: lp_ioctl,
  614. open: lp_open,
  615. release: lp_release,
  616. #ifdef CONFIG_PARPORT_1284
  617. read: lp_read,
  618. #endif
  619. };
  621. /* --- support for console on the line printer ----------------- */
  623. #ifdef CONFIG_LP_CONSOLE
  625. #define CONSOLE_LP 0
  627. /* If the printer is out of paper, we can either lose the messages or
  628.  * stall until the printer is happy again.  Define CONSOLE_LP_STRICT
  629.  * non-zero to get the latter behaviour. */
  630. #define CONSOLE_LP_STRICT 1
  632. /* The console must be locked when we get here. */
  634. static void lp_console_write (struct console *co, const char *s,
  635.       unsigned count)
  636. {
  637. struct pardevice *dev = lp_table[CONSOLE_LP].dev;
  638. struct parport *port = dev->port;
  639. ssize_t written;
  641. if (parport_claim (dev))
  642. /* Nothing we can do. */
  643. return;
  645. parport_set_timeout (dev, 0);
  647. /* Go to compatibility mode. */
  648. parport_negotiate (port, IEEE1284_MODE_COMPAT);
  650. do {
  651. /* Write the data, converting LF->CRLF as we go. */
  652. ssize_t canwrite = count;
  653. char *lf = memchr (s, 'n', count);
  654. if (lf)
  655. canwrite = lf - s;
  657. if (canwrite > 0) {
  658. written = parport_write (port, s, canwrite);
  660. if (written <= 0)
  661. continue;
  663. s += written;
  664. count -= written;
  665. canwrite -= written;
  666. }
  668. if (lf && canwrite <= 0) {
  669. const char *crlf = "rn";
  670. int i = 2;
  672. /* Dodge the original 'n', and put 'rn' instead. */
  673. s++;
  674. count--;
  675. do {
  676. written = parport_write (port, crlf, i);
  677. if (written > 0)
  678. i -= written, crlf += written;
  679. } while (i > 0 && (CONSOLE_LP_STRICT || written > 0));
  680. }
  681. } while (count > 0 && (CONSOLE_LP_STRICT || written > 0));
  683. parport_release (dev);
  684. }
  686. static kdev_t lp_console_device (struct console *c)
  687. {
  688. return MKDEV(LP_MAJOR, CONSOLE_LP);
  689. }
  691. static struct console lpcons = {
  692. name: "lp",
  693. write: lp_console_write,
  694. device: lp_console_device,
  695. flags: CON_PRINTBUFFER,
  696. };
  698. #endif /* console on line printer */
  700. /* --- initialisation code ------------------------------------- */
  702. static int parport_nr[LP_NO] = { [0 ... LP_NO-1] = LP_PARPORT_UNSPEC };
  703. static char *parport[LP_NO] = { NULL,  };
  704. static int reset = 0;
  706. MODULE_PARM(parport, "1-" __MODULE_STRING(LP_NO) "s");
  707. MODULE_PARM(reset, "i");
  709. #ifndef MODULE
  710. static int __init lp_setup (char *str)
  711. {
  712. static int parport_ptr; // initially zero
  713. int x;
  715. if (get_option (&str, &x)) {
  716. if (x == 0) {
  717. /* disable driver on "lp=" or "lp=0" */
  718. parport_nr[0] = LP_PARPORT_OFF;
  719. } else {
  720. printk(KERN_WARNING "warning: 'lp=0x%x' is deprecated, ignoredn", x);
  721. return 0;
  722. }
  723. } else if (!strncmp(str, "parport", 7)) {
  724. int n = simple_strtoul(str+7, NULL, 10);
  725. if (parport_ptr < LP_NO)
  726. parport_nr[parport_ptr++] = n;
  727. else
  728. printk(KERN_INFO "lp: too many ports, %s ignored.n",
  729.        str);
  730. } else if (!strcmp(str, "auto")) {
  731. parport_nr[0] = LP_PARPORT_AUTO;
  732. } else if (!strcmp(str, "none")) {
  733. parport_nr[parport_ptr++] = LP_PARPORT_NONE;
  734. } else if (!strcmp(str, "reset")) {
  735. reset = 1;
  736. }
  737. return 1;
  738. }
  739. #endif
  741. static int lp_register(int nr, struct parport *port)
  742. {
  743. char name[8];
  745. lp_table[nr].dev = parport_register_device(port, "lp", 
  746.    lp_preempt, NULL, NULL, 0,
  747.    (void *) &lp_table[nr]);
  748. if (lp_table[nr].dev == NULL)
  749. return 1;
  750. lp_table[nr].flags |= LP_EXIST;
  752. if (reset)
  753. lp_reset(nr);
  755. sprintf (name, "%d", nr);
  756. devfs_register (devfs_handle, name,
  757. DEVFS_FL_DEFAULT, LP_MAJOR, nr,
  758. S_IFCHR | S_IRUGO | S_IWUGO,
  759. &lp_fops, NULL);
  761. printk(KERN_INFO "lp%d: using %s (%s).n", nr, port->name, 
  762.        (port->irq == PARPORT_IRQ_NONE)?"polling":"interrupt-driven");
  764. #ifdef CONFIG_LP_CONSOLE
  765. if (!nr) {
  766. if (port->modes & PARPORT_MODE_SAFEININT) {
  767. register_console (&lpcons);
  768. console_registered = port;
  769. printk (KERN_INFO "lp%d: console readyn", CONSOLE_LP);
  770. } else
  771. printk (KERN_ERR "lp%d: cannot run console on %sn",
  772. CONSOLE_LP, port->name);
  773. }
  774. #endif
  776. return 0;
  777. }
  779. static void lp_attach (struct parport *port)
  780. {
  781. unsigned int i;
  783. switch (parport_nr[0])
  784. {
  785. case LP_PARPORT_UNSPEC:
  786. case LP_PARPORT_AUTO:
  787. if (parport_nr[0] == LP_PARPORT_AUTO &&
  788.     port->probe_info[0].class != PARPORT_CLASS_PRINTER)
  789. return;
  790. if (lp_count == LP_NO) {
  791. printk("lp: ignoring parallel port (max. %d)n",LP_NO);
  792. return;
  793. }
  794. if (!lp_register(lp_count, port))
  795. lp_count++;
  796. break;
  798. default:
  799. for (i = 0; i < LP_NO; i++) {
  800. if (port->number == parport_nr[i]) {
  801. if (!lp_register(i, port))
  802. lp_count++;
  803. break;
  804. }
  805. }
  806. break;
  807. }
  808. }
  810. static void lp_detach (struct parport *port)
  811. {
  812. /* Write this some day. */
  813. #ifdef CONFIG_LP_CONSOLE
  814. if (console_registered == port) {
  815. unregister_console (&lpcons);
  816. console_registered = NULL;
  817. }
  818. #endif /* CONFIG_LP_CONSOLE */
  819. }
  821. static struct parport_driver lp_driver = {
  822. "lp",
  823. lp_attach,
  824. lp_detach,
  825. NULL
  826. };
  828. int __init lp_init (void)
  829. {
  830. int i;
  832. if (parport_nr[0] == LP_PARPORT_OFF)
  833. return 0;
  835. for (i = 0; i < LP_NO; i++) {
  836. lp_table[i].dev = NULL;
  837. lp_table[i].flags = 0;
  838. lp_table[i].chars = LP_INIT_CHAR;
  839. lp_table[i].time = LP_INIT_TIME;
  840. lp_table[i].wait = LP_INIT_WAIT;
  841. lp_table[i].lp_buffer = NULL;
  842. #ifdef LP_STATS
  843. lp_table[i].lastcall = 0;
  844. lp_table[i].runchars = 0;
  845. memset (&lp_table[i].stats, 0, sizeof (struct lp_stats));
  846. #endif
  847. lp_table[i].last_error = 0;
  848. init_waitqueue_head (&lp_table[i].waitq);
  849. init_waitqueue_head (&lp_table[i].dataq);
  850. init_MUTEX (&lp_table[i].port_mutex);
  851. lp_table[i].timeout = 10 * HZ;
  852. }
  854. if (devfs_register_chrdev (LP_MAJOR, "lp", &lp_fops)) {
  855. printk ("lp: unable to get major %dn", LP_MAJOR);
  856. return -EIO;
  857. }
  859. devfs_handle = devfs_mk_dir (NULL, "printers", NULL);
  861. if (parport_register_driver (&lp_driver)) {
  862. printk ("lp: unable to register with parportn");
  863. return -EIO;
  864. }
  866. if (!lp_count) {
  867. printk (KERN_INFO "lp: driver loaded but no devices foundn");
  868. #ifndef CONFIG_PARPORT_1284
  869. if (parport_nr[0] == LP_PARPORT_AUTO)
  870. printk (KERN_INFO "lp: (is IEEE 1284 support enabled?)n");
  871. #endif
  872. }
  874. return 0;
  875. }
  877. static int __init lp_init_module (void)
  878. {
  879. if (parport[0]) {
  880. /* The user gave some parameters.  Let's see what they were.  */
  881. if (!strncmp(parport[0], "auto", 4))
  882. parport_nr[0] = LP_PARPORT_AUTO;
  883. else {
  884. int n;
  885. for (n = 0; n < LP_NO && parport[n]; n++) {
  886. if (!strncmp(parport[n], "none", 4))
  887. parport_nr[n] = LP_PARPORT_NONE;
  888. else {
  889. char *ep;
  890. unsigned long r = simple_strtoul(parport[n], &ep, 0);
  891. if (ep != parport[n]) 
  892. parport_nr[n] = r;
  893. else {
  894. printk(KERN_ERR "lp: bad port specifier `%s'n", parport[n]);
  895. return -ENODEV;
  896. }
  897. }
  898. }
  899. }
  900. }
  902. return lp_init();
  903. }
  905. static void lp_cleanup_module (void)
  906. {
  907. unsigned int offset;
  909. parport_unregister_driver (&lp_driver);
  911. #ifdef CONFIG_LP_CONSOLE
  912. unregister_console (&lpcons);
  913. #endif
  915. devfs_unregister (devfs_handle);
  916. devfs_unregister_chrdev(LP_MAJOR, "lp");
  917. for (offset = 0; offset < LP_NO; offset++) {
  918. if (lp_table[offset].dev == NULL)
  919. continue;
  920. parport_unregister_device(lp_table[offset].dev);
  921. }
  922. }
  924. __setup("lp=", lp_setup);
  925. module_init(lp_init_module);
  926. module_exit(lp_cleanup_module);
  928. MODULE_LICENSE("GPL");
  929. EXPORT_NO_SYMBOLS;