Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jgarzi...
[linux-2.6] / 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 = (struct usb_serial_port *) urb->context;
199         unsigned char *data = urb->transfer_buffer;
200         unsigned char length = urb->actual_length;
201         int i;
202         int result;
203         int status = urb->status;
204
205         dbg ("%s", __FUNCTION__);
206
207         if (status) {
208                 dbg("%s - nonzero read bulk status received: %d",
209                     __FUNCTION__, status);
210                 return;
211         }
212
213         dbg ("safe_read_bulk_callback length: %d", port->read_urb->actual_length);
214 #ifdef ECHO_RCV
215         {
216                 int i;
217                 unsigned char *cp = port->read_urb->transfer_buffer;
218                 for (i = 0; i < port->read_urb->actual_length; i++) {
219                         if ((i % 32) == 0) {
220                                 printk ("\nru[%02x] ", i);
221                         }
222                         printk ("%02x ", *cp++);
223                 }
224                 printk ("\n");
225         }
226 #endif
227         if (safe) {
228                 __u16 fcs;
229                 if (!(fcs = fcs_compute10 (data, length, CRC10_INITFCS))) {
230
231                         int actual_length = data[length - 2] >> 2;
232
233                         if (actual_length <= (length - 2)) {
234
235                                 info ("%s - actual: %d", __FUNCTION__, actual_length);
236
237                                 for (i = 0; i < actual_length; i++) {
238                                         tty_insert_flip_char (port->tty, data[i], 0);
239                                 }
240                                 tty_flip_buffer_push (port->tty);
241                         } else {
242                                 err ("%s - inconsistent lengths %d:%d", __FUNCTION__,
243                                      actual_length, length);
244                         }
245                 } else {
246                         err ("%s - bad CRC %x", __FUNCTION__, fcs);
247                 }
248         } else {
249                 for (i = 0; i < length; i++) {
250                         tty_insert_flip_char (port->tty, data[i], 0);
251                 }
252                 tty_flip_buffer_push (port->tty);
253         }
254
255         /* Continue trying to always read  */
256         usb_fill_bulk_urb (urb, port->serial->dev,
257                        usb_rcvbulkpipe (port->serial->dev, port->bulk_in_endpointAddress),
258                        urb->transfer_buffer, urb->transfer_buffer_length,
259                        safe_read_bulk_callback, port);
260
261         if ((result = usb_submit_urb (urb, GFP_ATOMIC))) {
262                 err ("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
263         }
264 }
265
266 static int safe_write (struct usb_serial_port *port, const unsigned char *buf, int count)
267 {
268         unsigned char *data;
269         int result;
270         int i;
271         int packet_length;
272
273         dbg ("safe_write port: %p %d urb: %p count: %d", port, port->number, port->write_urb,
274              count);
275
276         if (!port->write_urb) {
277                 dbg ("%s - write urb NULL", __FUNCTION__);
278                 return (0);
279         }
280
281         dbg ("safe_write write_urb: %d transfer_buffer_length",
282              port->write_urb->transfer_buffer_length);
283
284         if (!port->write_urb->transfer_buffer_length) {
285                 dbg ("%s - write urb transfer_buffer_length zero", __FUNCTION__);
286                 return (0);
287         }
288         if (count == 0) {
289                 dbg ("%s - write request of 0 bytes", __FUNCTION__);
290                 return (0);
291         }
292         spin_lock_bh(&port->lock);
293         if (port->write_urb_busy) {
294                 spin_unlock_bh(&port->lock);
295                 dbg("%s - already writing", __FUNCTION__);
296                 return 0;
297         }
298         port->write_urb_busy = 1;
299         spin_unlock_bh(&port->lock);
300
301         packet_length = port->bulk_out_size;    // get max packetsize
302
303         i = packet_length - (safe ? 2 : 0);     // get bytes to send
304         count = (count > i) ? i : count;
305
306
307         // get the data into the transfer buffer
308         data = port->write_urb->transfer_buffer;
309         memset (data, '0', packet_length);
310
311         memcpy (data, buf, count);
312
313         if (safe) {
314                 __u16 fcs;
315
316                 // pad if necessary
317                 if (!padded) {
318                         packet_length = count + 2;
319                 }
320                 // set count
321                 data[packet_length - 2] = count << 2;
322                 data[packet_length - 1] = 0;
323
324                 // compute fcs and insert into trailer
325                 fcs = fcs_compute10 (data, packet_length, CRC10_INITFCS);
326                 data[packet_length - 2] |= fcs >> 8;
327                 data[packet_length - 1] |= fcs & 0xff;
328
329                 // set length to send
330                 port->write_urb->transfer_buffer_length = packet_length;
331         } else {
332                 port->write_urb->transfer_buffer_length = count;
333         }
334
335         usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, port->write_urb->transfer_buffer);
336 #ifdef ECHO_TX
337         {
338                 int i;
339                 unsigned char *cp = port->write_urb->transfer_buffer;
340                 for (i = 0; i < port->write_urb->transfer_buffer_length; i++) {
341                         if ((i % 32) == 0) {
342                                 printk ("\nsu[%02x] ", i);
343                         }
344                         printk ("%02x ", *cp++);
345                 }
346                 printk ("\n");
347         }
348 #endif
349         port->write_urb->dev = port->serial->dev;
350         if ((result = usb_submit_urb (port->write_urb, GFP_KERNEL))) {
351                 port->write_urb_busy = 0;
352                 err ("%s - failed submitting write urb, error %d", __FUNCTION__, result);
353                 return 0;
354         }
355         dbg ("%s urb: %p submitted", __FUNCTION__, port->write_urb);
356
357         return (count);
358 }
359
360 static int safe_write_room (struct usb_serial_port *port)
361 {
362         int room = 0;           // Default: no room
363
364         dbg ("%s", __FUNCTION__);
365
366         if (port->write_urb_busy)
367                 room = port->bulk_out_size - (safe ? 2 : 0);
368
369         if (room) {
370                 dbg ("safe_write_room returns %d", room);
371         }
372
373         return (room);
374 }
375
376 static int safe_startup (struct usb_serial *serial)
377 {
378         switch (serial->interface->cur_altsetting->desc.bInterfaceProtocol) {
379         case LINEO_SAFESERIAL_CRC:
380                 break;
381         case LINEO_SAFESERIAL_CRC_PADDED:
382                 padded = 1;
383                 break;
384         default:
385                 return -EINVAL;
386         }
387         return 0;
388 }
389
390 static struct usb_serial_driver safe_device = {
391         .driver = {
392                 .owner =        THIS_MODULE,
393                 .name =         "safe_serial",
394         },
395         .id_table =             id_table,
396         .usb_driver =           &safe_driver,
397         .num_interrupt_in =     NUM_DONT_CARE,
398         .num_bulk_in =          NUM_DONT_CARE,
399         .num_bulk_out =         NUM_DONT_CARE,
400         .num_ports =            1,
401         .write =                safe_write,
402         .write_room =           safe_write_room,
403         .read_bulk_callback =   safe_read_bulk_callback,
404         .attach =               safe_startup,
405 };
406
407 static int __init safe_init (void)
408 {
409         int i, retval;
410
411         info (DRIVER_VERSION " " DRIVER_AUTHOR);
412         info (DRIVER_DESC);
413         info ("vendor: %x product: %x safe: %d padded: %d\n", vendor, product, safe, padded);
414
415         // if we have vendor / product parameters patch them into id list
416         if (vendor || product) {
417                 info ("vendor: %x product: %x\n", vendor, product);
418
419                 for (i = 0; i < ARRAY_SIZE(id_table); i++) {
420                         if (!id_table[i].idVendor && !id_table[i].idProduct) {
421                                 id_table[i].idVendor = vendor;
422                                 id_table[i].idProduct = product;
423                                 break;
424                         }
425                 }
426         }
427
428         retval = usb_serial_register(&safe_device);
429         if (retval)
430                 goto failed_usb_serial_register;
431         retval = usb_register(&safe_driver);
432         if (retval)
433                 goto failed_usb_register;
434
435         return 0;
436 failed_usb_register:
437         usb_serial_deregister(&safe_device);
438 failed_usb_serial_register:
439         return retval;
440 }
441
442 static void __exit safe_exit (void)
443 {
444         usb_deregister (&safe_driver);
445         usb_serial_deregister (&safe_device);
446 }
447
448 module_init (safe_init);
449 module_exit (safe_exit);