projects/linux·blob master · refs

309 lines · 9.9 KiB

1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Safe Encapsulated USB Serial Driver
4 *
5 * Copyright (C) 2010 Johan Hovold <[email protected]>
6 * Copyright (C) 2001 Lineo
7 * Copyright (C) 2001 Hewlett-Packard
8 *
9 * By:
10 * Stuart Lynne <[email protected]>, Tom Rushworth <[email protected]>
11 */
12
13/*
14 * The encapsultaion is designed to overcome difficulties with some USB
15 * hardware.
16 *
17 * While the USB protocol has a CRC over the data while in transit, i.e. while
18 * being carried over the bus, there is no end to end protection. If the
19 * hardware has any problems getting the data into or out of the USB transmit
20 * and receive FIFO's then data can be lost.
21 *
22 * This protocol adds a two byte trailer to each USB packet to specify the
23 * number of bytes of valid data and a 10 bit CRC that will allow the receiver
24 * to verify that the entire USB packet was received without error.
25 *
26 * Because in this case the sender and receiver are the class and function
27 * drivers there is now end to end protection.
28 *
29 * There is an additional option that can be used to force all transmitted
30 * packets to be padded to the maximum packet size. This provides a work
31 * around for some devices which have problems with small USB packets.
32 *
33 * Assuming a packetsize of N:
34 *
35 * 0..N-2 data and optional padding
36 *
37 * N-2 bits 7-2 - number of bytes of valid data
38 * bits 1-0 top two bits of 10 bit CRC
39 * N-1 bottom 8 bits of 10 bit CRC
40 *
41 *
42 * | Data Length | 10 bit CRC |
43 * + 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 | 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 +
44 *
45 * The 10 bit CRC is computed across the sent data, followed by the trailer
46 * with the length set and the CRC set to zero. The CRC is then OR'd into
47 * the trailer.
48 *
49 * When received a 10 bit CRC is computed over the entire frame including
50 * the trailer and should be equal to zero.
51 *
52 * Two module parameters are used to control the encapsulation, if both are
53 * turned of the module works as a simple serial device with NO
54 * encapsulation.
55 *
56 * See linux/drivers/usbd/serial_fd for a device function driver
57 * implementation of this.
58 *
59 */
60
61#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
62
63#include <linux/kernel.h>
64#include <linux/errno.h>
65#include <linux/gfp.h>
66#include <linux/tty.h>
67#include <linux/tty_flip.h>
68#include <linux/module.h>
69#include <linux/spinlock.h>
70#include <linux/usb.h>
71#include <linux/usb/serial.h>
72
73static bool safe = true;
74static bool padded = IS_ENABLED(CONFIG_USB_SERIAL_SAFE_PADDED);
75
76#define DRIVER_AUTHOR "[email protected], [email protected], Johan Hovold <[email protected]>"
77#define DRIVER_DESC "USB Safe Encapsulated Serial"
78
79MODULE_AUTHOR(DRIVER_AUTHOR);
80MODULE_DESCRIPTION(DRIVER_DESC);
81MODULE_LICENSE("GPL");
82
83module_param(safe, bool, 0);
84MODULE_PARM_DESC(safe, "Turn Safe Encapsulation On/Off");
85
86module_param(padded, bool, 0);
87MODULE_PARM_DESC(padded, "Pad to full wMaxPacketSize On/Off");
88
89#define CDC_DEVICE_CLASS 0x02
90
91#define CDC_INTERFACE_CLASS 0x02
92#define CDC_INTERFACE_SUBCLASS 0x06
93
94#define LINEO_INTERFACE_CLASS 0xff
95
96#define LINEO_INTERFACE_SUBCLASS_SAFENET 0x01
97#define LINEO_SAFENET_CRC 0x01
98#define LINEO_SAFENET_CRC_PADDED 0x02
99
100#define LINEO_INTERFACE_SUBCLASS_SAFESERIAL 0x02
101#define LINEO_SAFESERIAL_CRC 0x01
102#define LINEO_SAFESERIAL_CRC_PADDED 0x02
103
104
105#define MY_USB_DEVICE(vend, prod, dc, ic, isc) \
106 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
107 USB_DEVICE_ID_MATCH_DEV_CLASS | \
108 USB_DEVICE_ID_MATCH_INT_CLASS | \
109 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
110 .idVendor = (vend), \
111 .idProduct = (prod),\
112 .bDeviceClass = (dc),\
113 .bInterfaceClass = (ic), \
114 .bInterfaceSubClass = (isc),
115
116static const struct usb_device_id id_table[] = {
117 {MY_USB_DEVICE(0x49f, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Itsy */
118 {MY_USB_DEVICE(0x3f0, 0x2101, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Calypso */
119 {MY_USB_DEVICE(0x4dd, 0x8001, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Iris */
120 {MY_USB_DEVICE(0x4dd, 0x8002, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
121 {MY_USB_DEVICE(0x4dd, 0x8003, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
122 {MY_USB_DEVICE(0x4dd, 0x8004, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
123 {MY_USB_DEVICE(0x5f9, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Sharp tmp */
124 {} /* terminating entry */
125};
126
127MODULE_DEVICE_TABLE(usb, id_table);
128
129static const __u16 crc10_table[256] = {
130 0x000, 0x233, 0x255, 0x066, 0x299, 0x0aa, 0x0cc, 0x2ff,
131 0x301, 0x132, 0x154, 0x367, 0x198, 0x3ab, 0x3cd, 0x1fe,
132 0x031, 0x202, 0x264, 0x057, 0x2a8, 0x09b, 0x0fd, 0x2ce,
133 0x330, 0x103, 0x165, 0x356, 0x1a9, 0x39a, 0x3fc, 0x1cf,
134 0x062, 0x251, 0x237, 0x004, 0x2fb, 0x0c8, 0x0ae, 0x29d,
135 0x363, 0x150, 0x136, 0x305, 0x1fa, 0x3c9, 0x3af, 0x19c,
136 0x053, 0x260, 0x206, 0x035, 0x2ca, 0x0f9, 0x09f, 0x2ac,
137 0x352, 0x161, 0x107, 0x334, 0x1cb, 0x3f8, 0x39e, 0x1ad,
138 0x0c4, 0x2f7, 0x291, 0x0a2, 0x25d, 0x06e, 0x008, 0x23b,
139 0x3c5, 0x1f6, 0x190, 0x3a3, 0x15c, 0x36f, 0x309, 0x13a,
140 0x0f5, 0x2c6, 0x2a0, 0x093, 0x26c, 0x05f, 0x039, 0x20a,
141 0x3f4, 0x1c7, 0x1a1, 0x392, 0x16d, 0x35e, 0x338, 0x10b,
142 0x0a6, 0x295, 0x2f3, 0x0c0, 0x23f, 0x00c, 0x06a, 0x259,
143 0x3a7, 0x194, 0x1f2, 0x3c1, 0x13e, 0x30d, 0x36b, 0x158,
144 0x097, 0x2a4, 0x2c2, 0x0f1, 0x20e, 0x03d, 0x05b, 0x268,
145 0x396, 0x1a5, 0x1c3, 0x3f0, 0x10f, 0x33c, 0x35a, 0x169,
146 0x188, 0x3bb, 0x3dd, 0x1ee, 0x311, 0x122, 0x144, 0x377,
147 0x289, 0x0ba, 0x0dc, 0x2ef, 0x010, 0x223, 0x245, 0x076,
148 0x1b9, 0x38a, 0x3ec, 0x1df, 0x320, 0x113, 0x175, 0x346,
149 0x2b8, 0x08b, 0x0ed, 0x2de, 0x021, 0x212, 0x274, 0x047,
150 0x1ea, 0x3d9, 0x3bf, 0x18c, 0x373, 0x140, 0x126, 0x315,
151 0x2eb, 0x0d8, 0x0be, 0x28d, 0x072, 0x241, 0x227, 0x014,
152 0x1db, 0x3e8, 0x38e, 0x1bd, 0x342, 0x171, 0x117, 0x324,
153 0x2da, 0x0e9, 0x08f, 0x2bc, 0x043, 0x270, 0x216, 0x025,
154 0x14c, 0x37f, 0x319, 0x12a, 0x3d5, 0x1e6, 0x180, 0x3b3,
155 0x24d, 0x07e, 0x018, 0x22b, 0x0d4, 0x2e7, 0x281, 0x0b2,
156 0x17d, 0x34e, 0x328, 0x11b, 0x3e4, 0x1d7, 0x1b1, 0x382,
157 0x27c, 0x04f, 0x029, 0x21a, 0x0e5, 0x2d6, 0x2b0, 0x083,
158 0x12e, 0x31d, 0x37b, 0x148, 0x3b7, 0x184, 0x1e2, 0x3d1,
159 0x22f, 0x01c, 0x07a, 0x249, 0x0b6, 0x285, 0x2e3, 0x0d0,
160 0x11f, 0x32c, 0x34a, 0x179, 0x386, 0x1b5, 0x1d3, 0x3e0,
161 0x21e, 0x02d, 0x04b, 0x278, 0x087, 0x2b4, 0x2d2, 0x0e1,
162};
163
164#define CRC10_INITFCS 0x000 /* Initial FCS value */
165#define CRC10_GOODFCS 0x000 /* Good final FCS value */
166#define CRC10_FCS(fcs, c) ((((fcs) << 8) & 0x3ff) ^ crc10_table[((fcs) >> 2) & 0xff] ^ (c))
167
168/**
169 * fcs_compute10 - memcpy and calculate 10 bit CRC across buffer
170 * @sp: pointer to buffer
171 * @len: number of bytes
172 * @fcs: starting FCS
173 *
174 * Perform a memcpy and calculate fcs using ppp 10bit CRC algorithm. Return
175 * new 10 bit FCS.
176 */
177static inline __u16 fcs_compute10(unsigned char *sp, int len, __u16 fcs)
178{
179 for (; len-- > 0; fcs = CRC10_FCS(fcs, *sp++));
180 return fcs;
181}
182
183static void safe_process_read_urb(struct urb *urb)
184{
185 struct usb_serial_port *port = urb->context;
186 unsigned char *data = urb->transfer_buffer;
187 unsigned char length = urb->actual_length;
188 int actual_length;
189 __u16 fcs;
190
191 if (!length)
192 return;
193
194 if (!safe)
195 goto out;
196
197 if (length < 2) {
198 dev_err(&port->dev, "malformed packet\n");
199 return;
200 }
201
202 fcs = fcs_compute10(data, length, CRC10_INITFCS);
203 if (fcs) {
204 dev_err(&port->dev, "%s - bad CRC %x\n", __func__, fcs);
205 return;
206 }
207
208 actual_length = data[length - 2] >> 2;
209 if (actual_length > (length - 2)) {
210 dev_err(&port->dev, "%s - inconsistent lengths %d:%d\n",
211 __func__, actual_length, length);
212 return;
213 }
214 dev_info(&urb->dev->dev, "%s - actual: %d\n", __func__, actual_length);
215 length = actual_length;
216out:
217 tty_insert_flip_string(&port->port, data, length);
218 tty_flip_buffer_push(&port->port);
219}
220
221static int safe_prepare_write_buffer(struct usb_serial_port *port,
222 void *dest, size_t size)
223{
224 unsigned char *buf = dest;
225 int count;
226 int trailer_len;
227 int pkt_len;
228 __u16 fcs;
229
230 trailer_len = safe ? 2 : 0;
231
232 count = kfifo_out_locked(&port->write_fifo, buf, size - trailer_len,
233 &port->lock);
234 if (!safe)
235 return count;
236
237 /* pad if necessary */
238 if (padded) {
239 pkt_len = size;
240 memset(buf + count, '0', pkt_len - count - trailer_len);
241 } else {
242 pkt_len = count + trailer_len;
243 }
244
245 /* set count */
246 buf[pkt_len - 2] = count << 2;
247 buf[pkt_len - 1] = 0;
248
249 /* compute fcs and insert into trailer */
250 fcs = fcs_compute10(buf, pkt_len, CRC10_INITFCS);
251 buf[pkt_len - 2] |= fcs >> 8;
252 buf[pkt_len - 1] |= fcs & 0xff;
253
254 return pkt_len;
255}
256
257static int safe_startup(struct usb_serial *serial)
258{
259 struct usb_interface_descriptor *desc;
260 int bulk_out_size;
261
262 if (serial->dev->descriptor.bDeviceClass != CDC_DEVICE_CLASS)
263 return -ENODEV;
264
265 desc = &serial->interface->cur_altsetting->desc;
266
267 if (desc->bInterfaceClass != LINEO_INTERFACE_CLASS)
268 return -ENODEV;
269 if (desc->bInterfaceSubClass != LINEO_INTERFACE_SUBCLASS_SAFESERIAL)
270 return -ENODEV;
271
272 switch (desc->bInterfaceProtocol) {
273 case LINEO_SAFESERIAL_CRC:
274 break;
275 case LINEO_SAFESERIAL_CRC_PADDED:
276 padded = true;
277 break;
278 default:
279 return -EINVAL;
280 }
281
282 /*
283 * The bulk-out buffer needs to be large enough for the two-byte
284 * trailer in safe mode, but assume anything smaller than eight bytes
285 * is broken.
286 */
287 bulk_out_size = serial->port[0]->bulk_out_size;
288 if (bulk_out_size > 0 && bulk_out_size < 8)
289 return -EINVAL;
290
291 return 0;
292}
293
294static struct usb_serial_driver safe_device = {
295 .driver = {
296 .name = "safe_serial",
297 },
298 .id_table = id_table,
299 .num_ports = 1,
300 .process_read_urb = safe_process_read_urb,
301 .prepare_write_buffer = safe_prepare_write_buffer,
302 .attach = safe_startup,
303};
304
305static struct usb_serial_driver * const serial_drivers[] = {
306 &safe_device, NULL
307};
308
309module_usb_serial_driver(serial_drivers, id_table);