blob: e020ad28a00c9d566d24143175cb50baf1e07a90 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * KLSI KL5KUSB105 chip RS232 converter driver
3 *
Johan Hovold60b30132010-05-19 00:01:40 +02004 * Copyright (C) 2010 Johan Hovold <jhovold@gmail.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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 *
Alan Cox0c265f42008-07-22 11:14:00 +010019 * It seems that KLSI bought some silicon-design information from ScanLogic,
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 * 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
Alan Cox0c265f42008-07-22 11:14:00 +010023 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 * 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/kernel.h>
39#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#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>
Alan Cox0c265f42008-07-22 11:14:00 +010045#include <linux/uaccess.h>
Al Virofd05e722008-04-28 07:00:16 +010046#include <asm/unaligned.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070048#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include "kl5kusb105.h"
50
Johan Hovold60b30132010-05-19 00:01:40 +020051#define DRIVER_AUTHOR "Utz-Uwe Haus <haus@uuhaus.de>, Johan Hovold <jhovold@gmail.com>"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#define DRIVER_DESC "KLSI KL5KUSB105 chipset USB->Serial Converter driver"
53
54
55/*
56 * Function prototypes
57 */
Johan Hovold99a6f732012-10-17 13:35:01 +020058static int klsi_105_port_probe(struct usb_serial_port *port);
59static int klsi_105_port_remove(struct usb_serial_port *port);
Alan Coxa509a7e2009-09-19 13:13:26 -070060static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
Alan Cox335f8512009-06-11 12:26:29 +010061static void klsi_105_close(struct usb_serial_port *port);
Alan Cox0c265f42008-07-22 11:14:00 +010062static void klsi_105_set_termios(struct tty_struct *tty,
63 struct usb_serial_port *port, struct ktermios *old);
Alan Cox60b33c12011-02-14 16:26:14 +000064static int klsi_105_tiocmget(struct tty_struct *tty);
Johan Hovold60b30132010-05-19 00:01:40 +020065static void klsi_105_process_read_urb(struct urb *urb);
66static int klsi_105_prepare_write_buffer(struct usb_serial_port *port,
67 void *dest, size_t size);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
69/*
70 * All of the device info needed for the KLSI converters.
71 */
Németh Márton7d40d7e2010-01-10 15:34:24 +010072static const struct usb_device_id id_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 { USB_DEVICE(PALMCONNECT_VID, PALMCONNECT_PID) },
74 { USB_DEVICE(KLSI_VID, KLSI_KL5KUSB105D_PID) },
75 { } /* Terminating entry */
76};
77
Alan Cox0c265f42008-07-22 11:14:00 +010078MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -070080static struct usb_serial_driver kl5kusb105d_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -070081 .driver = {
82 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -070083 .name = "kl5kusb105d",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -070084 },
Johan Hovoldff8c1952010-05-19 00:01:39 +020085 .description = "KL5KUSB105D / PalmConnect",
Johan Hovoldff8c1952010-05-19 00:01:39 +020086 .id_table = id_table,
87 .num_ports = 1,
Johan Hovold60b30132010-05-19 00:01:40 +020088 .bulk_out_size = 64,
Johan Hovoldff8c1952010-05-19 00:01:39 +020089 .open = klsi_105_open,
90 .close = klsi_105_close,
Johan Hovoldff8c1952010-05-19 00:01:39 +020091 .set_termios = klsi_105_set_termios,
92 /*.break_ctl = klsi_105_break_ctl,*/
93 .tiocmget = klsi_105_tiocmget,
Johan Hovold99a6f732012-10-17 13:35:01 +020094 .port_probe = klsi_105_port_probe,
95 .port_remove = klsi_105_port_remove,
Johan Hovold60b30132010-05-19 00:01:40 +020096 .throttle = usb_serial_generic_throttle,
97 .unthrottle = usb_serial_generic_unthrottle,
98 .process_read_urb = klsi_105_process_read_urb,
99 .prepare_write_buffer = klsi_105_prepare_write_buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100};
101
Alan Stern4d2a7af2012-02-23 14:57:09 -0500102static struct usb_serial_driver * const serial_drivers[] = {
103 &kl5kusb105d_device, NULL
104};
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106struct klsi_105_port_settings {
107 __u8 pktlen; /* always 5, it seems */
108 __u8 baudrate;
109 __u8 databits;
110 __u8 unknown1;
111 __u8 unknown2;
112} __attribute__ ((packed));
113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114struct klsi_105_private {
115 struct klsi_105_port_settings cfg;
Alan Cox606d0992006-12-08 02:38:45 -0800116 struct ktermios termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 unsigned long line_state; /* modem line settings */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 spinlock_t lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119};
120
121
122/*
123 * Handle vendor specific USB requests
124 */
125
126
127#define KLSI_TIMEOUT 5000 /* default urb timeout */
128
129static int klsi_105_chg_port_settings(struct usb_serial_port *port,
130 struct klsi_105_port_settings *settings)
131{
132 int rc;
133
Alan Cox0c265f42008-07-22 11:14:00 +0100134 rc = usb_control_msg(port->serial->dev,
135 usb_sndctrlpipe(port->serial->dev, 0),
136 KL5KUSB105A_SIO_SET_DATA,
137 USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_INTERFACE,
138 0, /* value */
139 0, /* index */
140 settings,
141 sizeof(struct klsi_105_port_settings),
142 KLSI_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 if (rc < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700144 dev_err(&port->dev,
145 "Change port settings failed (error = %d)\n", rc);
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700146 dev_info(&port->serial->dev->dev,
147 "%d byte block, baudrate %x, databits %d, u1 %d, u2 %d\n",
148 settings->pktlen, settings->baudrate, settings->databits,
149 settings->unknown1, settings->unknown2);
Alan Cox0c265f42008-07-22 11:14:00 +0100150 return rc;
Johan Hovoldff8c1952010-05-19 00:01:39 +0200151}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153/* translate a 16-bit status value from the device to linux's TIO bits */
154static 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}
Johan Hovoldff8c1952010-05-19 00:01:39 +0200164
Alan Cox0c265f42008-07-22 11:14:00 +0100165/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 * Read line control via vendor command and return result through
Alan Cox0c265f42008-07-22 11:14:00 +0100167 * *line_state_p
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 */
169/* It seems that the status buffer has always only 2 bytes length */
170#define KLSI_STATUSBUF_LEN 2
171static int klsi_105_get_line_state(struct usb_serial_port *port,
172 unsigned long *line_state_p)
173{
174 int rc;
Johan Hovoldabf492e2009-12-28 23:01:52 +0100175 u8 *status_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 __u16 status;
177
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700178 dev_info(&port->serial->dev->dev, "sending SIO Poll request\n");
Johan Hovoldabf492e2009-12-28 23:01:52 +0100179
180 status_buf = kmalloc(KLSI_STATUSBUF_LEN, GFP_KERNEL);
Johan Hovold10c642d2013-12-29 19:22:56 +0100181 if (!status_buf)
Johan Hovoldabf492e2009-12-28 23:01:52 +0100182 return -ENOMEM;
Johan Hovold10c642d2013-12-29 19:22:56 +0100183
Johan Hovoldabf492e2009-12-28 23:01:52 +0100184 status_buf[0] = 0xff;
185 status_buf[1] = 0xff;
Alan Cox0c265f42008-07-22 11:14:00 +0100186 rc = usb_control_msg(port->serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 usb_rcvctrlpipe(port->serial->dev, 0),
188 KL5KUSB105A_SIO_POLL,
Alan Cox0c265f42008-07-22 11:14:00 +0100189 USB_TYPE_VENDOR | USB_DIR_IN,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 0, /* value */
191 0, /* index */
192 status_buf, KLSI_STATUSBUF_LEN,
193 10000
194 );
195 if (rc < 0)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700196 dev_err(&port->dev, "Reading line status failed (error = %d)\n",
197 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 else {
Harvey Harrisonbd2c7842008-05-01 20:52:57 -0700199 status = get_unaligned_le16(status_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Johan Hovoldd9a38a82014-03-12 19:09:42 +0100201 dev_info(&port->serial->dev->dev, "read status %x %x\n",
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700202 status_buf[0], status_buf[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
204 *line_state_p = klsi_105_status2linestate(status);
205 }
Johan Hovoldabf492e2009-12-28 23:01:52 +0100206
207 kfree(status_buf);
Alan Cox0c265f42008-07-22 11:14:00 +0100208 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209}
210
211
212/*
213 * Driver's tty interface functions
214 */
215
Johan Hovold99a6f732012-10-17 13:35:01 +0200216static int klsi_105_port_probe(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
218 struct klsi_105_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Johan Hovold99a6f732012-10-17 13:35:01 +0200220 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
221 if (!priv)
222 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
Johan Hovold99a6f732012-10-17 13:35:01 +0200224 /* set initial values for control structures */
225 priv->cfg.pktlen = 5;
226 priv->cfg.baudrate = kl5kusb105a_sio_b9600;
227 priv->cfg.databits = kl5kusb105a_dtb_8;
228 priv->cfg.unknown1 = 0;
229 priv->cfg.unknown2 = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Johan Hovold99a6f732012-10-17 13:35:01 +0200231 priv->line_state = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
Johan Hovold99a6f732012-10-17 13:35:01 +0200233 spin_lock_init(&priv->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
Johan Hovold99a6f732012-10-17 13:35:01 +0200235 /* priv->termios is left uninitialized until port opening */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Johan Hovold99a6f732012-10-17 13:35:01 +0200237 usb_set_serial_port_data(port, priv);
Alan Cox0c265f42008-07-22 11:14:00 +0100238
Oliver Neukum9306fff2007-03-29 11:23:54 +0200239 return 0;
Johan Hovoldff8c1952010-05-19 00:01:39 +0200240}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
Johan Hovold99a6f732012-10-17 13:35:01 +0200242static int klsi_105_port_remove(struct usb_serial_port *port)
Alan Sternf9c99bb2009-06-02 11:53:55 -0400243{
Johan Hovold99a6f732012-10-17 13:35:01 +0200244 struct klsi_105_private *priv;
Alan Sternf9c99bb2009-06-02 11:53:55 -0400245
Johan Hovold99a6f732012-10-17 13:35:01 +0200246 priv = usb_get_serial_port_data(port);
247 kfree(priv);
248
249 return 0;
Johan Hovoldff8c1952010-05-19 00:01:39 +0200250}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Alan Coxa509a7e2009-09-19 13:13:26 -0700252static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
254 struct klsi_105_private *priv = usb_get_serial_port_data(port);
255 int retval = 0;
256 int rc;
257 int i;
258 unsigned long line_state;
Johan Hovoldabf492e2009-12-28 23:01:52 +0100259 struct klsi_105_port_settings *cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 unsigned long flags;
261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 /* Do a defined restart:
263 * Set up sane default baud rate and send the 'READ_ON'
Alan Cox0c265f42008-07-22 11:14:00 +0100264 * vendor command.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 * FIXME: set modem line control (how?)
266 * Then read the modem line control and store values in
267 * priv->line_state.
268 */
Johan Hovoldabf492e2009-12-28 23:01:52 +0100269 cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
Johan Hovold10c642d2013-12-29 19:22:56 +0100270 if (!cfg)
Johan Hovoldabf492e2009-12-28 23:01:52 +0100271 return -ENOMEM;
Johan Hovold10c642d2013-12-29 19:22:56 +0100272
Johan Hovoldabf492e2009-12-28 23:01:52 +0100273 cfg->pktlen = 5;
274 cfg->baudrate = kl5kusb105a_sio_b9600;
275 cfg->databits = kl5kusb105a_dtb_8;
276 cfg->unknown1 = 0;
277 cfg->unknown2 = 1;
278 klsi_105_chg_port_settings(port, cfg);
Alan Cox0c265f42008-07-22 11:14:00 +0100279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 /* set up termios structure */
Alan Cox0c265f42008-07-22 11:14:00 +0100281 spin_lock_irqsave(&priv->lock, flags);
Alan Coxadc8d742012-07-14 15:31:47 +0100282 priv->termios.c_iflag = tty->termios.c_iflag;
283 priv->termios.c_oflag = tty->termios.c_oflag;
284 priv->termios.c_cflag = tty->termios.c_cflag;
285 priv->termios.c_lflag = tty->termios.c_lflag;
Alan Cox0c265f42008-07-22 11:14:00 +0100286 for (i = 0; i < NCCS; i++)
Alan Coxadc8d742012-07-14 15:31:47 +0100287 priv->termios.c_cc[i] = tty->termios.c_cc[i];
Johan Hovoldabf492e2009-12-28 23:01:52 +0100288 priv->cfg.pktlen = cfg->pktlen;
289 priv->cfg.baudrate = cfg->baudrate;
290 priv->cfg.databits = cfg->databits;
291 priv->cfg.unknown1 = cfg->unknown1;
292 priv->cfg.unknown2 = cfg->unknown2;
Alan Cox0c265f42008-07-22 11:14:00 +0100293 spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
295 /* READ_ON and urb submission */
Johan Hovold60b30132010-05-19 00:01:40 +0200296 rc = usb_serial_generic_open(tty, port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 if (rc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 retval = rc;
299 goto exit;
300 }
301
302 rc = usb_control_msg(port->serial->dev,
Alan Cox0c265f42008-07-22 11:14:00 +0100303 usb_sndctrlpipe(port->serial->dev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 KL5KUSB105A_SIO_CONFIGURE,
305 USB_TYPE_VENDOR|USB_DIR_OUT|USB_RECIP_INTERFACE,
306 KL5KUSB105A_SIO_CONFIGURE_READ_ON,
307 0, /* index */
308 NULL,
309 0,
310 KLSI_TIMEOUT);
311 if (rc < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700312 dev_err(&port->dev, "Enabling read failed (error = %d)\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 retval = rc;
Alan Cox0c265f42008-07-22 11:14:00 +0100314 } else
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700315 dev_dbg(&port->dev, "%s - enabled reading\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
317 rc = klsi_105_get_line_state(port, &line_state);
318 if (rc >= 0) {
Alan Cox0c265f42008-07-22 11:14:00 +0100319 spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 priv->line_state = line_state;
Alan Cox0c265f42008-07-22 11:14:00 +0100321 spin_unlock_irqrestore(&priv->lock, flags);
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700322 dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__, line_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 retval = 0;
324 } else
325 retval = rc;
326
327exit:
Johan Hovoldabf492e2009-12-28 23:01:52 +0100328 kfree(cfg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 return retval;
Johan Hovoldff8c1952010-05-19 00:01:39 +0200330}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Alan Cox335f8512009-06-11 12:26:29 +0100332static void klsi_105_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 int rc;
335
Johan Hovold9fcb2e62013-03-21 12:37:39 +0100336 /* send READ_OFF */
337 rc = usb_control_msg(port->serial->dev,
338 usb_sndctrlpipe(port->serial->dev, 0),
339 KL5KUSB105A_SIO_CONFIGURE,
340 USB_TYPE_VENDOR | USB_DIR_OUT,
341 KL5KUSB105A_SIO_CONFIGURE_READ_OFF,
342 0, /* index */
343 NULL, 0,
344 KLSI_TIMEOUT);
345 if (rc < 0)
346 dev_err(&port->dev, "failed to disable read: %d\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 /* shutdown our bulk reads and writes */
Johan Hovold60b30132010-05-19 00:01:40 +0200349 usb_serial_generic_close(port);
Johan Hovoldff8c1952010-05-19 00:01:39 +0200350}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
352/* We need to write a complete 64-byte data block and encode the
Alan Cox0c265f42008-07-22 11:14:00 +0100353 * number actually sent in the first double-byte, LSB-order. That
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 * leaves at most 62 bytes of payload.
355 */
Johan Hovold60b30132010-05-19 00:01:40 +0200356#define KLSI_HDR_LEN 2
357static int klsi_105_prepare_write_buffer(struct usb_serial_port *port,
358 void *dest, size_t size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Johan Hovold60b30132010-05-19 00:01:40 +0200360 unsigned char *buf = dest;
361 int count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Johan Hovold60b30132010-05-19 00:01:40 +0200363 count = kfifo_out_locked(&port->write_fifo, buf + KLSI_HDR_LEN, size,
364 &port->lock);
365 put_unaligned_le16(count, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
Johan Hovold60b30132010-05-19 00:01:40 +0200367 return count + KLSI_HDR_LEN;
Johan Hovoldff8c1952010-05-19 00:01:39 +0200368}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Johan Hovold60b30132010-05-19 00:01:40 +0200370/* The data received is preceded by a length double-byte in LSB-first order.
371 */
372static void klsi_105_process_read_urb(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
Ming Leicdc97792008-02-24 18:41:47 +0800374 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 unsigned char *data = urb->transfer_buffer;
Johan Hovold60b30132010-05-19 00:01:40 +0200376 unsigned len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Johan Hovold60b30132010-05-19 00:01:40 +0200378 /* empty urbs seem to happen, we ignore them */
379 if (!urb->actual_length)
380 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Johan Hovold60b30132010-05-19 00:01:40 +0200382 if (urb->actual_length <= KLSI_HDR_LEN) {
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700383 dev_dbg(&port->dev, "%s - malformed packet\n", __func__);
Greg Kroah-Hartman17c1b352007-06-15 15:44:13 -0700384 return;
385 }
386
Johan Hovold60b30132010-05-19 00:01:40 +0200387 len = get_unaligned_le16(data);
388 if (len > urb->actual_length - KLSI_HDR_LEN) {
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700389 dev_dbg(&port->dev, "%s - packet length mismatch\n", __func__);
Johan Hovold60b30132010-05-19 00:01:40 +0200390 len = urb->actual_length - KLSI_HDR_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 }
Johan Hovold60b30132010-05-19 00:01:40 +0200392
Jiri Slaby05c7cd32013-01-03 15:53:04 +0100393 tty_insert_flip_string(&port->port, data + KLSI_HDR_LEN, len);
Jiri Slaby2e124b42013-01-03 15:53:06 +0100394 tty_flip_buffer_push(&port->port);
Johan Hovoldff8c1952010-05-19 00:01:39 +0200395}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Alan Cox0c265f42008-07-22 11:14:00 +0100397static void klsi_105_set_termios(struct tty_struct *tty,
398 struct usb_serial_port *port,
399 struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
401 struct klsi_105_private *priv = usb_get_serial_port_data(port);
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700402 struct device *dev = &port->dev;
Alan Coxadc8d742012-07-14 15:31:47 +0100403 unsigned int iflag = tty->termios.c_iflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 unsigned int old_iflag = old_termios->c_iflag;
Alan Coxadc8d742012-07-14 15:31:47 +0100405 unsigned int cflag = tty->termios.c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 unsigned int old_cflag = old_termios->c_cflag;
Johan Hovoldabf492e2009-12-28 23:01:52 +0100407 struct klsi_105_port_settings *cfg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 unsigned long flags;
Alan Coxa5b6f602008-04-08 17:16:06 +0100409 speed_t baud;
Alan Cox0c265f42008-07-22 11:14:00 +0100410
Johan Hovoldabf492e2009-12-28 23:01:52 +0100411 cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
Johan Hovold10c642d2013-12-29 19:22:56 +0100412 if (!cfg)
Johan Hovoldabf492e2009-12-28 23:01:52 +0100413 return;
Johan Hovoldabf492e2009-12-28 23:01:52 +0100414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 /* lock while we are modifying the settings */
Alan Cox0c265f42008-07-22 11:14:00 +0100416 spin_lock_irqsave(&priv->lock, flags);
417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 /*
419 * Update baud rate
420 */
Alan Coxa5b6f602008-04-08 17:16:06 +0100421 baud = tty_get_baud_rate(tty);
422
Alan Cox0c265f42008-07-22 11:14:00 +0100423 if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
424 /* reassert DTR and (maybe) RTS on transition from B0 */
425 if ((old_cflag & CBAUD) == B0) {
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700426 dev_dbg(dev, "%s: baud was B0\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427#if 0
428 priv->control_state |= TIOCM_DTR;
429 /* don't set RTS if using hardware flow control */
Alan Cox0c265f42008-07-22 11:14:00 +0100430 if (!(old_cflag & CRTSCTS))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 priv->control_state |= TIOCM_RTS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 mct_u232_set_modem_ctrl(serial, priv->control_state);
433#endif
434 }
Alan Coxa5b6f602008-04-08 17:16:06 +0100435 }
Alan Cox0c265f42008-07-22 11:14:00 +0100436 switch (baud) {
437 case 0: /* handled below */
438 break;
439 case 1200:
440 priv->cfg.baudrate = kl5kusb105a_sio_b1200;
441 break;
442 case 2400:
443 priv->cfg.baudrate = kl5kusb105a_sio_b2400;
444 break;
445 case 4800:
446 priv->cfg.baudrate = kl5kusb105a_sio_b4800;
447 break;
448 case 9600:
449 priv->cfg.baudrate = kl5kusb105a_sio_b9600;
450 break;
451 case 19200:
452 priv->cfg.baudrate = kl5kusb105a_sio_b19200;
453 break;
454 case 38400:
455 priv->cfg.baudrate = kl5kusb105a_sio_b38400;
456 break;
457 case 57600:
458 priv->cfg.baudrate = kl5kusb105a_sio_b57600;
459 break;
460 case 115200:
461 priv->cfg.baudrate = kl5kusb105a_sio_b115200;
462 break;
463 default:
Johan Hovoldd9a38a82014-03-12 19:09:42 +0100464 dev_dbg(dev, "unsupported baudrate, using 9600\n");
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700465 priv->cfg.baudrate = kl5kusb105a_sio_b9600;
Alan Cox0c265f42008-07-22 11:14:00 +0100466 baud = 9600;
467 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 }
Alan Cox0c265f42008-07-22 11:14:00 +0100469 if ((cflag & CBAUD) == B0) {
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700470 dev_dbg(dev, "%s: baud is B0\n", __func__);
Alan Coxa5b6f602008-04-08 17:16:06 +0100471 /* Drop RTS and DTR */
472 /* maybe this should be simulated by sending read
473 * disable and read enable messages?
474 */
475 ;
476#if 0
477 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
Alan Cox0c265f42008-07-22 11:14:00 +0100478 mct_u232_set_modem_ctrl(serial, priv->control_state);
Alan Coxa5b6f602008-04-08 17:16:06 +0100479#endif
480 }
481 tty_encode_baud_rate(tty, baud, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
484 /* set the number of data bits */
485 switch (cflag & CSIZE) {
486 case CS5:
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700487 dev_dbg(dev, "%s - 5 bits/byte not supported\n", __func__);
Alan Cox0c265f42008-07-22 11:14:00 +0100488 spin_unlock_irqrestore(&priv->lock, flags);
Johan Hovoldabf492e2009-12-28 23:01:52 +0100489 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 case CS6:
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700491 dev_dbg(dev, "%s - 6 bits/byte not supported\n", __func__);
Alan Cox0c265f42008-07-22 11:14:00 +0100492 spin_unlock_irqrestore(&priv->lock, flags);
Johan Hovoldabf492e2009-12-28 23:01:52 +0100493 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 case CS7:
495 priv->cfg.databits = kl5kusb105a_dtb_7;
496 break;
497 case CS8:
498 priv->cfg.databits = kl5kusb105a_dtb_8;
499 break;
500 default:
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700501 dev_err(dev, "CSIZE was not CS5-CS8, using default of 8\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 priv->cfg.databits = kl5kusb105a_dtb_8;
503 break;
504 }
505 }
506
507 /*
508 * Update line control register (LCR)
509 */
510 if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))
Alan Cox0c265f42008-07-22 11:14:00 +0100511 || (cflag & CSTOPB) != (old_cflag & CSTOPB)) {
Alan Coxa5b6f602008-04-08 17:16:06 +0100512 /* Not currently supported */
Alan Coxadc8d742012-07-14 15:31:47 +0100513 tty->termios.c_cflag &= ~(PARENB|PARODD|CSTOPB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514#if 0
515 priv->last_lcr = 0;
516
517 /* set the parity */
518 if (cflag & PARENB)
519 priv->last_lcr |= (cflag & PARODD) ?
520 MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
521 else
522 priv->last_lcr |= MCT_U232_PARITY_NONE;
523
524 /* set the number of stop bits */
525 priv->last_lcr |= (cflag & CSTOPB) ?
526 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
527
528 mct_u232_set_line_ctrl(serial, priv->last_lcr);
529#endif
530 ;
531 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 /*
533 * Set flow control: well, I do not really now how to handle DTR/RTS.
534 * Just do what we have seen with SniffUSB on Win98.
535 */
Alan Cox0c265f42008-07-22 11:14:00 +0100536 if ((iflag & IXOFF) != (old_iflag & IXOFF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 || (iflag & IXON) != (old_iflag & IXON)
Alan Cox0c265f42008-07-22 11:14:00 +0100538 || (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
Alan Coxa5b6f602008-04-08 17:16:06 +0100539 /* Not currently supported */
Alan Coxadc8d742012-07-14 15:31:47 +0100540 tty->termios.c_cflag &= ~CRTSCTS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 /* Drop DTR/RTS if no flow control otherwise assert */
542#if 0
Alan Cox0c265f42008-07-22 11:14:00 +0100543 if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 priv->control_state |= TIOCM_DTR | TIOCM_RTS;
545 else
546 priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
547 mct_u232_set_modem_ctrl(serial, priv->control_state);
548#endif
549 ;
550 }
Johan Hovoldabf492e2009-12-28 23:01:52 +0100551 memcpy(cfg, &priv->cfg, sizeof(*cfg));
Alan Cox0c265f42008-07-22 11:14:00 +0100552 spin_unlock_irqrestore(&priv->lock, flags);
553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 /* now commit changes to device */
Johan Hovoldabf492e2009-12-28 23:01:52 +0100555 klsi_105_chg_port_settings(port, cfg);
556err:
557 kfree(cfg);
Johan Hovoldff8c1952010-05-19 00:01:39 +0200558}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560#if 0
Alan Cox0c265f42008-07-22 11:14:00 +0100561static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562{
Alan Cox95da3102008-07-22 11:09:07 +0100563 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 struct usb_serial *serial = port->serial;
Alan Cox0c265f42008-07-22 11:14:00 +0100565 struct mct_u232_private *priv =
566 (struct mct_u232_private *)port->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 unsigned char lcr = priv->last_lcr;
568
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700569 dev_dbg(&port->dev, "%s - state=%d\n", __func__, break_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Alan Cox6b447f042009-01-02 13:48:56 +0000571 /* LOCKING */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 if (break_state)
573 lcr |= MCT_U232_SET_BREAK;
574
575 mct_u232_set_line_ctrl(serial, lcr);
Johan Hovoldff8c1952010-05-19 00:01:39 +0200576}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577#endif
578
Alan Cox60b33c12011-02-14 16:26:14 +0000579static int klsi_105_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
Alan Cox95da3102008-07-22 11:09:07 +0100581 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 struct klsi_105_private *priv = usb_get_serial_port_data(port);
583 unsigned long flags;
584 int rc;
585 unsigned long line_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
587 rc = klsi_105_get_line_state(port, &line_state);
588 if (rc < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700589 dev_err(&port->dev,
590 "Reading line control failed (error = %d)\n", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 /* better return value? EAGAIN? */
592 return rc;
593 }
594
Alan Cox0c265f42008-07-22 11:14:00 +0100595 spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 priv->line_state = line_state;
Alan Cox0c265f42008-07-22 11:14:00 +0100597 spin_unlock_irqrestore(&priv->lock, flags);
Greg Kroah-Hartman1ad76042012-09-14 09:47:43 -0700598 dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__, line_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 return (int)line_state;
600}
601
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -0700602module_usb_serial_driver(serial_drivers, id_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
Alan Cox0c265f42008-07-22 11:14:00 +0100604MODULE_AUTHOR(DRIVER_AUTHOR);
605MODULE_DESCRIPTION(DRIVER_DESC);
606MODULE_LICENSE("GPL");