xref: /linux/drivers/usb/serial/kl5kusb105.c (revision c411ed854584a71b0e86ac3019b60e4789d88086)
1 /*
2  * KLSI KL5KUSB105 chip RS232 converter driver
3  *
4  *   Copyright (C) 2010 Johan Hovold <jhovold@gmail.com>
5  *   Copyright (C) 2001 Utz-Uwe Haus <haus@uuhaus.de>
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  * All information about the device was acquired using SniffUSB ans snoopUSB
13  * on Windows98.
14  * It was written out of frustration with the PalmConnect USB Serial adapter
15  * sold by Palm Inc.
16  * Neither Palm, nor their contractor (MCCI) or their supplier (KLSI) provided
17  * information that was not already available.
18  *
19  * It seems that KLSI bought some silicon-design information from ScanLogic,
20  * whose SL11R processor is at the core of the KL5KUSB chipset from KLSI.
21  * KLSI has firmware available for their devices; it is probable that the
22  * firmware differs from that used by KLSI in their products. If you have an
23  * original KLSI device and can provide some information on it, I would be
24  * most interested in adding support for it here. If you have any information
25  * on the protocol used (or find errors in my reverse-engineered stuff), please
26  * let me know.
27  *
28  * The code was only tested with a PalmConnect USB adapter; if you
29  * are adventurous, try it with any KLSI-based device and let me know how it
30  * breaks so that I can fix it!
31  */
32 
33 /* TODO:
34  *	check modem line signals
35  *	implement handshaking or decide that we do not support it
36  */
37 
38 #include <linux/kernel.h>
39 #include <linux/errno.h>
40 #include <linux/slab.h>
41 #include <linux/tty.h>
42 #include <linux/tty_driver.h>
43 #include <linux/tty_flip.h>
44 #include <linux/module.h>
45 #include <linux/uaccess.h>
46 #include <asm/unaligned.h>
47 #include <linux/usb.h>
48 #include <linux/usb/serial.h>
49 #include "kl5kusb105.h"
50 
51 #define DRIVER_AUTHOR "Utz-Uwe Haus <haus@uuhaus.de>, Johan Hovold <jhovold@gmail.com>"
52 #define DRIVER_DESC "KLSI KL5KUSB105 chipset USB->Serial Converter driver"
53 
54 
55 /*
56  * Function prototypes
57  */
58 static int klsi_105_port_probe(struct usb_serial_port *port);
59 static int klsi_105_port_remove(struct usb_serial_port *port);
60 static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
61 static void klsi_105_close(struct usb_serial_port *port);
62 static void klsi_105_set_termios(struct tty_struct *tty,
63 			struct usb_serial_port *port, struct ktermios *old);
64 static int  klsi_105_tiocmget(struct tty_struct *tty);
65 static void klsi_105_process_read_urb(struct urb *urb);
66 static int klsi_105_prepare_write_buffer(struct usb_serial_port *port,
67 						void *dest, size_t size);
68 
69 /*
70  * All of the device info needed for the KLSI converters.
71  */
72 static const struct usb_device_id id_table[] = {
73 	{ USB_DEVICE(PALMCONNECT_VID, PALMCONNECT_PID) },
74 	{ USB_DEVICE(KLSI_VID, KLSI_KL5KUSB105D_PID) },
75 	{ }		/* Terminating entry */
76 };
77 
78 MODULE_DEVICE_TABLE(usb, id_table);
79 
80 static struct usb_serial_driver kl5kusb105d_device = {
81 	.driver = {
82 		.owner =	THIS_MODULE,
83 		.name =		"kl5kusb105d",
84 	},
85 	.description =		"KL5KUSB105D / PalmConnect",
86 	.id_table =		id_table,
87 	.num_ports =		1,
88 	.bulk_out_size =	64,
89 	.open =			klsi_105_open,
90 	.close =		klsi_105_close,
91 	.set_termios =		klsi_105_set_termios,
92 	.tiocmget =		klsi_105_tiocmget,
93 	.port_probe =		klsi_105_port_probe,
94 	.port_remove =		klsi_105_port_remove,
95 	.throttle =		usb_serial_generic_throttle,
96 	.unthrottle =		usb_serial_generic_unthrottle,
97 	.process_read_urb =	klsi_105_process_read_urb,
98 	.prepare_write_buffer =	klsi_105_prepare_write_buffer,
99 };
100 
101 static struct usb_serial_driver * const serial_drivers[] = {
102 	&kl5kusb105d_device, NULL
103 };
104 
105 struct klsi_105_port_settings {
106 	u8	pktlen;		/* always 5, it seems */
107 	u8	baudrate;
108 	u8	databits;
109 	u8	unknown1;
110 	u8	unknown2;
111 };
112 
113 struct klsi_105_private {
114 	struct klsi_105_port_settings	cfg;
115 	unsigned long			line_state; /* modem line settings */
116 	spinlock_t			lock;
117 };
118 
119 
120 /*
121  * Handle vendor specific USB requests
122  */
123 
124 
125 #define KLSI_TIMEOUT	 5000 /* default urb timeout */
126 
127 static int klsi_105_chg_port_settings(struct usb_serial_port *port,
128 				      struct klsi_105_port_settings *settings)
129 {
130 	int rc;
131 
132 	rc = usb_control_msg(port->serial->dev,
133 			usb_sndctrlpipe(port->serial->dev, 0),
134 			KL5KUSB105A_SIO_SET_DATA,
135 			USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_INTERFACE,
136 			0, /* value */
137 			0, /* index */
138 			settings,
139 			sizeof(struct klsi_105_port_settings),
140 			KLSI_TIMEOUT);
141 	if (rc < 0)
142 		dev_err(&port->dev,
143 			"Change port settings failed (error = %d)\n", rc);
144 
145 	dev_dbg(&port->dev,
146 		"pktlen %u, baudrate 0x%02x, databits %u, u1 %u, u2 %u\n",
147 		settings->pktlen, settings->baudrate, settings->databits,
148 		settings->unknown1, settings->unknown2);
149 
150 	return rc;
151 }
152 
153 /* translate a 16-bit status value from the device to linux's TIO bits */
154 static unsigned long klsi_105_status2linestate(const __u16 status)
155 {
156 	unsigned long res = 0;
157 
158 	res =   ((status & KL5KUSB105A_DSR) ? TIOCM_DSR : 0)
159 	      | ((status & KL5KUSB105A_CTS) ? TIOCM_CTS : 0)
160 	      ;
161 
162 	return res;
163 }
164 
165 /*
166  * Read line control via vendor command and return result through
167  * *line_state_p
168  */
169 /* It seems that the status buffer has always only 2 bytes length */
170 #define KLSI_STATUSBUF_LEN	2
171 static int klsi_105_get_line_state(struct usb_serial_port *port,
172 				   unsigned long *line_state_p)
173 {
174 	int rc;
175 	u8 *status_buf;
176 	__u16 status;
177 
178 	status_buf = kmalloc(KLSI_STATUSBUF_LEN, GFP_KERNEL);
179 	if (!status_buf)
180 		return -ENOMEM;
181 
182 	status_buf[0] = 0xff;
183 	status_buf[1] = 0xff;
184 	rc = usb_control_msg(port->serial->dev,
185 			     usb_rcvctrlpipe(port->serial->dev, 0),
186 			     KL5KUSB105A_SIO_POLL,
187 			     USB_TYPE_VENDOR | USB_DIR_IN,
188 			     0, /* value */
189 			     0, /* index */
190 			     status_buf, KLSI_STATUSBUF_LEN,
191 			     10000
192 			     );
193 	if (rc != KLSI_STATUSBUF_LEN) {
194 		dev_err(&port->dev, "reading line status failed: %d\n", rc);
195 		if (rc >= 0)
196 			rc = -EIO;
197 	} else {
198 		status = get_unaligned_le16(status_buf);
199 
200 		dev_dbg(&port->dev, "read status %02x %02x\n",
201 			status_buf[0], status_buf[1]);
202 
203 		*line_state_p = klsi_105_status2linestate(status);
204 	}
205 
206 	kfree(status_buf);
207 	return rc;
208 }
209 
210 
211 /*
212  * Driver's tty interface functions
213  */
214 
215 static int klsi_105_port_probe(struct usb_serial_port *port)
216 {
217 	struct klsi_105_private *priv;
218 
219 	priv = kmalloc(sizeof(*priv), GFP_KERNEL);
220 	if (!priv)
221 		return -ENOMEM;
222 
223 	/* set initial values for control structures */
224 	priv->cfg.pktlen    = 5;
225 	priv->cfg.baudrate  = kl5kusb105a_sio_b9600;
226 	priv->cfg.databits  = kl5kusb105a_dtb_8;
227 	priv->cfg.unknown1  = 0;
228 	priv->cfg.unknown2  = 1;
229 
230 	priv->line_state    = 0;
231 
232 	spin_lock_init(&priv->lock);
233 
234 	usb_set_serial_port_data(port, priv);
235 
236 	return 0;
237 }
238 
239 static int klsi_105_port_remove(struct usb_serial_port *port)
240 {
241 	struct klsi_105_private *priv;
242 
243 	priv = usb_get_serial_port_data(port);
244 	kfree(priv);
245 
246 	return 0;
247 }
248 
249 static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
250 {
251 	struct klsi_105_private *priv = usb_get_serial_port_data(port);
252 	int retval = 0;
253 	int rc;
254 	unsigned long line_state;
255 	struct klsi_105_port_settings *cfg;
256 	unsigned long flags;
257 
258 	/* Do a defined restart:
259 	 * Set up sane default baud rate and send the 'READ_ON'
260 	 * vendor command.
261 	 * FIXME: set modem line control (how?)
262 	 * Then read the modem line control and store values in
263 	 * priv->line_state.
264 	 */
265 	cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
266 	if (!cfg)
267 		return -ENOMEM;
268 
269 	cfg->pktlen   = 5;
270 	cfg->baudrate = kl5kusb105a_sio_b9600;
271 	cfg->databits = kl5kusb105a_dtb_8;
272 	cfg->unknown1 = 0;
273 	cfg->unknown2 = 1;
274 	klsi_105_chg_port_settings(port, cfg);
275 
276 	spin_lock_irqsave(&priv->lock, flags);
277 	priv->cfg.pktlen   = cfg->pktlen;
278 	priv->cfg.baudrate = cfg->baudrate;
279 	priv->cfg.databits = cfg->databits;
280 	priv->cfg.unknown1 = cfg->unknown1;
281 	priv->cfg.unknown2 = cfg->unknown2;
282 	spin_unlock_irqrestore(&priv->lock, flags);
283 
284 	/* READ_ON and urb submission */
285 	rc = usb_serial_generic_open(tty, port);
286 	if (rc) {
287 		retval = rc;
288 		goto err_free_cfg;
289 	}
290 
291 	rc = usb_control_msg(port->serial->dev,
292 			     usb_sndctrlpipe(port->serial->dev, 0),
293 			     KL5KUSB105A_SIO_CONFIGURE,
294 			     USB_TYPE_VENDOR|USB_DIR_OUT|USB_RECIP_INTERFACE,
295 			     KL5KUSB105A_SIO_CONFIGURE_READ_ON,
296 			     0, /* index */
297 			     NULL,
298 			     0,
299 			     KLSI_TIMEOUT);
300 	if (rc < 0) {
301 		dev_err(&port->dev, "Enabling read failed (error = %d)\n", rc);
302 		retval = rc;
303 		goto err_generic_close;
304 	} else
305 		dev_dbg(&port->dev, "%s - enabled reading\n", __func__);
306 
307 	rc = klsi_105_get_line_state(port, &line_state);
308 	if (rc < 0) {
309 		retval = rc;
310 		goto err_disable_read;
311 	}
312 
313 	spin_lock_irqsave(&priv->lock, flags);
314 	priv->line_state = line_state;
315 	spin_unlock_irqrestore(&priv->lock, flags);
316 	dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__,
317 			line_state);
318 
319 	return 0;
320 
321 err_disable_read:
322 	usb_control_msg(port->serial->dev,
323 			     usb_sndctrlpipe(port->serial->dev, 0),
324 			     KL5KUSB105A_SIO_CONFIGURE,
325 			     USB_TYPE_VENDOR | USB_DIR_OUT,
326 			     KL5KUSB105A_SIO_CONFIGURE_READ_OFF,
327 			     0, /* index */
328 			     NULL, 0,
329 			     KLSI_TIMEOUT);
330 err_generic_close:
331 	usb_serial_generic_close(port);
332 err_free_cfg:
333 	kfree(cfg);
334 
335 	return retval;
336 }
337 
338 static void klsi_105_close(struct usb_serial_port *port)
339 {
340 	int rc;
341 
342 	/* send READ_OFF */
343 	rc = usb_control_msg(port->serial->dev,
344 			     usb_sndctrlpipe(port->serial->dev, 0),
345 			     KL5KUSB105A_SIO_CONFIGURE,
346 			     USB_TYPE_VENDOR | USB_DIR_OUT,
347 			     KL5KUSB105A_SIO_CONFIGURE_READ_OFF,
348 			     0, /* index */
349 			     NULL, 0,
350 			     KLSI_TIMEOUT);
351 	if (rc < 0)
352 		dev_err(&port->dev, "failed to disable read: %d\n", rc);
353 
354 	/* shutdown our bulk reads and writes */
355 	usb_serial_generic_close(port);
356 }
357 
358 /* We need to write a complete 64-byte data block and encode the
359  * number actually sent in the first double-byte, LSB-order. That
360  * leaves at most 62 bytes of payload.
361  */
362 #define KLSI_HDR_LEN		2
363 static int klsi_105_prepare_write_buffer(struct usb_serial_port *port,
364 						void *dest, size_t size)
365 {
366 	unsigned char *buf = dest;
367 	int count;
368 
369 	count = kfifo_out_locked(&port->write_fifo, buf + KLSI_HDR_LEN, size,
370 								&port->lock);
371 	put_unaligned_le16(count, buf);
372 
373 	return count + KLSI_HDR_LEN;
374 }
375 
376 /* The data received is preceded by a length double-byte in LSB-first order.
377  */
378 static void klsi_105_process_read_urb(struct urb *urb)
379 {
380 	struct usb_serial_port *port = urb->context;
381 	unsigned char *data = urb->transfer_buffer;
382 	unsigned len;
383 
384 	/* empty urbs seem to happen, we ignore them */
385 	if (!urb->actual_length)
386 		return;
387 
388 	if (urb->actual_length <= KLSI_HDR_LEN) {
389 		dev_dbg(&port->dev, "%s - malformed packet\n", __func__);
390 		return;
391 	}
392 
393 	len = get_unaligned_le16(data);
394 	if (len > urb->actual_length - KLSI_HDR_LEN) {
395 		dev_dbg(&port->dev, "%s - packet length mismatch\n", __func__);
396 		len = urb->actual_length - KLSI_HDR_LEN;
397 	}
398 
399 	tty_insert_flip_string(&port->port, data + KLSI_HDR_LEN, len);
400 	tty_flip_buffer_push(&port->port);
401 }
402 
403 static void klsi_105_set_termios(struct tty_struct *tty,
404 				 struct usb_serial_port *port,
405 				 struct ktermios *old_termios)
406 {
407 	struct klsi_105_private *priv = usb_get_serial_port_data(port);
408 	struct device *dev = &port->dev;
409 	unsigned int iflag = tty->termios.c_iflag;
410 	unsigned int old_iflag = old_termios->c_iflag;
411 	unsigned int cflag = tty->termios.c_cflag;
412 	unsigned int old_cflag = old_termios->c_cflag;
413 	struct klsi_105_port_settings *cfg;
414 	unsigned long flags;
415 	speed_t baud;
416 
417 	cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
418 	if (!cfg)
419 		return;
420 
421 	/* lock while we are modifying the settings */
422 	spin_lock_irqsave(&priv->lock, flags);
423 
424 	/*
425 	 * Update baud rate
426 	 */
427 	baud = tty_get_baud_rate(tty);
428 
429 	switch (baud) {
430 	case 0: /* handled below */
431 		break;
432 	case 1200:
433 		priv->cfg.baudrate = kl5kusb105a_sio_b1200;
434 		break;
435 	case 2400:
436 		priv->cfg.baudrate = kl5kusb105a_sio_b2400;
437 		break;
438 	case 4800:
439 		priv->cfg.baudrate = kl5kusb105a_sio_b4800;
440 		break;
441 	case 9600:
442 		priv->cfg.baudrate = kl5kusb105a_sio_b9600;
443 		break;
444 	case 19200:
445 		priv->cfg.baudrate = kl5kusb105a_sio_b19200;
446 		break;
447 	case 38400:
448 		priv->cfg.baudrate = kl5kusb105a_sio_b38400;
449 		break;
450 	case 57600:
451 		priv->cfg.baudrate = kl5kusb105a_sio_b57600;
452 		break;
453 	case 115200:
454 		priv->cfg.baudrate = kl5kusb105a_sio_b115200;
455 		break;
456 	default:
457 		dev_dbg(dev, "unsupported baudrate, using 9600\n");
458 		priv->cfg.baudrate = kl5kusb105a_sio_b9600;
459 		baud = 9600;
460 		break;
461 	}
462 
463 	/*
464 	 * FIXME: implement B0 handling
465 	 *
466 	 * Maybe this should be simulated by sending read disable and read
467 	 * enable messages?
468 	 */
469 
470 	tty_encode_baud_rate(tty, baud, baud);
471 
472 	if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
473 		/* set the number of data bits */
474 		switch (cflag & CSIZE) {
475 		case CS5:
476 			dev_dbg(dev, "%s - 5 bits/byte not supported\n", __func__);
477 			spin_unlock_irqrestore(&priv->lock, flags);
478 			goto err;
479 		case CS6:
480 			dev_dbg(dev, "%s - 6 bits/byte not supported\n", __func__);
481 			spin_unlock_irqrestore(&priv->lock, flags);
482 			goto err;
483 		case CS7:
484 			priv->cfg.databits = kl5kusb105a_dtb_7;
485 			break;
486 		case CS8:
487 			priv->cfg.databits = kl5kusb105a_dtb_8;
488 			break;
489 		default:
490 			dev_err(dev, "CSIZE was not CS5-CS8, using default of 8\n");
491 			priv->cfg.databits = kl5kusb105a_dtb_8;
492 			break;
493 		}
494 	}
495 
496 	/*
497 	 * Update line control register (LCR)
498 	 */
499 	if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))
500 	    || (cflag & CSTOPB) != (old_cflag & CSTOPB)) {
501 		/* Not currently supported */
502 		tty->termios.c_cflag &= ~(PARENB|PARODD|CSTOPB);
503 	}
504 	/*
505 	 * Set flow control: well, I do not really now how to handle DTR/RTS.
506 	 * Just do what we have seen with SniffUSB on Win98.
507 	 */
508 	if ((iflag & IXOFF) != (old_iflag & IXOFF)
509 	    || (iflag & IXON) != (old_iflag & IXON)
510 	    ||  (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
511 		/* Not currently supported */
512 		tty->termios.c_cflag &= ~CRTSCTS;
513 	}
514 	memcpy(cfg, &priv->cfg, sizeof(*cfg));
515 	spin_unlock_irqrestore(&priv->lock, flags);
516 
517 	/* now commit changes to device */
518 	klsi_105_chg_port_settings(port, cfg);
519 err:
520 	kfree(cfg);
521 }
522 
523 static int klsi_105_tiocmget(struct tty_struct *tty)
524 {
525 	struct usb_serial_port *port = tty->driver_data;
526 	struct klsi_105_private *priv = usb_get_serial_port_data(port);
527 	unsigned long flags;
528 	int rc;
529 	unsigned long line_state;
530 
531 	rc = klsi_105_get_line_state(port, &line_state);
532 	if (rc < 0) {
533 		dev_err(&port->dev,
534 			"Reading line control failed (error = %d)\n", rc);
535 		/* better return value? EAGAIN? */
536 		return rc;
537 	}
538 
539 	spin_lock_irqsave(&priv->lock, flags);
540 	priv->line_state = line_state;
541 	spin_unlock_irqrestore(&priv->lock, flags);
542 	dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__, line_state);
543 	return (int)line_state;
544 }
545 
546 module_usb_serial_driver(serial_drivers, id_table);
547 
548 MODULE_AUTHOR(DRIVER_AUTHOR);
549 MODULE_DESCRIPTION(DRIVER_DESC);
550 MODULE_LICENSE("GPL");
551