git.oblomov.eu Git - linux-2.6/blob - drivers/usb/serial/safe_serial.c

   1 /*
   2  * Safe Encapsulated USB Serial Driver
   3  *
   4  *      Copyright (C) 2001 Lineo
   5  *      Copyright (C) 2001 Hewlett-Packard
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  * By:
  13  *      Stuart Lynne <sl@lineo.com>, Tom Rushworth <tbr@lineo.com>
  14  */
  15
  16 /*
  17  * The encapsultaion is designed to overcome difficulties with some USB hardware.
  18  *
  19  * While the USB protocol has a CRC over the data while in transit, i.e. while
  20  * being carried over the bus, there is no end to end protection. If the hardware
  21  * has any problems getting the data into or out of the USB transmit and receive
  22  * FIFO's then data can be lost.
  23  *
  24  * This protocol adds a two byte trailer to each USB packet to specify the number
  25  * of bytes of valid data and a 10 bit CRC that will allow the receiver to verify
  26  * that the entire USB packet was received without error.
  27  *
  28  * Because in this case the sender and receiver are the class and function drivers
  29  * there is now end to end protection.
  30  *
  31  * There is an additional option that can be used to force all transmitted packets
  32  * to be padded to the maximum packet size. This provides a work around for some
  33  * devices which have problems with small USB packets.
  34  *
  35  * Assuming a packetsize of N:
  36  *
  37  *      0..N-2  data and optional padding
  38  *
  39  *      N-2     bits 7-2 - number of bytes of valid data
  40  *              bits 1-0 top two bits of 10 bit CRC
  41  *      N-1     bottom 8 bits of 10 bit CRC
  42  *
  43  *
  44  *      | Data Length       | 10 bit CRC                                |
  45  *      + 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 | 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 +
  46  *
  47  * The 10 bit CRC is computed across the sent data, followed by the trailer with
  48  * the length set and the CRC set to zero. The CRC is then OR'd into the trailer.
  49  *
  50  * When received a 10 bit CRC is computed over the entire frame including the trailer
  51  * and should be equal to zero.
  52  *
  53  * Two module parameters are used to control the encapsulation, if both are
  54  * turned of the module works as a simple serial device with NO
  55  * encapsulation.
  56  *
  57  * See linux/drivers/usbd/serial_fd for a device function driver
  58  * implementation of this.
  59  *
  60  */
  61
  62
  63 #include <linux/kernel.h>
  64 #include <linux/errno.h>
  65 #include <linux/init.h>
  66 #include <linux/slab.h>
  67 #include <linux/tty.h>
  68 #include <linux/tty_driver.h>
  69 #include <linux/tty_flip.h>
  70 #include <linux/module.h>
  71 #include <linux/spinlock.h>
  72 #include <asm/uaccess.h>
  73 #include <linux/usb.h>
  74 #include <linux/usb/serial.h>
  75
  76
  77 #ifndef CONFIG_USB_SERIAL_SAFE_PADDED
  78 #define CONFIG_USB_SERIAL_SAFE_PADDED 0
  79 #endif
  80
  81 static int debug;
  82 static int safe = 1;
  83 static int padded = CONFIG_USB_SERIAL_SAFE_PADDED;
  84
  85 #define DRIVER_VERSION "v0.0b"
  86 #define DRIVER_AUTHOR "sl@lineo.com, tbr@lineo.com"
  87 #define DRIVER_DESC "USB Safe Encapsulated Serial"
  88
  89 MODULE_AUTHOR (DRIVER_AUTHOR);
  90 MODULE_DESCRIPTION (DRIVER_DESC);
  91 MODULE_LICENSE("GPL");
  92
  93 static __u16 vendor;            // no default
  94 static __u16 product;           // no default
  95 module_param(vendor, ushort, 0);
  96 MODULE_PARM_DESC(vendor, "User specified USB idVendor (required)");
  97 module_param(product, ushort, 0);
  98 MODULE_PARM_DESC(product, "User specified USB idProduct (required)");
  99
 100 module_param(debug, bool, S_IRUGO | S_IWUSR);
 101 MODULE_PARM_DESC(debug, "Debug enabled or not");
 102
 103 module_param(safe, bool, 0);
 104 MODULE_PARM_DESC(safe, "Turn Safe Encapsulation On/Off");
 105
 106 module_param(padded, bool, 0);
 107 MODULE_PARM_DESC(padded, "Pad to full wMaxPacketSize On/Off");
 108
 109 #define CDC_DEVICE_CLASS                        0x02
 110
 111 #define CDC_INTERFACE_CLASS                     0x02
 112 #define CDC_INTERFACE_SUBCLASS                  0x06
 113
 114 #define LINEO_INTERFACE_CLASS                   0xff
 115
 116 #define LINEO_INTERFACE_SUBCLASS_SAFENET        0x01
 117 #define LINEO_SAFENET_CRC                       0x01
 118 #define LINEO_SAFENET_CRC_PADDED                0x02
 119
 120 #define LINEO_INTERFACE_SUBCLASS_SAFESERIAL     0x02
 121 #define LINEO_SAFESERIAL_CRC                    0x01
 122 #define LINEO_SAFESERIAL_CRC_PADDED             0x02
 123
 124
 125 #define MY_USB_DEVICE(vend,prod,dc,ic,isc) \
 126         .match_flags = USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_CLASS | \
 127                 USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
 128         .idVendor = (vend), \
 129         .idProduct = (prod),\
 130         .bDeviceClass = (dc),\
 131         .bInterfaceClass = (ic), \
 132         .bInterfaceSubClass = (isc),
 133
 134 static struct usb_device_id id_table[] = {
 135         {MY_USB_DEVICE (0x49f, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Itsy
 136         {MY_USB_DEVICE (0x3f0, 0x2101, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Calypso
 137         {MY_USB_DEVICE (0x4dd, 0x8001, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Iris
 138         {MY_USB_DEVICE (0x4dd, 0x8002, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Collie
 139         {MY_USB_DEVICE (0x4dd, 0x8003, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Collie
 140         {MY_USB_DEVICE (0x4dd, 0x8004, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Collie
 141         {MY_USB_DEVICE (0x5f9, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},  // Sharp tmp
 142         // extra null entry for module
 143         // vendor/produc parameters
 144         {MY_USB_DEVICE (0, 0, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},
 145         {}                      // terminating entry
 146 };
 147
 148 MODULE_DEVICE_TABLE (usb, id_table);
 149
 150 static struct usb_driver safe_driver = {
 151         .name =         "safe_serial",
 152         .probe =        usb_serial_probe,
 153         .disconnect =   usb_serial_disconnect,
 154         .id_table =     id_table,
 155         .no_dynamic_id =        1,
 156 };
 157
 158 static const __u16 crc10_table[256] = {
 159         0x000, 0x233, 0x255, 0x066, 0x299, 0x0aa, 0x0cc, 0x2ff, 0x301, 0x132, 0x154, 0x367, 0x198, 0x3ab, 0x3cd, 0x1fe,
 160         0x031, 0x202, 0x264, 0x057, 0x2a8, 0x09b, 0x0fd, 0x2ce, 0x330, 0x103, 0x165, 0x356, 0x1a9, 0x39a, 0x3fc, 0x1cf,
 161         0x062, 0x251, 0x237, 0x004, 0x2fb, 0x0c8, 0x0ae, 0x29d, 0x363, 0x150, 0x136, 0x305, 0x1fa, 0x3c9, 0x3af, 0x19c,
 162         0x053, 0x260, 0x206, 0x035, 0x2ca, 0x0f9, 0x09f, 0x2ac, 0x352, 0x161, 0x107, 0x334, 0x1cb, 0x3f8, 0x39e, 0x1ad,
 163         0x0c4, 0x2f7, 0x291, 0x0a2, 0x25d, 0x06e, 0x008, 0x23b, 0x3c5, 0x1f6, 0x190, 0x3a3, 0x15c, 0x36f, 0x309, 0x13a,
 164         0x0f5, 0x2c6, 0x2a0, 0x093, 0x26c, 0x05f, 0x039, 0x20a, 0x3f4, 0x1c7, 0x1a1, 0x392, 0x16d, 0x35e, 0x338, 0x10b,
 165         0x0a6, 0x295, 0x2f3, 0x0c0, 0x23f, 0x00c, 0x06a, 0x259, 0x3a7, 0x194, 0x1f2, 0x3c1, 0x13e, 0x30d, 0x36b, 0x158,
 166         0x097, 0x2a4, 0x2c2, 0x0f1, 0x20e, 0x03d, 0x05b, 0x268, 0x396, 0x1a5, 0x1c3, 0x3f0, 0x10f, 0x33c, 0x35a, 0x169,
 167         0x188, 0x3bb, 0x3dd, 0x1ee, 0x311, 0x122, 0x144, 0x377, 0x289, 0x0ba, 0x0dc, 0x2ef, 0x010, 0x223, 0x245, 0x076,
 168         0x1b9, 0x38a, 0x3ec, 0x1df, 0x320, 0x113, 0x175, 0x346, 0x2b8, 0x08b, 0x0ed, 0x2de, 0x021, 0x212, 0x274, 0x047,
 169         0x1ea, 0x3d9, 0x3bf, 0x18c, 0x373, 0x140, 0x126, 0x315, 0x2eb, 0x0d8, 0x0be, 0x28d, 0x072, 0x241, 0x227, 0x014,
 170         0x1db, 0x3e8, 0x38e, 0x1bd, 0x342, 0x171, 0x117, 0x324, 0x2da, 0x0e9, 0x08f, 0x2bc, 0x043, 0x270, 0x216, 0x025,
 171         0x14c, 0x37f, 0x319, 0x12a, 0x3d5, 0x1e6, 0x180, 0x3b3, 0x24d, 0x07e, 0x018, 0x22b, 0x0d4, 0x2e7, 0x281, 0x0b2,
 172         0x17d, 0x34e, 0x328, 0x11b, 0x3e4, 0x1d7, 0x1b1, 0x382, 0x27c, 0x04f, 0x029, 0x21a, 0x0e5, 0x2d6, 0x2b0, 0x083,
 173         0x12e, 0x31d, 0x37b, 0x148, 0x3b7, 0x184, 0x1e2, 0x3d1, 0x22f, 0x01c, 0x07a, 0x249, 0x0b6, 0x285, 0x2e3, 0x0d0,
 174         0x11f, 0x32c, 0x34a, 0x179, 0x386, 0x1b5, 0x1d3, 0x3e0, 0x21e, 0x02d, 0x04b, 0x278, 0x087, 0x2b4, 0x2d2, 0x0e1,
 175 };
 176
 177 #define CRC10_INITFCS     0x000 // Initial FCS value
 178 #define CRC10_GOODFCS     0x000 // Good final FCS value
 179 #define CRC10_FCS(fcs, c) ( (((fcs) << 8) & 0x3ff) ^ crc10_table[((fcs) >> 2) & 0xff] ^ (c))
 180
 181 /**
 182  * fcs_compute10 - memcpy and calculate 10 bit CRC across buffer
 183  * @sp: pointer to buffer
 184  * @len: number of bytes
 185  * @fcs: starting FCS
 186  *
 187  * Perform a memcpy and calculate fcs using ppp 10bit CRC algorithm. Return
 188  * new 10 bit FCS.
 189  */
 190 static __u16 __inline__ fcs_compute10 (unsigned char *sp, int len, __u16 fcs)
 191 {
 192         for (; len-- > 0; fcs = CRC10_FCS (fcs, *sp++));
 193         return fcs;
 194 }
 195
 196 static void safe_read_bulk_callback (struct urb *urb)
 197 {
 198         struct usb_serial_port *port =  urb->context;
 199         unsigned char *data = urb->transfer_buffer;
 200         unsigned char length = urb->actual_length;
 201         int result;
 202         int status = urb->status;
 203
 204         dbg ("%s", __func__);
 205
 206         if (status) {
 207                 dbg("%s - nonzero read bulk status received: %d",
 208                     __func__, status);
 209                 return;
 210         }
 211
 212         dbg ("safe_read_bulk_callback length: %d", port->read_urb->actual_length);
 213 #ifdef ECHO_RCV
 214         {
 215                 int i;
 216                 unsigned char *cp = port->read_urb->transfer_buffer;
 217                 for (i = 0; i < port->read_urb->actual_length; i++) {
 218                         if ((i % 32) == 0) {
 219                                 printk ("\nru[%02x] ", i);
 220                         }
 221                         printk ("%02x ", *cp++);
 222                 }
 223                 printk ("\n");
 224         }
 225 #endif
 226         if (safe) {
 227                 __u16 fcs;
 228                 if (!(fcs = fcs_compute10 (data, length, CRC10_INITFCS))) {
 229                         int actual_length = data[length - 2] >> 2;
 230                         if (actual_length <= (length - 2)) {
 231                                 info ("%s - actual: %d", __func__, actual_length);
 232                                 tty_insert_flip_string(port->tty, data, actual_length);
 233                                 tty_flip_buffer_push (port->tty);
 234                         } else {
 235                                 err ("%s - inconsistent lengths %d:%d", __func__,
 236                                      actual_length, length);
 237                         }
 238                 } else {
 239                         err ("%s - bad CRC %x", __func__, fcs);
 240                 }
 241         } else {
 242                 tty_insert_flip_string(port->tty, data, length);
 243                 tty_flip_buffer_push (port->tty);
 244         }
 245
 246         /* Continue trying to always read  */
 247         usb_fill_bulk_urb (urb, port->serial->dev,
 248                        usb_rcvbulkpipe (port->serial->dev, port->bulk_in_endpointAddress),
 249                        urb->transfer_buffer, urb->transfer_buffer_length,
 250                        safe_read_bulk_callback, port);
 251
 252         if ((result = usb_submit_urb (urb, GFP_ATOMIC))) {
 253                 err ("%s - failed resubmitting read urb, error %d", __func__, result);
 254                 /* FIXME: Need a mechanism to retry later if this happens */
 255         }
 256 }
 257
 258 static int safe_write (struct usb_serial_port *port, const unsigned char *buf, int count)
 259 {
 260         unsigned char *data;
 261         int result;
 262         int i;
 263         int packet_length;
 264
 265         dbg ("safe_write port: %p %d urb: %p count: %d", port, port->number, port->write_urb,
 266              count);
 267
 268         if (!port->write_urb) {
 269                 dbg ("%s - write urb NULL", __func__);
 270                 return 0;
 271         }
 272
 273         dbg ("safe_write write_urb: %d transfer_buffer_length",
 274              port->write_urb->transfer_buffer_length);
 275
 276         if (!port->write_urb->transfer_buffer_length) {
 277                 dbg ("%s - write urb transfer_buffer_length zero", __func__);
 278                 return 0;
 279         }
 280         if (count == 0) {
 281                 dbg ("%s - write request of 0 bytes", __func__);
 282                 return 0;
 283         }
 284         spin_lock_bh(&port->lock);
 285         if (port->write_urb_busy) {
 286                 spin_unlock_bh(&port->lock);
 287                 dbg("%s - already writing", __func__);
 288                 return 0;
 289         }
 290         port->write_urb_busy = 1;
 291         spin_unlock_bh(&port->lock);
 292
 293         packet_length = port->bulk_out_size;    // get max packetsize
 294
 295         i = packet_length - (safe ? 2 : 0);     // get bytes to send
 296         count = (count > i) ? i : count;
 297
 298
 299         // get the data into the transfer buffer
 300         data = port->write_urb->transfer_buffer;
 301         memset (data, '0', packet_length);
 302
 303         memcpy (data, buf, count);
 304
 305         if (safe) {
 306                 __u16 fcs;
 307
 308                 // pad if necessary
 309                 if (!padded) {
 310                         packet_length = count + 2;
 311                 }
 312                 // set count
 313                 data[packet_length - 2] = count << 2;
 314                 data[packet_length - 1] = 0;
 315
 316                 // compute fcs and insert into trailer
 317                 fcs = fcs_compute10 (data, packet_length, CRC10_INITFCS);
 318                 data[packet_length - 2] |= fcs >> 8;
 319                 data[packet_length - 1] |= fcs & 0xff;
 320
 321                 // set length to send
 322                 port->write_urb->transfer_buffer_length = packet_length;
 323         } else {
 324                 port->write_urb->transfer_buffer_length = count;
 325         }
 326
 327         usb_serial_debug_data(debug, &port->dev, __func__, count, port->write_urb->transfer_buffer);
 328 #ifdef ECHO_TX
 329         {
 330                 int i;
 331                 unsigned char *cp = port->write_urb->transfer_buffer;
 332                 for (i = 0; i < port->write_urb->transfer_buffer_length; i++) {
 333                         if ((i % 32) == 0) {
 334                                 printk ("\nsu[%02x] ", i);
 335                         }
 336                         printk ("%02x ", *cp++);
 337                 }
 338                 printk ("\n");
 339         }
 340 #endif
 341         port->write_urb->dev = port->serial->dev;
 342         if ((result = usb_submit_urb (port->write_urb, GFP_KERNEL))) {
 343                 port->write_urb_busy = 0;
 344                 err ("%s - failed submitting write urb, error %d", __func__, result);
 345                 return 0;
 346         }
 347         dbg ("%s urb: %p submitted", __func__, port->write_urb);
 348
 349         return (count);
 350 }
 351
 352 static int safe_write_room (struct usb_serial_port *port)
 353 {
 354         int room = 0;           /* Default: no room */
 355         unsigned long flags;
 356
 357         dbg ("%s", __func__);
 358
 359         spin_lock_irqsave(&port->lock, flags);
 360         if (port->write_urb_busy)
 361                 room = port->bulk_out_size - (safe ? 2 : 0);
 362         spin_unlock_irqrestore(&port->lock, flags);
 363
 364         if (room) {
 365                 dbg ("safe_write_room returns %d", room);
 366         }
 367
 368         return room;
 369 }
 370
 371 static int safe_startup (struct usb_serial *serial)
 372 {
 373         switch (serial->interface->cur_altsetting->desc.bInterfaceProtocol) {
 374         case LINEO_SAFESERIAL_CRC:
 375                 break;
 376         case LINEO_SAFESERIAL_CRC_PADDED:
 377                 padded = 1;
 378                 break;
 379         default:
 380                 return -EINVAL;
 381         }
 382         return 0;
 383 }
 384
 385 static struct usb_serial_driver safe_device = {
 386         .driver = {
 387                 .owner =        THIS_MODULE,
 388                 .name =         "safe_serial",
 389         },
 390         .id_table =             id_table,
 391         .usb_driver =           &safe_driver,
 392         .num_ports =            1,
 393         .write =                safe_write,
 394         .write_room =           safe_write_room,
 395         .read_bulk_callback =   safe_read_bulk_callback,
 396         .attach =               safe_startup,
 397 };
 398
 399 static int __init safe_init (void)
 400 {
 401         int i, retval;
 402
 403         info (DRIVER_VERSION " " DRIVER_AUTHOR);
 404         info (DRIVER_DESC);
 405         info ("vendor: %x product: %x safe: %d padded: %d\n", vendor, product, safe, padded);
 406
 407         // if we have vendor / product parameters patch them into id list
 408         if (vendor || product) {
 409                 info ("vendor: %x product: %x\n", vendor, product);
 410
 411                 for (i = 0; i < ARRAY_SIZE(id_table); i++) {
 412                         if (!id_table[i].idVendor && !id_table[i].idProduct) {
 413                                 id_table[i].idVendor = vendor;
 414                                 id_table[i].idProduct = product;
 415                                 break;
 416                         }
 417                 }
 418         }
 419
 420         retval = usb_serial_register(&safe_device);
 421         if (retval)
 422                 goto failed_usb_serial_register;
 423         retval = usb_register(&safe_driver);
 424         if (retval)
 425                 goto failed_usb_register;
 426
 427         return 0;
 428 failed_usb_register:
 429         usb_serial_deregister(&safe_device);
 430 failed_usb_serial_register:
 431         return retval;
 432 }
 433
 434 static void __exit safe_exit (void)
 435 {
 436         usb_deregister (&safe_driver);
 437         usb_serial_deregister (&safe_device);
 438 }
 439
 440 module_init (safe_init);
 441 module_exit (safe_exit);