drivers/usb/printer.c

   1
   2 /* Driver for USB Printers
   3  *
   4  * (C) Michael Gee (michael@linuxspecific.com) 1999
   5  *
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/kernel.h>
  10 #include <linux/sched.h>
  11 #include <linux/signal.h>
  12 #include <linux/errno.h>
  13 #include <linux/miscdevice.h>
  14 #include <linux/random.h>
  15 #include <linux/poll.h>
  16 #include <linux/init.h>
  17 #include <linux/malloc.h>
  18 #include <linux/lp.h>
  19 #include <linux/spinlock.h>
  20
  21 #include "usb.h"
  22
  23 #define NAK_TIMEOUT (HZ)                                /* stall wait for printer */
  24 #define MAX_RETRY_COUNT ((60*60*HZ)/NAK_TIMEOUT)        /* should not take 1 minute a page! */
  25
  26 #ifndef USB_PRINTER_MAJOR
  27 #define USB_PRINTER_MAJOR 63
  28 #endif
  29
  30 static int mymajor = USB_PRINTER_MAJOR;
  31
  32 #define MAX_PRINTERS    8
  33
  34 struct pp_usb_data {
  35         struct usb_device       *pusb_dev;
  36         __u8                    isopen;                 /* nz if open */
  37         __u8                    noinput;                /* nz if no input stream */
  38         __u8                    minor;                  /* minor number of device */
  39         __u8                    status;                 /* last status from device */
  40         int                     maxin, maxout;          /* max transfer size in and out */
  41         char                    *obuf;                  /* transfer buffer (out only) */
  42         wait_queue_head_t       wait_q;                 /* for timeouts */
  43         unsigned int            last_error;             /* save for checking */
  44 };
  45
  46 static struct pp_usb_data *minor_data[MAX_PRINTERS];
  47
  48 #define PPDATA(x) ((struct pp_usb_data *)(x))
  49
  50 unsigned char printer_read_status(struct pp_usb_data *p)
  51 {
  52         __u8 status;
  53         devrequest dr;
  54         struct usb_device *dev = p->pusb_dev;
  55
  56         dr.requesttype = USB_TYPE_CLASS | USB_RT_INTERFACE | 0x80;
  57         dr.request = 1;
  58         dr.value = 0;
  59         dr.index = 0;
  60         dr.length = 1;
  61         if (dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, &status, 1)) {
  62                 return 0;
  63         }
  64         return status;
  65 }
  66
  67 static int printer_check_status(struct pp_usb_data *p)
  68 {
  69         unsigned int last = p->last_error;
  70         unsigned char status = printer_read_status(p);
  71
  72         if (status & LP_PERRORP)
  73                 /* No error. */
  74                 last = 0;
  75         else if ((status & LP_POUTPA)) {
  76                 if (last != LP_POUTPA) {
  77                         last = LP_POUTPA;
  78                         printk(KERN_INFO "usblp%d out of paper\n", p->minor);
  79                 }
  80         } else if (!(status & LP_PSELECD)) {
  81                 if (last != LP_PSELECD) {
  82                         last = LP_PSELECD;
  83                         printk(KERN_INFO "usblp%d off-line\n", p->minor);
  84                 }
  85         } else {
  86                 if (last != LP_PERRORP) {
  87                         last = LP_PERRORP;
  88                         printk(KERN_INFO "usblp%d on fire\n", p->minor);
  89                 }
  90         }
  91
  92         p->last_error = last;
  93
  94         return status;
  95 }
  96
  97 void printer_reset(struct pp_usb_data *p)
  98 {
  99         devrequest dr;
 100         struct usb_device *dev = p->pusb_dev;
 101
 102         dr.requesttype = USB_TYPE_CLASS | USB_RECIP_OTHER;
 103         dr.request = 2;
 104         dr.value = 0;
 105         dr.index = 0;
 106         dr.length = 0;
 107         dev->bus->op->control_msg(dev, usb_sndctrlpipe(dev,0), &dr, NULL, 0);
 108 }
 109
 110 static int open_printer(struct inode * inode, struct file * file)
 111 {
 112         struct pp_usb_data *p;
 113
 114         if(MINOR(inode->i_rdev) >= MAX_PRINTERS ||
 115            !minor_data[MINOR(inode->i_rdev)]) {
 116                 return -ENODEV;
 117         }
 118
 119         p = minor_data[MINOR(inode->i_rdev)];
 120         p->minor = MINOR(inode->i_rdev);
 121
 122         if (p->isopen++) {
 123                 return -EBUSY;
 124         }
 125         if (!(p->obuf = (char *)__get_free_page(GFP_KERNEL))) {
 126                 p->isopen = 0;
 127                 return -ENOMEM;
 128         }
 129
 130         printer_check_status(p);
 131
 132
 133         file->private_data = p;
 134 //      printer_reset(p);
 135         init_waitqueue_head(&p->wait_q);
 136         return 0;
 137 }
 138
 139 static int close_printer(struct inode * inode, struct file * file)
 140 {
 141         struct pp_usb_data *p = file->private_data;
 142
 143         free_page((unsigned long)p->obuf);
 144         p->isopen = 0;
 145         file->private_data = NULL;
 146         if(!p->pusb_dev) {
 147                 minor_data[p->minor] = NULL;
 148                 kfree(p);
 149
 150                 MOD_DEC_USE_COUNT;
 151
 152         }
 153         return 0;
 154 }
 155
 156 static ssize_t write_printer(struct file * file,
 157        const char * buffer, size_t count, loff_t *ppos)
 158 {
 159         struct pp_usb_data *p = file->private_data;
 160         unsigned long copy_size;
 161         unsigned long bytes_written = 0;
 162         unsigned long partial;
 163         int result = USB_ST_NOERROR;
 164         int maxretry;
 165         int endpoint_num;
 166         struct usb_interface_descriptor *interface;
 167
 168         interface = p->pusb_dev->config->interface->altsetting;
 169         endpoint_num = (interface->endpoint[1].bEndpointAddress & 0x0f);
 170
 171         do {
 172                 char *obuf = p->obuf;
 173                 unsigned long thistime;
 174
 175                 thistime = copy_size = (count > p->maxout) ? p->maxout : count;
 176                 if (copy_from_user(p->obuf, buffer, copy_size))
 177                         return -EFAULT;
 178                 maxretry = MAX_RETRY_COUNT;
 179                 while (thistime) {
 180                         if (!p->pusb_dev)
 181                                 return -ENODEV;
 182                         if (signal_pending(current)) {
 183                                 return bytes_written ? bytes_written : -EINTR;
 184                         }
 185                         result = p->pusb_dev->bus->op->bulk_msg(p->pusb_dev,
 186                                          usb_sndbulkpipe(p->pusb_dev, endpoint_num),
 187                                          obuf, thistime, &partial);
 188                         if (partial) {
 189                                 obuf += partial;
 190                                 thistime -= partial;
 191                                 maxretry = MAX_RETRY_COUNT;
 192                         }
 193                         if (result == USB_ST_TIMEOUT) { /* NAK - so hold for a while */
 194                                 if(!maxretry--)
 195                                         return -ETIME;
 196                                 interruptible_sleep_on_timeout(&p->wait_q, NAK_TIMEOUT);
 197                                 continue;
 198                         } else if (!result && !partial) {
 199                                 break;
 200                         }
 201                 };
 202                 if (result) {
 203                         /* whoops - let's reset and fail the request */
 204 //                      printk("Whoops - %x\n", result);
 205                         printer_reset(p);
 206                         interruptible_sleep_on_timeout(&p->wait_q, 5*HZ);  /* let reset do its stuff */
 207                         return -EIO;
 208                 }
 209                 bytes_written += copy_size;
 210                 count -= copy_size;
 211                 buffer += copy_size;
 212         } while ( count > 0 );
 213
 214         return bytes_written ? bytes_written : -EIO;
 215 }
 216
 217 static ssize_t read_printer(struct file * file,
 218        char * buffer, size_t count, loff_t *ppos)
 219 {
 220         struct pp_usb_data *p = file->private_data;
 221         int read_count;
 222         int this_read;
 223         char buf[64];
 224         unsigned long partial;
 225         int result;
 226         int endpoint_num;
 227         struct usb_interface_descriptor *interface;
 228
 229         interface = p->pusb_dev->config->interface->altsetting;
 230         endpoint_num = (interface->endpoint[0].bEndpointAddress & 0x0f);
 231
 232         if (p->noinput)
 233                 return -EINVAL;
 234
 235         read_count = 0;
 236         while (count) {
 237                 if (signal_pending(current)) {
 238                         return read_count ? read_count : -EINTR;
 239                 }
 240                 if (!p->pusb_dev)
 241                         return -ENODEV;
 242                 this_read = (count > sizeof(buf)) ? sizeof(buf) : count;
 243
 244                 result = p->pusb_dev->bus->op->bulk_msg(p->pusb_dev,
 245                           usb_rcvbulkpipe(p->pusb_dev, endpoint_num),
 246                           buf, this_read, &partial);
 247
 248                 /* unlike writes, we don't retry a NAK, just stop now */
 249                 if (!result & partial)
 250                         count = this_read = partial;
 251                 else if (result)
 252                         return -EIO;
 253
 254                 if (this_read) {
 255                         if (copy_to_user(buffer, buf, this_read))
 256                                 return -EFAULT;
 257                         count -= this_read;
 258                         read_count += this_read;
 259                         buffer += this_read;
 260                 }
 261         }
 262         return read_count;
 263 }
 264
 265 static int printer_probe(struct usb_device *dev)
 266 {
 267         struct usb_interface_descriptor *interface;
 268         int i;
 269
 270         /*
 271          * FIXME - this will not cope with combined printer/scanners
 272          */
 273         if ((dev->descriptor.bDeviceClass != 7 &&
 274              dev->descriptor.bDeviceClass != 0) ||
 275             dev->descriptor.bNumConfigurations != 1 ||
 276             dev->config[0].bNumInterfaces != 1) {
 277                 return -1;
 278         }
 279
 280         interface = &dev->config[0].interface[0].altsetting[0];
 281
 282         /* Lets be paranoid (for the moment)*/
 283         if (interface->bInterfaceClass != 7 ||
 284             interface->bInterfaceSubClass != 1 ||
 285             (interface->bInterfaceProtocol != 2 && interface->bInterfaceProtocol != 1)||
 286             interface->bNumEndpoints > 2) {
 287                 return -1;
 288         }
 289
 290         if ((interface->endpoint[0].bEndpointAddress & 0xf0) != 0x00 ||
 291             interface->endpoint[0].bmAttributes != 0x02 ||
 292             (interface->bNumEndpoints > 1 && (
 293                     (interface->endpoint[1].bEndpointAddress & 0xf0) != 0x80 ||
 294                     interface->endpoint[1].bmAttributes != 0x02))) {
 295                 return -1;
 296         }
 297
 298         for (i=0; i<MAX_PRINTERS; i++) {
 299                 if (!minor_data[i])
 300                         break;
 301         }
 302         if (i >= MAX_PRINTERS) {
 303                 return -1;
 304         }
 305
 306         printk(KERN_INFO "USB Printer found at address %d\n", dev->devnum);
 307
 308         if (!(dev->private = kmalloc(sizeof(struct pp_usb_data), GFP_KERNEL))) {
 309                 printk( KERN_DEBUG "usb_printer: no memory!\n");
 310                 return -1;
 311         }
 312
 313         memset(dev->private, 0, sizeof(struct pp_usb_data));
 314         minor_data[i] = PPDATA(dev->private);
 315         minor_data[i]->minor = i;
 316         minor_data[i]->pusb_dev = dev;
 317         /* The max packet size can't be more than 64 (& will be 64 for
 318          * any decent bulk device); this calculation was silly.  -greg
 319          * minor_data[i]->maxout = interface->endpoint[0].wMaxPacketSize * 16;
 320          */
 321         minor_data[i]->maxout = 8192;
 322         if (minor_data[i]->maxout > PAGE_SIZE) {
 323                 minor_data[i]->maxout = PAGE_SIZE;
 324         }
 325         if (interface->bInterfaceProtocol != 2)
 326                 minor_data[i]->noinput = 1;
 327         else {
 328                 minor_data[i]->maxin = interface->endpoint[1].wMaxPacketSize;
 329         }
 330
 331         if (usb_set_configuration(dev, dev->config[0].bConfigurationValue)) {
 332                 printk(KERN_INFO "  Failed usb_set_configuration: printer\n");
 333                 return -1;
 334         }
 335 #if 0
 336         {
 337                 __u8 status;
 338                 __u8 ieee_id[64];
 339                 devrequest dr;
 340
 341                 /* Lets get the device id if possible */
 342                 dr.requesttype = USB_TYPE_CLASS | USB_RT_INTERFACE | 0x80;
 343                 dr.request = 0;
 344                 dr.value = 0;
 345                 dr.index = 0;
 346                 dr.length = sizeof(ieee_id) - 1;
 347                 if (dev->bus->op->control_msg(dev, usb_rcvctrlpipe(dev,0), &dr, ieee_id, sizeof(ieee_id)-1) == 0) {
 348                         if (ieee_id[1] < sizeof(ieee_id) - 1)
 349                                 ieee_id[ieee_id[1]+2] = '\0';
 350                         else
 351                                 ieee_id[sizeof(ieee_id)-1] = '\0';
 352                         printk(KERN_INFO "  Printer ID is %s\n", &ieee_id[2]);
 353                 }
 354                 status = printer_read_status(PPDATA(dev->private));
 355                 printk(KERN_INFO "  Status is %s,%s,%s\n",
 356                        (status & 0x10) ? "Selected" : "Not Selected",
 357                        (status & 0x20) ? "No Paper" : "Paper",
 358                        (status & 0x08) ? "No Error" : "Error");
 359         }
 360 #endif
 361         return 0;
 362 }
 363
 364 static void printer_disconnect(struct usb_device *dev)
 365 {
 366         struct pp_usb_data *pp = dev->private;
 367
 368         if (pp->isopen) {
 369                 /* better let it finish - the release will do whats needed */
 370                 pp->pusb_dev = NULL;
 371                 return;
 372         }
 373         minor_data[pp->minor] = NULL;
 374         kfree(pp);
 375         dev->private = NULL;            /* just in case */
 376         MOD_DEC_USE_COUNT;
 377 }
 378
 379 static struct usb_driver printer_driver = {
 380         "printer",
 381         printer_probe,
 382         printer_disconnect,
 383         { NULL, NULL }
 384 };
 385
 386 static struct file_operations usb_printer_fops = {
 387         NULL,           /* seek */
 388         read_printer,
 389         write_printer,
 390         NULL,           /* readdir */
 391         NULL,           /* poll - out for the moment */
 392         NULL,           /* ioctl */
 393         NULL,           /* mmap */
 394         open_printer,
 395         NULL,           /* flush ? */
 396         close_printer,
 397         NULL,
 398         NULL
 399 };
 400
 401 int usb_printer_init(void)
 402 {
 403         int result;
 404
 405         MOD_INC_USE_COUNT;
 406
 407         if ((result = register_chrdev(USB_PRINTER_MAJOR, "usblp", &usb_printer_fops)) < 0) {
 408                 printk(KERN_WARNING "usbprinter: Cannot register device\n");
 409                 return result;
 410         }
 411         if (mymajor == 0) {
 412                 mymajor = result;
 413         }
 414         usb_register(&printer_driver);
 415         printk(KERN_INFO "USB Printer support registered.\n");
 416         return 0;
 417 }
 418
 419 #ifdef MODULE
 420 int init_module(void)
 421 {
 422
 423         return usb_printer_init();
 424 }
 425
 426 void cleanup_module(void)
 427 {
 428         usb_deregister(&printer_driver);
 429         unregister_chrdev(mymajor, "usblp");
 430 }
 431 #endif