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

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

Linux/Unix编程

开发平台：

Unix_Linux

printer.c：源码内容
  1. /*
  2.  * printer.c  Version 0.11
  3.  *
  4.  * Copyright (c) 1999 Michael Gee <michael@linuxspecific.com>
  5.  * Copyright (c) 1999 Pavel Machek <pavel@suse.cz>
  6.  * Copyright (c) 2000 Randy Dunlap <randy.dunlap@intel.com>
  7.  * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
  8.  # Copyright (c) 2001 Pete Zaitcev <zaitcev@redhat.com>
  9.  # Copyright (c) 2001 David Paschal <paschal@rcsis.com>
  10.  *
  11.  * USB Printer Device Class driver for USB printers and printer cables
  12.  *
  13.  * Sponsored by SuSE
  14.  *
  15.  * ChangeLog:
  16.  * v0.1 - thorough cleaning, URBification, almost a rewrite
  17.  * v0.2 - some more cleanups
  18.  * v0.3 - cleaner again, waitqueue fixes
  19.  * v0.4 - fixes in unidirectional mode
  20.  * v0.5 - add DEVICE_ID string support
  21.  * v0.6 - never time out
  22.  * v0.7 - fixed bulk-IN read and poll (David Paschal)
  23.  * v0.8 - add devfs support
  24.  * v0.9 - fix unplug-while-open paths
  25.  * v0.10 - add proto_bias option (Pete Zaitcev)
  26.  * v0.11 - add hpoj.sourceforge.net ioctls (David Paschal)
  27.  */
  29. /*
  30.  * This program is free software; you can redistribute it and/or modify
  31.  * it under the terms of the GNU General Public License as published by
  32.  * the Free Software Foundation; either version 2 of the License, or
  33.  * (at your option) any later version.
  34.  *
  35.  * This program is distributed in the hope that it will be useful,
  36.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  37.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  38.  * GNU General Public License for more details.
  39.  *
  40.  * You should have received a copy of the GNU General Public License
  41.  * along with this program; if not, write to the Free Software
  42.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  43.  */
  45. #include <linux/module.h>
  46. #include <linux/kernel.h>
  47. #include <linux/sched.h>
  48. #include <linux/smp_lock.h>
  49. #include <linux/signal.h>
  50. #include <linux/poll.h>
  51. #include <linux/init.h>
  52. #include <linux/slab.h>
  53. #include <linux/lp.h>
  54. #include <linux/devfs_fs_kernel.h>
  55. #undef DEBUG
  56. #include <linux/usb.h>
  58. /*
  59.  * Version Information
  60.  */
  61. #define DRIVER_VERSION "v0.11"
  62. #define DRIVER_AUTHOR "Michael Gee, Pavel Machek, Vojtech Pavlik, Randy Dunlap, Pete Zaitcev, David Paschal"
  63. #define DRIVER_DESC "USB Printer Device Class driver"
  65. #define USBLP_BUF_SIZE 8192
  66. #define DEVICE_ID_SIZE 1024
  68. /* ioctls: */
  69. #define LPGETSTATUS 0x060b /* same as in drivers/char/lp.c */
  70. #define IOCNR_GET_DEVICE_ID 1
  71. #define IOCNR_GET_PROTOCOLS 2
  72. #define IOCNR_SET_PROTOCOL 3
  73. #define IOCNR_HP_SET_CHANNEL 4
  74. #define IOCNR_GET_BUS_ADDRESS 5
  75. #define IOCNR_GET_VID_PID 6
  76. /* Get device_id string: */
  77. #define LPIOC_GET_DEVICE_ID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_DEVICE_ID, len)
  78. /* The following ioctls were added for http://hpoj.sourceforge.net: */
  79. /* Get two-int array:
  80.  * [0]=current protocol (1=7/1/1, 2=7/1/2, 3=7/1/3),
  81.  * [1]=supported protocol mask (mask&(1<<n)!=0 means 7/1/n supported): */
  82. #define LPIOC_GET_PROTOCOLS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_PROTOCOLS, len)
  83. /* Set protocol (arg: 1=7/1/1, 2=7/1/2, 3=7/1/3): */
  84. #define LPIOC_SET_PROTOCOL _IOC(_IOC_WRITE, 'P', IOCNR_SET_PROTOCOL, 0)
  85. /* Set channel number (HP Vendor-specific command): */
  86. #define LPIOC_HP_SET_CHANNEL _IOC(_IOC_WRITE, 'P', IOCNR_HP_SET_CHANNEL, 0)
  87. /* Get two-int array: [0]=bus number, [1]=device address: */
  88. #define LPIOC_GET_BUS_ADDRESS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_BUS_ADDRESS, len)
  89. /* Get two-int array: [0]=vendor ID, [1]=product ID: */
  90. #define LPIOC_GET_VID_PID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_VID_PID, len)
  92. /*
  93.  * A DEVICE_ID string may include the printer's serial number.
  94.  * It should end with a semi-colon (';').
  95.  * An example from an HP 970C DeskJet printer is (this is one long string,
  96.  * with the serial number changed):
  97. MFG:HEWLETT-PACKARD;MDL:DESKJET 970C;CMD:MLC,PCL,PML;CLASS:PRINTER;DESCRIPTION:Hewlett-Packard DeskJet 970C;SERN:US970CSEPROF;VSTATUS:$HB0$NC0,ff,DN,IDLE,CUT,K1,C0,DP,NR,KP000,CP027;VP:0800,FL,B0;VJ:                    ;
  98.  */
  100. /*
  101.  * USB Printer Requests
  102.  */
  104. #define USBLP_REQ_GET_ID 0x00
  105. #define USBLP_REQ_GET_STATUS 0x01
  106. #define USBLP_REQ_RESET 0x02
  107. #define USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST 0x00 /* HP Vendor-specific */
  109. #define USBLP_MINORS 16
  110. #define USBLP_MINOR_BASE 0
  112. #define USBLP_WRITE_TIMEOUT (5*HZ) /* 5 seconds */
  114. #define USBLP_FIRST_PROTOCOL 1
  115. #define USBLP_LAST_PROTOCOL 3
  116. #define USBLP_MAX_PROTOCOLS (USBLP_LAST_PROTOCOL+1)
  118. struct usblp {
  119. struct usb_device  *dev; /* USB device */
  120. devfs_handle_t devfs; /* devfs device */
  121. struct semaphore sem; /* locks this struct, especially "dev" */
  122. char *buf; /* writeurb.transfer_buffer */
  123. struct urb readurb, writeurb; /* The urbs */
  124. wait_queue_head_t wait; /* Zzzzz ... */
  125. int readcount; /* Counter for reads */
  126. int ifnum; /* Interface number */
  127. /* Alternate-setting numbers and endpoints for each protocol
  128.  * (7/1/{index=1,2,3}) that the device supports: */
  129. struct {
  130. int alt_setting;
  131. struct usb_endpoint_descriptor *epwrite;
  132. struct usb_endpoint_descriptor *epread;
  133. } protocol[USBLP_MAX_PROTOCOLS];
  134. int current_protocol;
  135. int minor; /* minor number of device */
  136. unsigned int quirks; /* quirks flags */
  137. unsigned char used; /* True if open */
  138. unsigned char bidir; /* interface is bidirectional */
  139. unsigned char *device_id_string; /* IEEE 1284 DEVICE ID string (ptr) */
  140. /* first 2 bytes are (big-endian) length */
  141. };
  143. #ifdef DEBUG
  144. static void usblp_dump(struct usblp *usblp) {
  145. int p;
  147. dbg("usblp=0x%p", usblp);
  148. dbg("dev=0x%p", usblp->dev);
  149. dbg("devfs=0x%p", usblp->devfs);
  150. dbg("buf=0x%p", usblp->buf);
  151. dbg("readcount=%d", usblp->readcount);
  152. dbg("ifnum=%d", usblp->ifnum);
  153.     for (p = USBLP_FIRST_PROTOCOL; p <= USBLP_LAST_PROTOCOL; p++) {
  154. dbg("protocol[%d].alt_setting=%d", p, usblp->protocol[p].alt_setting);
  155. dbg("protocol[%d].epwrite=%p", p, usblp->protocol[p].epwrite);
  156. dbg("protocol[%d].epread=%p", p, usblp->protocol[p].epread);
  157.     }
  158. dbg("current_protocol=%d", usblp->current_protocol);
  159. dbg("minor=%d", usblp->minor);
  160. dbg("quirks=%d", usblp->quirks);
  161. dbg("used=%d", usblp->used);
  162. dbg("bidir=%d", usblp->bidir);
  163. dbg("device_id_string="%s"",
  164. usblp->device_id_string ?
  165. usblp->device_id_string + 2 :
  166. (unsigned char *)"(null)");
  167. }
  168. #endif
  170. extern devfs_handle_t usb_devfs_handle; /* /dev/usb dir. */
  172. static struct usblp *usblp_table[USBLP_MINORS];
  174. /* Quirks: various printer quirks are handled by this table & its flags. */
  176. struct quirk_printer_struct {
  177. __u16 vendorId;
  178. __u16 productId;
  179. unsigned int quirks;
  180. };
  182. #define USBLP_QUIRK_BIDIR 0x1 /* reports bidir but requires unidirectional mode (no INs/reads) */
  183. #define USBLP_QUIRK_USB_INIT 0x2 /* needs vendor USB init string */
  185. static struct quirk_printer_struct quirk_printers[] = {
  186. { 0x03f0, 0x0004, USBLP_QUIRK_BIDIR }, /* HP DeskJet 895C */
  187. { 0x03f0, 0x0104, USBLP_QUIRK_BIDIR }, /* HP DeskJet 880C */
  188. { 0x03f0, 0x0204, USBLP_QUIRK_BIDIR }, /* HP DeskJet 815C */
  189. { 0x03f0, 0x0304, USBLP_QUIRK_BIDIR }, /* HP DeskJet 810C/812C */
  190. { 0x03f0, 0x0404, USBLP_QUIRK_BIDIR }, /* HP DeskJet 830C */
  191. { 0x03f0, 0x0504, USBLP_QUIRK_BIDIR }, /* HP DeskJet 885C */
  192. { 0x03f0, 0x0604, USBLP_QUIRK_BIDIR }, /* HP DeskJet 840C */   
  193. { 0x03f0, 0x0804, USBLP_QUIRK_BIDIR }, /* HP DeskJet 816C */   
  194. { 0x03f0, 0x1104, USBLP_QUIRK_BIDIR }, /* HP Deskjet 959C */
  195. { 0x0409, 0xefbe, USBLP_QUIRK_BIDIR }, /* NEC Picty900 (HP OEM) */
  196. { 0x0409, 0xbef4, USBLP_QUIRK_BIDIR }, /* NEC Picty760 (HP OEM) */
  197. { 0x0409, 0xf0be, USBLP_QUIRK_BIDIR }, /* NEC Picty920 (HP OEM) */
  198. { 0x0409, 0xf1be, USBLP_QUIRK_BIDIR }, /* NEC Picty800 (HP OEM) */
  199. { 0, 0 }
  200. };
  202. static int usblp_select_alts(struct usblp *usblp);
  203. static int usblp_set_protocol(struct usblp *usblp, int protocol);
  204. static int usblp_cache_device_id_string(struct usblp *usblp);
  207. /*
  208.  * Functions for usblp control messages.
  209.  */
  211. static int usblp_ctrl_msg(struct usblp *usblp, int request, int type, int dir, int recip, int value, void *buf, int len)
  212. {
  213. int retval = usb_control_msg(usblp->dev,
  214. dir ? usb_rcvctrlpipe(usblp->dev, 0) : usb_sndctrlpipe(usblp->dev, 0),
  215. request, type | dir | recip, value, usblp->ifnum, buf, len, USBLP_WRITE_TIMEOUT);
  216. dbg("usblp_control_msg: rq: 0x%02x dir: %d recip: %d value: %d len: %#x result: %d",
  217. request, !!dir, recip, value, len, retval);
  218. return retval < 0 ? retval : 0;
  219. }
  221. #define usblp_read_status(usblp, status)
  222. usblp_ctrl_msg(usblp, USBLP_REQ_GET_STATUS, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, 0, status, 1)
  223. #define usblp_get_id(usblp, config, id, maxlen)
  224. usblp_ctrl_msg(usblp, USBLP_REQ_GET_ID, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, config, id, maxlen)
  225. #define usblp_reset(usblp)
  226. usblp_ctrl_msg(usblp, USBLP_REQ_RESET, USB_TYPE_CLASS, USB_DIR_OUT, USB_RECIP_OTHER, 0, NULL, 0)
  228. #define usblp_hp_channel_change_request(usblp, channel, buffer) 
  229. usblp_ctrl_msg(usblp, USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST, USB_TYPE_VENDOR, USB_DIR_IN, USB_RECIP_INTERFACE, channel, buffer, 1)
  231. /*
  232.  * See the description for usblp_select_alts() below for the usage
  233.  * explanation.  Look into your /proc/bus/usb/devices and dmesg in
  234.  * case of any trouble.
  235.  */
  236. static int proto_bias = -1;
  238. /*
  239.  * URB callback.
  240.  */
  242. static void usblp_bulk(struct urb *urb)
  243. {
  244. struct usblp *usblp = urb->context;
  246. if (!usblp || !usblp->dev || !usblp->used)
  247. return;
  249. if (urb->status)
  250. warn("usblp%d: nonzero read/write bulk status received: %d",
  251. usblp->minor, urb->status);
  253. wake_up_interruptible(&usblp->wait);
  254. }
  256. /*
  257.  * Get and print printer errors.
  258.  */
  260. static char *usblp_messages[] = { "ok", "out of paper", "off-line", "unknown error" };
  262. static int usblp_check_status(struct usblp *usblp, int err)
  263. {
  264. unsigned char status, newerr = 0;
  265. int error;
  267. error = usblp_read_status (usblp, &status);
  268. if (error < 0) {
  269. err("usblp%d: error %d reading printer status",
  270. usblp->minor, error);
  271. return 0;
  272. }
  274. if (~status & LP_PERRORP) {
  275. newerr = 3;
  276. if (status & LP_POUTPA) newerr = 1;
  277. if (~status & LP_PSELECD) newerr = 2;
  278. }
  280. if (newerr != err)
  281. info("usblp%d: %s", usblp->minor, usblp_messages[newerr]);
  283. return newerr;
  284. }
  286. /*
  287.  * File op functions.
  288.  */
  290. static int usblp_open(struct inode *inode, struct file *file)
  291. {
  292. int minor = MINOR(inode->i_rdev) - USBLP_MINOR_BASE;
  293. struct usblp *usblp;
  294. int retval;
  296. if (minor < 0 || minor >= USBLP_MINORS)
  297. return -ENODEV;
  299. lock_kernel();
  300. usblp  = usblp_table[minor];
  302. retval = -ENODEV;
  303. if (!usblp || !usblp->dev)
  304. goto out;
  306. retval = -EBUSY;
  307. if (usblp->used)
  308. goto out;
  310. /*
  311.  * TODO: need to implement LP_ABORTOPEN + O_NONBLOCK as in drivers/char/lp.c ???
  312.  * This is #if 0-ed because we *don't* want to fail an open
  313.  * just because the printer is off-line.
  314.  */
  315. #if 0
  316. if ((retval = usblp_check_status(usblp, 0))) {
  317. retval = retval > 1 ? -EIO : -ENOSPC;
  318. goto out;
  319. }
  320. #else
  321. retval = 0;
  322. #endif
  324. usblp->used = 1;
  325. file->private_data = usblp;
  327. usblp->writeurb.transfer_buffer_length = 0;
  328. usblp->writeurb.status = 0;
  330. if (usblp->bidir) {
  331. usblp->readcount = 0;
  332. usblp->readurb.dev = usblp->dev;
  333. if (usb_submit_urb(&usblp->readurb) < 0) {
  334. retval = -EIO;
  335. usblp->used = 0;
  336. file->private_data = NULL;
  337. }
  338. }
  339. out:
  340. unlock_kernel();
  341. return retval;
  342. }
  344. static void usblp_cleanup (struct usblp *usblp)
  345. {
  346. devfs_unregister (usblp->devfs);
  347. usblp_table [usblp->minor] = NULL;
  348. info("usblp%d: removed", usblp->minor);
  350. kfree (usblp->writeurb.transfer_buffer);
  351. kfree (usblp->device_id_string);
  352. kfree (usblp);
  353. }
  355. static void usblp_unlink_urbs(struct usblp *usblp)
  356. {
  357. usb_unlink_urb(&usblp->writeurb);
  358. if (usblp->bidir)
  359. usb_unlink_urb(&usblp->readurb);
  360. }
  362. static int usblp_release(struct inode *inode, struct file *file)
  363. {
  364. struct usblp *usblp = file->private_data;
  366. down (&usblp->sem);
  367. lock_kernel();
  368. usblp->used = 0;
  369. if (usblp->dev) {
  370. usblp_unlink_urbs(usblp);
  371. up(&usblp->sem);
  372. } else  /* finish cleanup from disconnect */
  373. usblp_cleanup (usblp);
  374. unlock_kernel();
  375. return 0;
  376. }
  378. /* No kernel lock - fine */
  379. static unsigned int usblp_poll(struct file *file, struct poll_table_struct *wait)
  380. {
  381. struct usblp *usblp = file->private_data;
  382. poll_wait(file, &usblp->wait, wait);
  383.   return ((!usblp->bidir || usblp->readurb.status  == -EINPROGRESS) ? 0 : POLLIN  | POLLRDNORM)
  384.          | (usblp->writeurb.status == -EINPROGRESS  ? 0 : POLLOUT | POLLWRNORM);
  385. }
  387. static int usblp_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  388. {
  389. struct usblp *usblp = file->private_data;
  390. int length, err, i;
  391. unsigned char lpstatus, newChannel;
  392. int status;
  393. int twoints[2];
  394. int retval = 0;
  396. down (&usblp->sem);
  397. if (!usblp->dev) {
  398. retval = -ENODEV;
  399. goto done;
  400. }
  402. if (_IOC_TYPE(cmd) == 'P') /* new-style ioctl number */
  404. switch (_IOC_NR(cmd)) {
  406. case IOCNR_GET_DEVICE_ID: /* get the DEVICE_ID string */
  407. if (_IOC_DIR(cmd) != _IOC_READ) {
  408. retval = -EINVAL;
  409. goto done;
  410. }
  412. length = usblp_cache_device_id_string(usblp);
  413. if (length < 0) {
  414. retval = length;
  415. goto done;
  416. }
  417. if (length > _IOC_SIZE(cmd))
  418. length = _IOC_SIZE(cmd); /* truncate */
  420. if (copy_to_user((unsigned char *) arg,
  421. usblp->device_id_string,
  422. (unsigned long) length)) {
  423. retval = -EFAULT;
  424. goto done;
  425. }
  427. break;
  429. case IOCNR_GET_PROTOCOLS:
  430. if (_IOC_DIR(cmd) != _IOC_READ ||
  431.     _IOC_SIZE(cmd) < sizeof(twoints)) {
  432. retval = -EINVAL;
  433. goto done;
  434. }
  436. twoints[0] = usblp->current_protocol;
  437. twoints[1] = 0;
  438. for (i = USBLP_FIRST_PROTOCOL;
  439.      i <= USBLP_LAST_PROTOCOL; i++) {
  440. if (usblp->protocol[i].alt_setting >= 0)
  441. twoints[1] |= (1<<i);
  442. }
  444. if (copy_to_user((unsigned char *)arg,
  445. (unsigned char *)twoints,
  446. sizeof(twoints))) {
  447. retval = -EFAULT;
  448. goto done;
  449. }
  451. break;
  453. case IOCNR_SET_PROTOCOL:
  454. if (_IOC_DIR(cmd) != _IOC_WRITE) {
  455. retval = -EINVAL;
  456. goto done;
  457. }
  459. #ifdef DEBUG
  460. if (arg == -10) {
  461. usblp_dump(usblp);
  462. break;
  463. }
  464. #endif
  466. usblp_unlink_urbs(usblp);
  467. retval = usblp_set_protocol(usblp, arg);
  468. if (retval < 0) {
  469. usblp_set_protocol(usblp,
  470. usblp->current_protocol);
  471. }
  472. break;
  474. case IOCNR_HP_SET_CHANNEL:
  475. if (_IOC_DIR(cmd) != _IOC_WRITE ||
  476.     usblp->dev->descriptor.idVendor != 0x03F0 ||
  477.     usblp->quirks & USBLP_QUIRK_BIDIR) {
  478. retval = -EINVAL;
  479. goto done;
  480. }
  482. err = usblp_hp_channel_change_request(usblp,
  483. arg, &newChannel);
  484. if (err < 0) {
  485. err("usblp%d: error = %d setting "
  486. "HP channel",
  487. usblp->minor, err);
  488. retval = -EIO;
  489. goto done;
  490. }
  492. dbg("usblp%d requested/got HP channel %ld/%d",
  493. usblp->minor, arg, newChannel);
  494. break;
  496. case IOCNR_GET_BUS_ADDRESS:
  497. if (_IOC_DIR(cmd) != _IOC_READ ||
  498.     _IOC_SIZE(cmd) < sizeof(twoints)) {
  499. retval = -EINVAL;
  500. goto done;
  501. }
  503. twoints[0] = usblp->dev->bus->busnum;
  504. twoints[1] = usblp->dev->devnum;
  505. if (copy_to_user((unsigned char *)arg,
  506. (unsigned char *)twoints,
  507. sizeof(twoints))) {
  508. retval = -EFAULT;
  509. goto done;
  510. }
  512. dbg("usblp%d is bus=%d, device=%d",
  513. usblp->minor, twoints[0], twoints[1]);
  514. break;
  516. case IOCNR_GET_VID_PID:
  517. if (_IOC_DIR(cmd) != _IOC_READ ||
  518.     _IOC_SIZE(cmd) < sizeof(twoints)) {
  519. retval = -EINVAL;
  520. goto done;
  521. }
  523. twoints[0] = usblp->dev->descriptor.idVendor;
  524. twoints[1] = usblp->dev->descriptor.idProduct;
  525. if (copy_to_user((unsigned char *)arg,
  526. (unsigned char *)twoints,
  527. sizeof(twoints))) {
  528. retval = -EFAULT;
  529. goto done;
  530. }
  532. dbg("usblp%d is VID=0x%4.4X, PID=0x%4.4X",
  533. usblp->minor, twoints[0], twoints[1]);
  534. break;
  536. default:
  537. retval = -EINVAL;
  538. }
  539. else /* old-style ioctl value */
  540. switch (cmd) {
  542. case LPGETSTATUS:
  543. if (usblp_read_status(usblp, &lpstatus)) {
  544. err("usblp%d: failed reading printer status", usblp->minor);
  545. retval = -EIO;
  546. goto done;
  547. }
  548. status = lpstatus;
  549. if (copy_to_user ((int *)arg, &status, sizeof(int)))
  550. retval = -EFAULT;
  551. break;
  553. default:
  554. retval = -EINVAL;
  555. }
  557. done:
  558. up (&usblp->sem);
  559. return retval;
  560. }
  562. static ssize_t usblp_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
  563. {
  564. struct usblp *usblp = file->private_data;
  565. int timeout, err = 0;
  566. size_t writecount = 0;
  568. while (writecount < count) {
  570. // FIXME:  only use urb->status inside completion
  571. // callbacks; this way is racey...
  572. if (usblp->writeurb.status == -EINPROGRESS) {
  574. if (file->f_flags & O_NONBLOCK)
  575. return -EAGAIN;
  577. timeout = USBLP_WRITE_TIMEOUT;
  578. while (timeout && usblp->writeurb.status == -EINPROGRESS) {
  580. if (signal_pending(current))
  581. return writecount ? writecount : -EINTR;
  583. timeout = interruptible_sleep_on_timeout(&usblp->wait, timeout);
  584. }
  585. }
  587. down (&usblp->sem);
  588. if (!usblp->dev) {
  589. up (&usblp->sem);
  590. return -ENODEV;
  591. }
  593. if (usblp->writeurb.status != 0) {
  594. if (usblp->quirks & USBLP_QUIRK_BIDIR) {
  595. if (usblp->writeurb.status != -EINPROGRESS)
  596. err("usblp%d: error %d writing to printer",
  597. usblp->minor, usblp->writeurb.status);
  598. err = usblp->writeurb.status;
  599. } else
  600. err = usblp_check_status(usblp, err);
  601. up (&usblp->sem);
  603. /* if the fault was due to disconnect, let khubd's
  604.  * call to usblp_disconnect() grab usblp->sem ...
  605.  */
  606. schedule ();
  607. continue;
  608. }
  610. writecount += usblp->writeurb.transfer_buffer_length;
  611. usblp->writeurb.transfer_buffer_length = 0;
  613. if (writecount == count) {
  614. up (&usblp->sem);
  615. break;
  616. }
  618. usblp->writeurb.transfer_buffer_length = (count - writecount) < USBLP_BUF_SIZE ?
  619.  (count - writecount) : USBLP_BUF_SIZE;
  621. if (copy_from_user(usblp->writeurb.transfer_buffer, buffer + writecount,
  622. usblp->writeurb.transfer_buffer_length)) {
  623. up(&usblp->sem);
  624. return writecount ? writecount : -EFAULT;
  625. }
  627. usblp->writeurb.dev = usblp->dev;
  628. usb_submit_urb(&usblp->writeurb);
  629. up (&usblp->sem);
  630. }
  632. return count;
  633. }
  635. static ssize_t usblp_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
  636. {
  637. struct usblp *usblp = file->private_data;
  639. if (!usblp->bidir)
  640. return -EINVAL;
  642. down (&usblp->sem);
  643. if (!usblp->dev) {
  644. count = -ENODEV;
  645. goto done;
  646. }
  648. if (usblp->readurb.status == -EINPROGRESS) {
  650. if (file->f_flags & O_NONBLOCK) {
  651. count = -EAGAIN;
  652. goto done;
  653. }
  655. // FIXME:  only use urb->status inside completion
  656. // callbacks; this way is racey...
  657. while (usblp->readurb.status == -EINPROGRESS) {
  658. if (signal_pending(current)) {
  659. count = -EINTR;
  660. goto done;
  661. }
  662. up (&usblp->sem);
  663. interruptible_sleep_on(&usblp->wait);
  664. down (&usblp->sem);
  665. }
  666. }
  668. if (!usblp->dev) {
  669. count = -ENODEV;
  670. goto done;
  671. }
  673. if (usblp->readurb.status) {
  674. err("usblp%d: error %d reading from printer",
  675. usblp->minor, usblp->readurb.status);
  676. usblp->readurb.dev = usblp->dev;
  677.   usblp->readcount = 0;
  678. usb_submit_urb(&usblp->readurb);
  679. count = -EIO;
  680. goto done;
  681. }
  683. count = count < usblp->readurb.actual_length - usblp->readcount ?
  684. count : usblp->readurb.actual_length - usblp->readcount;
  686. if (copy_to_user(buffer, usblp->readurb.transfer_buffer + usblp->readcount, count)) {
  687. count = -EFAULT;
  688. goto done;
  689. }
  691. if ((usblp->readcount += count) == usblp->readurb.actual_length) {
  692. usblp->readcount = 0;
  693. usblp->readurb.dev = usblp->dev;
  694. usb_submit_urb(&usblp->readurb);
  695. }
  697. done:
  698. up (&usblp->sem);
  699. return count;
  700. }
  702. /*
  703.  * Checks for printers that have quirks, such as requiring unidirectional
  704.  * communication but reporting bidirectional; currently some HP printers
  705.  * have this flaw (HP 810, 880, 895, etc.), or needing an init string
  706.  * sent at each open (like some Epsons).
  707.  * Returns 1 if found, 0 if not found.
  708.  *
  709.  * HP recommended that we use the bidirectional interface but
  710.  * don't attempt any bulk IN transfers from the IN endpoint.
  711.  * Here's some more detail on the problem:
  712.  * The problem is not that it isn't bidirectional though. The problem
  713.  * is that if you request a device ID, or status information, while
  714.  * the buffers are full, the return data will end up in the print data
  715.  * buffer. For example if you make sure you never request the device ID
  716.  * while you are sending print data, and you don't try to query the
  717.  * printer status every couple of milliseconds, you will probably be OK.
  718.  */
  719. static unsigned int usblp_quirks (__u16 vendor, __u16 product)
  720. {
  721. int i;
  723. for (i = 0; quirk_printers[i].vendorId; i++) {
  724. if (vendor == quirk_printers[i].vendorId &&
  725.     product == quirk_printers[i].productId)
  726. return quirk_printers[i].quirks;
  727.   }
  728. return 0;
  729. }
  731. static struct file_operations usblp_fops = {
  732. owner: THIS_MODULE,
  733. read: usblp_read,
  734. write: usblp_write,
  735. poll: usblp_poll,
  736. ioctl: usblp_ioctl,
  737. open: usblp_open,
  738. release: usblp_release,
  739. };
  741. static void *usblp_probe(struct usb_device *dev, unsigned int ifnum,
  742.  const struct usb_device_id *id)
  743. {
  744. struct usblp *usblp = 0;
  745. int protocol;
  746. char name[6];
  748. /* Malloc and start initializing usblp structure so we can use it
  749.  * directly. */
  750. if (!(usblp = kmalloc(sizeof(struct usblp), GFP_KERNEL))) {
  751. err("out of memory for usblp");
  752. goto abort;
  753. }
  754. memset(usblp, 0, sizeof(struct usblp));
  755. usblp->dev = dev;
  756. init_MUTEX (&usblp->sem);
  757. init_waitqueue_head(&usblp->wait);
  758. usblp->ifnum = ifnum;
  760. /* Look for a free usblp_table entry. */
  761. while (usblp_table[usblp->minor]) {
  762. usblp->minor++;
  763. if (usblp->minor >= USBLP_MINORS) {
  764. err("no more free usblp devices");
  765. goto abort;
  766. }
  767. }
  769. /* Malloc device ID string buffer to the largest expected length,
  770.  * since we can re-query it on an ioctl and a dynamic string
  771.  * could change in length. */
  772. if (!(usblp->device_id_string = kmalloc(DEVICE_ID_SIZE, GFP_KERNEL))) {
  773. err("out of memory for device_id_string");
  774. goto abort;
  775. }
  777. /* Malloc write/read buffers in one chunk.  We somewhat wastefully
  778.  * malloc both regardless of bidirectionality, because the
  779.  * alternate setting can be changed later via an ioctl. */
  780. if (!(usblp->buf = kmalloc(2 * USBLP_BUF_SIZE, GFP_KERNEL))) {
  781. err("out of memory for buf");
  782. goto abort;
  783. }
  785. /* Lookup quirks for this printer. */
  786. usblp->quirks = usblp_quirks(
  787. dev->descriptor.idVendor,
  788. dev->descriptor.idProduct);
  790. /* Analyze and pick initial alternate settings and endpoints. */
  791. protocol = usblp_select_alts(usblp);
  792. if (protocol < 0) {
  793. dbg("incompatible printer-class device 0x%4.4X/0x%4.4X",
  794. dev->descriptor.idVendor,
  795. dev->descriptor.idProduct);
  796. goto abort;
  797. }
  799. /* Setup the selected alternate setting and endpoints. */
  800. if (usblp_set_protocol(usblp, protocol) < 0)
  801. goto abort;
  803. /* Retrieve and store the device ID string. */
  804. usblp_cache_device_id_string(usblp);
  806. #ifdef DEBUG
  807. usblp_check_status(usblp, 0);
  808. #endif
  810. usblp_table[usblp->minor] = usblp;
  811. /* If we have devfs, create with perms=660. */
  812. sprintf(name, "lp%d", usblp->minor);
  813. usblp->devfs = devfs_register(usb_devfs_handle, name,
  814.       DEVFS_FL_DEFAULT, USB_MAJOR,
  815.       USBLP_MINOR_BASE + usblp->minor,
  816.       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP |
  817.       S_IWGRP, &usblp_fops, NULL);
  819. info("usblp%d: USB %sdirectional printer dev %d "
  820. "if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X",
  821. usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum, ifnum,
  822. usblp->protocol[usblp->current_protocol].alt_setting,
  823. usblp->current_protocol, usblp->dev->descriptor.idVendor,
  824. usblp->dev->descriptor.idProduct);
  826. return usblp;
  828. abort:
  829. if (usblp) {
  830. if (usblp->buf) kfree(usblp->buf);
  831. if (usblp->device_id_string) kfree(usblp->device_id_string);
  832. kfree(usblp);
  833. }
  834. return NULL;
  835. }
  837. /*
  838.  * We are a "new" style driver with usb_device_id table,
  839.  * but our requirements are too intricate for simple match to handle.
  840.  *
  841.  * The "proto_bias" option may be used to specify the preferred protocol
  842.  * for all USB printers (1=7/1/1, 2=7/1/2, 3=7/1/3).  If the device
  843.  * supports the preferred protocol, then we bind to it.
  844.  *
  845.  * The best interface for us is 7/1/2, because it is compatible
  846.  * with a stream of characters. If we find it, we bind to it.
  847.  *
  848.  * Note that the people from hpoj.sourceforge.net need to be able to
  849.  * bind to 7/1/3 (MLC/1284.4), so we provide them ioctls for this purpose.
  850.  *
  851.  * Failing 7/1/2, we look for 7/1/3, even though it's probably not
  852.  * stream-compatible, because this matches the behaviour of the old code.
  853.  *
  854.  * If nothing else, we bind to 7/1/1 - the unidirectional interface.
  855.  */
  856. static int usblp_select_alts(struct usblp *usblp)
  857. {
  858. struct usb_interface *if_alt;
  859. struct usb_interface_descriptor *ifd;
  860. struct usb_endpoint_descriptor *epd, *epwrite, *epread;
  861. int p, i, e;
  863. if_alt = &usblp->dev->actconfig->interface[usblp->ifnum];
  865. for (p = 0; p < USBLP_MAX_PROTOCOLS; p++)
  866. usblp->protocol[p].alt_setting = -1;
  868. /* Find out what we have. */
  869. for (i = 0; i < if_alt->num_altsetting; i++) {
  870. ifd = &if_alt->altsetting[i];
  872. if (ifd->bInterfaceClass != 7 || ifd->bInterfaceSubClass != 1)
  873. continue;
  875. if (ifd->bInterfaceProtocol < USBLP_FIRST_PROTOCOL ||
  876.     ifd->bInterfaceProtocol > USBLP_LAST_PROTOCOL)
  877. continue;
  879. /* Look for bulk OUT and IN endpoints. */
  880. epwrite = epread = 0;
  881. for (e = 0; e < ifd->bNumEndpoints; e++) {
  882. epd = &ifd->endpoint[e];
  884. if ((epd->bmAttributes&USB_ENDPOINT_XFERTYPE_MASK)!=
  885.     USB_ENDPOINT_XFER_BULK)
  886. continue;
  888. if (!(epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK)) {
  889. if (!epwrite) epwrite=epd;
  891. } else {
  892. if (!epread) epread=epd;
  893. }
  894. }
  896. /* Ignore buggy hardware without the right endpoints. */
  897. if (!epwrite || (ifd->bInterfaceProtocol > 1 && !epread))
  898. continue;
  900. /* Turn off reads for 7/1/1 (unidirectional) interfaces
  901.  * and buggy bidirectional printers. */
  902. if (ifd->bInterfaceProtocol == 1) {
  903. epread = NULL;
  904. } else if (usblp->quirks & USBLP_QUIRK_BIDIR) {
  905. info("Disabling reads from problem bidirectional "
  906. "printer on usblp%d", usblp->minor);
  907. epread = NULL;
  908. }
  910. usblp->protocol[ifd->bInterfaceProtocol].alt_setting = i;
  911. usblp->protocol[ifd->bInterfaceProtocol].epwrite = epwrite;
  912. usblp->protocol[ifd->bInterfaceProtocol].epread = epread;
  913. }
  915. /* If our requested protocol is supported, then use it. */
  916. if (proto_bias >= USBLP_FIRST_PROTOCOL &&
  917.     proto_bias <= USBLP_LAST_PROTOCOL &&
  918.     usblp->protocol[proto_bias].alt_setting != -1)
  919. return proto_bias;
  921. /* Ordering is important here. */
  922. if (usblp->protocol[2].alt_setting != -1) return 2;
  923. if (usblp->protocol[1].alt_setting != -1) return 1;
  924. if (usblp->protocol[3].alt_setting != -1) return 3;
  926. /* If nothing is available, then don't bind to this device. */
  927. return -1;
  928. }
  930. static int usblp_set_protocol(struct usblp *usblp, int protocol)
  931. {
  932. int r, alts;
  934. if (protocol < USBLP_FIRST_PROTOCOL || protocol > USBLP_LAST_PROTOCOL)
  935. return -EINVAL;
  937. alts = usblp->protocol[protocol].alt_setting;
  938. if (alts < 0) return -EINVAL;
  939. r = usb_set_interface(usblp->dev, usblp->ifnum, alts);
  940. if (r < 0) {
  941. err("can't set desired altsetting %d on interface %d",
  942. alts, usblp->ifnum);
  943. return r;
  944. }
  946. FILL_BULK_URB(&usblp->writeurb, usblp->dev,
  947. usb_sndbulkpipe(usblp->dev,
  948.  usblp->protocol[protocol].epwrite->bEndpointAddress),
  949. usblp->buf, 0,
  950. usblp_bulk, usblp);
  952. usblp->bidir = (usblp->protocol[protocol].epread != 0);
  953. if (usblp->bidir)
  954. FILL_BULK_URB(&usblp->readurb, usblp->dev,
  955. usb_rcvbulkpipe(usblp->dev,
  956.  usblp->protocol[protocol].epread->bEndpointAddress),
  957. usblp->buf + USBLP_BUF_SIZE, USBLP_BUF_SIZE,
  958. usblp_bulk, usblp);
  960. usblp->current_protocol = protocol;
  961. dbg("usblp%d set protocol %d", usblp->minor, protocol);
  962. return 0;
  963. }
  965. /* Retrieves and caches device ID string.
  966.  * Returns length, including length bytes but not null terminator.
  967.  * On error, returns a negative errno value. */
  968. static int usblp_cache_device_id_string(struct usblp *usblp)
  969. {
  970. int err, length;
  972. err = usblp_get_id(usblp, 0, usblp->device_id_string, DEVICE_ID_SIZE - 1);
  973. if (err < 0) {
  974. dbg("usblp%d: error = %d reading IEEE-1284 Device ID string",
  975. usblp->minor, err);
  976. usblp->device_id_string[0] = usblp->device_id_string[1] = '';
  977. return -EIO;
  978. }
  980. /* First two bytes are length in big-endian.
  981.  * They count themselves, and we copy them into
  982.  * the user's buffer. */
  983. length = (usblp->device_id_string[0] << 8) + usblp->device_id_string[1];
  984. if (length < 2)
  985. length = 2;
  986. else if (length >= DEVICE_ID_SIZE)
  987. length = DEVICE_ID_SIZE - 1;
  988. usblp->device_id_string[length] = '';
  990. dbg("usblp%d Device ID string [len=%d]="%s"",
  991. usblp->minor, length, &usblp->device_id_string[2]);
  993. return length;
  994. }
  996. static void usblp_disconnect(struct usb_device *dev, void *ptr)
  997. {
  998. struct usblp *usblp = ptr;
  1000. if (!usblp || !usblp->dev) {
  1001. err("bogus disconnect");
  1002. BUG ();
  1003. }
  1005. down (&usblp->sem);
  1006. lock_kernel();
  1007. usblp->dev = NULL;
  1009. usblp_unlink_urbs(usblp);
  1011. if (!usblp->used)
  1012. usblp_cleanup (usblp);
  1013. else  /* cleanup later, on close */
  1014. up (&usblp->sem);
  1015. unlock_kernel();
  1016. }
  1018. static struct usb_device_id usblp_ids [] = {
  1019. { USB_DEVICE_INFO(7, 1, 1) },
  1020. { USB_DEVICE_INFO(7, 1, 2) },
  1021. { USB_DEVICE_INFO(7, 1, 3) },
  1022. { USB_INTERFACE_INFO(7, 1, 1) },
  1023. { USB_INTERFACE_INFO(7, 1, 2) },
  1024. { USB_INTERFACE_INFO(7, 1, 3) },
  1025. { } /* Terminating entry */
  1026. };
  1028. MODULE_DEVICE_TABLE (usb, usblp_ids);
  1030. static struct usb_driver usblp_driver = {
  1031. name: "usblp",
  1032. probe: usblp_probe,
  1033. disconnect: usblp_disconnect,
  1034. fops: &usblp_fops,
  1035. minor: USBLP_MINOR_BASE,
  1036. id_table: usblp_ids,
  1037. };
  1039. static int __init usblp_init(void)
  1040. {
  1041. if (usb_register(&usblp_driver))
  1042. return -1;
  1043. info(DRIVER_VERSION ": " DRIVER_DESC);
  1044. return 0;
  1045. }
  1047. static void __exit usblp_exit(void)
  1048. {
  1049. usb_deregister(&usblp_driver);
  1050. }
  1052. module_init(usblp_init);
  1053. module_exit(usblp_exit);
  1055. MODULE_AUTHOR( DRIVER_AUTHOR );
  1056. MODULE_DESCRIPTION( DRIVER_DESC );
  1057. MODULE_PARM(proto_bias, "i");
  1058. MODULE_PARM_DESC(proto_bias, "Favourite protocol number");
  1059. MODULE_LICENSE("GPL");