blob: 3ec24870bca995edfd1c180ae7f1781c452ada5e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Silicon Laboratories CP2101/CP2102 USB to RS232 serial adaptor driver
3 *
4 * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
9 *
Craig Shelley39a66b82005-05-27 00:09:56 +010010 * Support to set flow control line levels using TIOCMGET and TIOCMSET
11 * thanks to Karl Hiramoto karl@hiramoto.org. RTSCTS hardware flow
12 * control thanks to Munir Nassar nassarmu@real-time.com
13 *
14 * Outstanding Issues:
15 * Buffers are not flushed when the port is opened.
16 * Multiple calls to write() may fail with "Resource temporarily unavailable"
17 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/kernel.h>
21#include <linux/errno.h>
22#include <linux/slab.h>
23#include <linux/tty.h>
24#include <linux/tty_flip.h>
25#include <linux/module.h>
26#include <linux/moduleparam.h>
27#include <linux/usb.h>
28#include <asm/uaccess.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070029#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
31/*
32 * Version Information
33 */
Craig Shelley59224f52006-03-11 11:29:02 +000034#define DRIVER_VERSION "v0.07"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
36
37/*
38 * Function Prototypes
39 */
40static int cp2101_open(struct usb_serial_port*, struct file*);
41static void cp2101_cleanup(struct usb_serial_port*);
42static void cp2101_close(struct usb_serial_port*, struct file*);
43static void cp2101_get_termios(struct usb_serial_port*);
Alan Cox606d0992006-12-08 02:38:45 -080044static void cp2101_set_termios(struct usb_serial_port*, struct ktermios*);
Craig Shelley39a66b82005-05-27 00:09:56 +010045static int cp2101_tiocmget (struct usb_serial_port *, struct file *);
46static int cp2101_tiocmset (struct usb_serial_port *, struct file *,
47 unsigned int, unsigned int);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048static void cp2101_break_ctl(struct usb_serial_port*, int);
49static int cp2101_startup (struct usb_serial *);
50static void cp2101_shutdown(struct usb_serial*);
51
52
53static int debug;
54
55static struct usb_device_id id_table [] = {
Craig Shelley198b9512005-08-28 09:51:15 +010056 { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
Craig Shelley198b9512005-08-28 09:51:15 +010057 { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
Craig Shelleye988fc82006-01-20 00:06:19 +000058 { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
59 { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
Craig Shelley59224f52006-03-11 11:29:02 +000060 { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
Vitja Makarov212a4b42006-05-31 00:40:06 +040061 { USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
Craig Shelleye988fc82006-01-20 00:06:19 +000062 { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
63 { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
64 { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
65 { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
66 { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
Bjorn Schneider78001e32006-10-28 12:42:04 +020067 { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
68 { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
69 { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
Craig Shelleye988fc82006-01-20 00:06:19 +000070 { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
Craig Shelley61926b92006-10-12 22:09:56 +010071 { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
Johannes Hoelzle05998d2006-12-02 16:54:27 +010072 { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
Josef Balatkab0ce84d2005-11-17 09:47:24 -080073 { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
Craig Shelley39a66b82005-05-27 00:09:56 +010074 { } /* Terminating Entry */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075};
76
77MODULE_DEVICE_TABLE (usb, id_table);
78
79static struct usb_driver cp2101_driver = {
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -070080 .name = "cp2101",
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 .probe = usb_serial_probe,
82 .disconnect = usb_serial_disconnect,
83 .id_table = id_table,
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -080084 .no_dynamic_id = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -070085};
86
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -070087static struct usb_serial_driver cp2101_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -070088 .driver = {
89 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -070090 .name = "cp2101",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -070091 },
Johannes Hölzld9b1b782006-12-17 21:50:24 +010092 .usb_driver = &cp2101_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 .id_table = id_table,
94 .num_interrupt_in = 0,
95 .num_bulk_in = 0,
96 .num_bulk_out = 0,
97 .num_ports = 1,
98 .open = cp2101_open,
99 .close = cp2101_close,
100 .break_ctl = cp2101_break_ctl,
101 .set_termios = cp2101_set_termios,
Craig Shelley39a66b82005-05-27 00:09:56 +0100102 .tiocmget = cp2101_tiocmget,
103 .tiocmset = cp2101_tiocmset,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 .attach = cp2101_startup,
105 .shutdown = cp2101_shutdown,
106};
107
Craig Shelley39a66b82005-05-27 00:09:56 +0100108/* Config request types */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109#define REQTYPE_HOST_TO_DEVICE 0x41
110#define REQTYPE_DEVICE_TO_HOST 0xc1
111
Craig Shelley39a66b82005-05-27 00:09:56 +0100112/* Config SET requests. To GET, add 1 to the request number */
113#define CP2101_UART 0x00 /* Enable / Disable */
114#define CP2101_BAUDRATE 0x01 /* (BAUD_RATE_GEN_FREQ / baudrate) */
115#define CP2101_BITS 0x03 /* 0x(0)(databits)(parity)(stopbits) */
116#define CP2101_BREAK 0x05 /* On / Off */
117#define CP2101_CONTROL 0x07 /* Flow control line states */
118#define CP2101_MODEMCTL 0x13 /* Modem controls */
119#define CP2101_CONFIG_6 0x19 /* 6 bytes of config data ??? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
Craig Shelley39a66b82005-05-27 00:09:56 +0100121/* CP2101_UART */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122#define UART_ENABLE 0x0001
123#define UART_DISABLE 0x0000
124
Craig Shelley39a66b82005-05-27 00:09:56 +0100125/* CP2101_BAUDRATE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126#define BAUD_RATE_GEN_FREQ 0x384000
127
Craig Shelley39a66b82005-05-27 00:09:56 +0100128/* CP2101_BITS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129#define BITS_DATA_MASK 0X0f00
Craig Shelley39a66b82005-05-27 00:09:56 +0100130#define BITS_DATA_5 0X0500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131#define BITS_DATA_6 0X0600
132#define BITS_DATA_7 0X0700
133#define BITS_DATA_8 0X0800
134#define BITS_DATA_9 0X0900
135
136#define BITS_PARITY_MASK 0x00f0
137#define BITS_PARITY_NONE 0x0000
138#define BITS_PARITY_ODD 0x0010
139#define BITS_PARITY_EVEN 0x0020
140#define BITS_PARITY_MARK 0x0030
141#define BITS_PARITY_SPACE 0x0040
142
143#define BITS_STOP_MASK 0x000f
144#define BITS_STOP_1 0x0000
145#define BITS_STOP_1_5 0x0001
146#define BITS_STOP_2 0x0002
Craig Shelley39a66b82005-05-27 00:09:56 +0100147
148/* CP2101_BREAK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149#define BREAK_ON 0x0000
150#define BREAK_OFF 0x0001
151
Craig Shelley39a66b82005-05-27 00:09:56 +0100152/* CP2101_CONTROL */
153#define CONTROL_DTR 0x0001
154#define CONTROL_RTS 0x0002
155#define CONTROL_CTS 0x0010
156#define CONTROL_DSR 0x0020
157#define CONTROL_RING 0x0040
158#define CONTROL_DCD 0x0080
159#define CONTROL_WRITE_DTR 0x0100
160#define CONTROL_WRITE_RTS 0x0200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
Craig Shelley39a66b82005-05-27 00:09:56 +0100162/*
163 * cp2101_get_config
164 * Reads from the CP2101 configuration registers
165 * 'size' is specified in bytes.
166 * 'data' is a pointer to a pre-allocated array of integers large
167 * enough to hold 'size' bytes (with 4 bytes to each integer)
168 */
169static int cp2101_get_config(struct usb_serial_port* port, u8 request,
170 unsigned int *data, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171{
172 struct usb_serial *serial = port->serial;
Al Viro53ebb3b2007-02-09 16:39:55 +0000173 __le32 *buf;
Craig Shelley39a66b82005-05-27 00:09:56 +0100174 int result, i, length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Craig Shelley39a66b82005-05-27 00:09:56 +0100176 /* Number of integers required to contain the array */
177 length = (((size - 1) | 3) + 1)/4;
178
Al Viro53ebb3b2007-02-09 16:39:55 +0000179 buf = kcalloc(length, sizeof(__le32), GFP_KERNEL);
Craig Shelley39a66b82005-05-27 00:09:56 +0100180 if (!buf) {
181 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
182 return -ENOMEM;
183 }
184
185 /* For get requests, the request number must be incremented */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 request++;
187
Craig Shelley39a66b82005-05-27 00:09:56 +0100188 /* Issue the request, attempting to read 'size' bytes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 result = usb_control_msg (serial->dev,usb_rcvctrlpipe (serial->dev, 0),
190 request, REQTYPE_DEVICE_TO_HOST, 0x0000,
Craig Shelley39a66b82005-05-27 00:09:56 +0100191 0, buf, size, 300);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Craig Shelley39a66b82005-05-27 00:09:56 +0100193 /* Convert data into an array of integers */
194 for (i=0; i<length; i++)
195 data[i] = le32_to_cpu(buf[i]);
196
197 kfree(buf);
198
199 if (result != size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 dev_err(&port->dev, "%s - Unable to send config request, "
Craig Shelley39a66b82005-05-27 00:09:56 +0100201 "request=0x%x size=%d result=%d\n",
202 __FUNCTION__, request, size, result);
203 return -EPROTO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 }
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 return 0;
207}
208
Craig Shelley39a66b82005-05-27 00:09:56 +0100209/*
210 * cp2101_set_config
211 * Writes to the CP2101 configuration registers
212 * Values less than 16 bits wide are sent directly
213 * 'size' is specified in bytes.
214 */
215static int cp2101_set_config(struct usb_serial_port* port, u8 request,
216 unsigned int *data, int size)
217{
218 struct usb_serial *serial = port->serial;
Al Viro53ebb3b2007-02-09 16:39:55 +0000219 __le32 *buf;
Craig Shelley39a66b82005-05-27 00:09:56 +0100220 int result, i, length;
221
222 /* Number of integers required to contain the array */
223 length = (((size - 1) | 3) + 1)/4;
224
Al Viro53ebb3b2007-02-09 16:39:55 +0000225 buf = kmalloc(length * sizeof(__le32), GFP_KERNEL);
Craig Shelley39a66b82005-05-27 00:09:56 +0100226 if (!buf) {
227 dev_err(&port->dev, "%s - out of memory.\n",
228 __FUNCTION__);
229 return -ENOMEM;
230 }
231
232 /* Array of integers into bytes */
233 for (i = 0; i < length; i++)
234 buf[i] = cpu_to_le32(data[i]);
235
236 if (size > 2) {
237 result = usb_control_msg (serial->dev,
238 usb_sndctrlpipe(serial->dev, 0),
239 request, REQTYPE_HOST_TO_DEVICE, 0x0000,
240 0, buf, size, 300);
241 } else {
242 result = usb_control_msg (serial->dev,
243 usb_sndctrlpipe(serial->dev, 0),
244 request, REQTYPE_HOST_TO_DEVICE, data[0],
245 0, NULL, 0, 300);
246 }
247
248 kfree(buf);
249
250 if ((size > 2 && result != size) || result < 0) {
251 dev_err(&port->dev, "%s - Unable to send request, "
252 "request=0x%x size=%d result=%d\n",
253 __FUNCTION__, request, size, result);
254 return -EPROTO;
255 }
256
257 /* Single data value */
258 result = usb_control_msg (serial->dev,
259 usb_sndctrlpipe(serial->dev, 0),
260 request, REQTYPE_HOST_TO_DEVICE, data[0],
261 0, NULL, 0, 300);
262 return 0;
263}
264
265/*
266 * cp2101_set_config_single
267 * Convenience function for calling cp2101_set_config on single data values
268 * without requiring an integer pointer
269 */
270static inline int cp2101_set_config_single(struct usb_serial_port* port,
271 u8 request, unsigned int data)
272{
273 return cp2101_set_config(port, request, &data, 2);
274}
275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276static int cp2101_open (struct usb_serial_port *port, struct file *filp)
277{
278 struct usb_serial *serial = port->serial;
279 int result;
280
281 dbg("%s - port %d", __FUNCTION__, port->number);
282
Craig Shelley39a66b82005-05-27 00:09:56 +0100283 if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 dev_err(&port->dev, "%s - Unable to enable UART\n",
285 __FUNCTION__);
286 return -EPROTO;
287 }
288
289 /* Start reading from the device */
290 usb_fill_bulk_urb (port->read_urb, serial->dev,
291 usb_rcvbulkpipe(serial->dev,
292 port->bulk_in_endpointAddress),
293 port->read_urb->transfer_buffer,
294 port->read_urb->transfer_buffer_length,
295 serial->type->read_bulk_callback,
296 port);
297 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
298 if (result) {
299 dev_err(&port->dev, "%s - failed resubmitting read urb, "
300 "error %d\n", __FUNCTION__, result);
301 return result;
302 }
303
Craig Shelley39a66b82005-05-27 00:09:56 +0100304 /* Configure the termios structure */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 cp2101_get_termios(port);
306
Craig Shelley39a66b82005-05-27 00:09:56 +0100307 /* Set the DTR and RTS pins low */
308 cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0);
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return 0;
311}
312
313static void cp2101_cleanup (struct usb_serial_port *port)
314{
315 struct usb_serial *serial = port->serial;
316
317 dbg("%s - port %d", __FUNCTION__, port->number);
318
319 if (serial->dev) {
320 /* shutdown any bulk reads that might be going on */
321 if (serial->num_bulk_out)
322 usb_kill_urb(port->write_urb);
323 if (serial->num_bulk_in)
324 usb_kill_urb(port->read_urb);
325 }
326}
327
328static void cp2101_close (struct usb_serial_port *port, struct file * filp)
329{
330 dbg("%s - port %d", __FUNCTION__, port->number);
331
332 /* shutdown our urbs */
333 dbg("%s - shutting down urbs", __FUNCTION__);
334 usb_kill_urb(port->write_urb);
335 usb_kill_urb(port->read_urb);
336
Craig Shelley39a66b82005-05-27 00:09:56 +0100337 cp2101_set_config_single(port, CP2101_UART, UART_DISABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338}
339
Craig Shelley39a66b82005-05-27 00:09:56 +0100340/*
341 * cp2101_get_termios
342 * Reads the baud rate, data bits, parity, stop bits and flow control mode
343 * from the device, corrects any unsupported values, and configures the
344 * termios structure to reflect the state of the device
345 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346static void cp2101_get_termios (struct usb_serial_port *port)
347{
Craig Shelley39a66b82005-05-27 00:09:56 +0100348 unsigned int cflag, modem_ctl[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 int baud;
350 int bits;
351
352 dbg("%s - port %d", __FUNCTION__, port->number);
353
354 if ((!port->tty) || (!port->tty->termios)) {
355 dbg("%s - no tty structures", __FUNCTION__);
356 return;
357 }
358 cflag = port->tty->termios->c_cflag;
359
Craig Shelley39a66b82005-05-27 00:09:56 +0100360 cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
361 /* Convert to baudrate */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (baud)
363 baud = BAUD_RATE_GEN_FREQ / baud;
364
365 dbg("%s - baud rate = %d", __FUNCTION__, baud);
366 cflag &= ~CBAUD;
367 switch (baud) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100368 /*
369 * The baud rates which are commented out below
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 * appear to be supported by the device
371 * but are non-standard
372 */
373 case 600: cflag |= B600; break;
374 case 1200: cflag |= B1200; break;
375 case 1800: cflag |= B1800; break;
376 case 2400: cflag |= B2400; break;
377 case 4800: cflag |= B4800; break;
378 /*case 7200: cflag |= B7200; break;*/
379 case 9600: cflag |= B9600; break;
380 /*case 14400: cflag |= B14400; break;*/
381 case 19200: cflag |= B19200; break;
382 /*case 28800: cflag |= B28800; break;*/
383 case 38400: cflag |= B38400; break;
384 /*case 55854: cflag |= B55054; break;*/
385 case 57600: cflag |= B57600; break;
386 case 115200: cflag |= B115200; break;
387 /*case 127117: cflag |= B127117; break;*/
388 case 230400: cflag |= B230400; break;
389 case 460800: cflag |= B460800; break;
390 case 921600: cflag |= B921600; break;
391 /*case 3686400: cflag |= B3686400; break;*/
392 default:
393 dbg("%s - Baud rate is not supported, "
394 "using 9600 baud", __FUNCTION__);
395 cflag |= B9600;
Craig Shelley39a66b82005-05-27 00:09:56 +0100396 cp2101_set_config_single(port, CP2101_BAUDRATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 (BAUD_RATE_GEN_FREQ/9600));
398 break;
399 }
400
Craig Shelley39a66b82005-05-27 00:09:56 +0100401 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 cflag &= ~CSIZE;
403 switch(bits & BITS_DATA_MASK) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100404 case BITS_DATA_5:
405 dbg("%s - data bits = 5", __FUNCTION__);
406 cflag |= CS5;
407 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 case BITS_DATA_6:
409 dbg("%s - data bits = 6", __FUNCTION__);
410 cflag |= CS6;
411 break;
412 case BITS_DATA_7:
413 dbg("%s - data bits = 7", __FUNCTION__);
414 cflag |= CS7;
415 break;
416 case BITS_DATA_8:
417 dbg("%s - data bits = 8", __FUNCTION__);
418 cflag |= CS8;
419 break;
420 case BITS_DATA_9:
421 dbg("%s - data bits = 9 (not supported, "
422 "using 8 data bits)", __FUNCTION__);
423 cflag |= CS8;
424 bits &= ~BITS_DATA_MASK;
425 bits |= BITS_DATA_8;
Craig Shelley39a66b82005-05-27 00:09:56 +0100426 cp2101_set_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 break;
428 default:
429 dbg("%s - Unknown number of data bits, "
430 "using 8", __FUNCTION__);
431 cflag |= CS8;
432 bits &= ~BITS_DATA_MASK;
433 bits |= BITS_DATA_8;
Craig Shelley39a66b82005-05-27 00:09:56 +0100434 cp2101_set_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 break;
436 }
437
438 switch(bits & BITS_PARITY_MASK) {
439 case BITS_PARITY_NONE:
440 dbg("%s - parity = NONE", __FUNCTION__);
441 cflag &= ~PARENB;
442 break;
443 case BITS_PARITY_ODD:
444 dbg("%s - parity = ODD", __FUNCTION__);
445 cflag |= (PARENB|PARODD);
446 break;
447 case BITS_PARITY_EVEN:
448 dbg("%s - parity = EVEN", __FUNCTION__);
449 cflag &= ~PARODD;
450 cflag |= PARENB;
451 break;
452 case BITS_PARITY_MARK:
453 dbg("%s - parity = MARK (not supported, "
454 "disabling parity)", __FUNCTION__);
455 cflag &= ~PARENB;
456 bits &= ~BITS_PARITY_MASK;
Craig Shelley39a66b82005-05-27 00:09:56 +0100457 cp2101_set_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 break;
459 case BITS_PARITY_SPACE:
460 dbg("%s - parity = SPACE (not supported, "
461 "disabling parity)", __FUNCTION__);
462 cflag &= ~PARENB;
463 bits &= ~BITS_PARITY_MASK;
Craig Shelley39a66b82005-05-27 00:09:56 +0100464 cp2101_set_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 break;
466 default:
467 dbg("%s - Unknown parity mode, "
468 "disabling parity", __FUNCTION__);
469 cflag &= ~PARENB;
470 bits &= ~BITS_PARITY_MASK;
Craig Shelley39a66b82005-05-27 00:09:56 +0100471 cp2101_set_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 break;
473 }
474
475 cflag &= ~CSTOPB;
476 switch(bits & BITS_STOP_MASK) {
477 case BITS_STOP_1:
478 dbg("%s - stop bits = 1", __FUNCTION__);
479 break;
480 case BITS_STOP_1_5:
481 dbg("%s - stop bits = 1.5 (not supported, "
Craig Shelley39a66b82005-05-27 00:09:56 +0100482 "using 1 stop bit)", __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 bits &= ~BITS_STOP_MASK;
Craig Shelley39a66b82005-05-27 00:09:56 +0100484 cp2101_set_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 break;
486 case BITS_STOP_2:
487 dbg("%s - stop bits = 2", __FUNCTION__);
488 cflag |= CSTOPB;
489 break;
490 default:
491 dbg("%s - Unknown number of stop bits, "
492 "using 1 stop bit", __FUNCTION__);
493 bits &= ~BITS_STOP_MASK;
Craig Shelley39a66b82005-05-27 00:09:56 +0100494 cp2101_set_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 break;
496 }
497
Craig Shelley39a66b82005-05-27 00:09:56 +0100498 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
499 if (modem_ctl[0] & 0x0008) {
500 dbg("%s - flow control = CRTSCTS", __FUNCTION__);
501 cflag |= CRTSCTS;
502 } else {
503 dbg("%s - flow control = NONE", __FUNCTION__);
504 cflag &= ~CRTSCTS;
505 }
506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 port->tty->termios->c_cflag = cflag;
508}
509
510static void cp2101_set_termios (struct usb_serial_port *port,
Alan Cox606d0992006-12-08 02:38:45 -0800511 struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
513 unsigned int cflag, old_cflag=0;
Craig Shelley39a66b82005-05-27 00:09:56 +0100514 int baud=0, bits;
515 unsigned int modem_ctl[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
517 dbg("%s - port %d", __FUNCTION__, port->number);
518
519 if ((!port->tty) || (!port->tty->termios)) {
520 dbg("%s - no tty structures", __FUNCTION__);
521 return;
522 }
523 cflag = port->tty->termios->c_cflag;
524
Craig Shelley39a66b82005-05-27 00:09:56 +0100525 /* Check that they really want us to change something */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 if (old_termios) {
527 if ((cflag == old_termios->c_cflag) &&
528 (RELEVANT_IFLAG(port->tty->termios->c_iflag)
529 == RELEVANT_IFLAG(old_termios->c_iflag))) {
530 dbg("%s - nothing to change...", __FUNCTION__);
531 return;
532 }
533
534 old_cflag = old_termios->c_cflag;
535 }
536
537 /* If the baud rate is to be updated*/
538 if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
539 switch (cflag & CBAUD) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100540 /*
541 * The baud rates which are commented out below
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 * appear to be supported by the device
543 * but are non-standard
544 */
545 case B0: baud = 0; break;
546 case B600: baud = 600; break;
547 case B1200: baud = 1200; break;
548 case B1800: baud = 1800; break;
549 case B2400: baud = 2400; break;
550 case B4800: baud = 4800; break;
551 /*case B7200: baud = 7200; break;*/
552 case B9600: baud = 9600; break;
553 /*ase B14400: baud = 14400; break;*/
554 case B19200: baud = 19200; break;
555 /*case B28800: baud = 28800; break;*/
556 case B38400: baud = 38400; break;
557 /*case B55854: baud = 55054; break;*/
558 case B57600: baud = 57600; break;
559 case B115200: baud = 115200; break;
560 /*case B127117: baud = 127117; break;*/
561 case B230400: baud = 230400; break;
562 case B460800: baud = 460800; break;
563 case B921600: baud = 921600; break;
564 /*case B3686400: baud = 3686400; break;*/
565 default:
566 dev_err(&port->dev, "cp2101 driver does not "
567 "support the baudrate requested\n");
568 break;
569 }
570
571 if (baud) {
572 dbg("%s - Setting baud rate to %d baud", __FUNCTION__,
573 baud);
Craig Shelley39a66b82005-05-27 00:09:56 +0100574 if (cp2101_set_config_single(port, CP2101_BAUDRATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 (BAUD_RATE_GEN_FREQ / baud)))
576 dev_err(&port->dev, "Baud rate requested not "
577 "supported by device\n");
578 }
579 }
580
Craig Shelley39a66b82005-05-27 00:09:56 +0100581 /* If the number of data bits is to be updated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100583 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 bits &= ~BITS_DATA_MASK;
585 switch (cflag & CSIZE) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100586 case CS5:
587 bits |= BITS_DATA_5;
588 dbg("%s - data bits = 5", __FUNCTION__);
589 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 case CS6:
591 bits |= BITS_DATA_6;
592 dbg("%s - data bits = 6", __FUNCTION__);
593 break;
594 case CS7:
595 bits |= BITS_DATA_7;
596 dbg("%s - data bits = 7", __FUNCTION__);
597 break;
598 case CS8:
599 bits |= BITS_DATA_8;
600 dbg("%s - data bits = 8", __FUNCTION__);
601 break;
602 /*case CS9:
603 bits |= BITS_DATA_9;
604 dbg("%s - data bits = 9", __FUNCTION__);
605 break;*/
606 default:
607 dev_err(&port->dev, "cp2101 driver does not "
608 "support the number of bits requested,"
609 " using 8 bit mode\n");
610 bits |= BITS_DATA_8;
611 break;
612 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100613 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 dev_err(&port->dev, "Number of data bits requested "
615 "not supported by device\n");
616 }
617
618 if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100619 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 bits &= ~BITS_PARITY_MASK;
621 if (cflag & PARENB) {
622 if (cflag & PARODD) {
623 bits |= BITS_PARITY_ODD;
624 dbg("%s - parity = ODD", __FUNCTION__);
625 } else {
626 bits |= BITS_PARITY_EVEN;
627 dbg("%s - parity = EVEN", __FUNCTION__);
628 }
629 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100630 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 dev_err(&port->dev, "Parity mode not supported "
632 "by device\n");
633 }
634
635 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100636 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 bits &= ~BITS_STOP_MASK;
638 if (cflag & CSTOPB) {
639 bits |= BITS_STOP_2;
640 dbg("%s - stop bits = 2", __FUNCTION__);
641 } else {
642 bits |= BITS_STOP_1;
643 dbg("%s - stop bits = 1", __FUNCTION__);
644 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100645 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 dev_err(&port->dev, "Number of stop bits requested "
647 "not supported by device\n");
648 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100649
650 if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
651 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
652 dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
653 __FUNCTION__, modem_ctl[0], modem_ctl[1],
654 modem_ctl[2], modem_ctl[3]);
655
656 if (cflag & CRTSCTS) {
657 modem_ctl[0] &= ~0x7B;
658 modem_ctl[0] |= 0x09;
659 modem_ctl[1] = 0x80;
660 dbg("%s - flow control = CRTSCTS", __FUNCTION__);
661 } else {
662 modem_ctl[0] &= ~0x7B;
663 modem_ctl[0] |= 0x01;
664 modem_ctl[1] |= 0x40;
665 dbg("%s - flow control = NONE", __FUNCTION__);
666 }
667
668 dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
669 __FUNCTION__, modem_ctl[0], modem_ctl[1],
670 modem_ctl[2], modem_ctl[3]);
671 cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16);
672 }
673
674}
675
676static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
677 unsigned int set, unsigned int clear)
678{
679 int control = 0;
680
681 dbg("%s - port %d", __FUNCTION__, port->number);
682
683 if (set & TIOCM_RTS) {
684 control |= CONTROL_RTS;
685 control |= CONTROL_WRITE_RTS;
686 }
687 if (set & TIOCM_DTR) {
688 control |= CONTROL_DTR;
689 control |= CONTROL_WRITE_DTR;
690 }
691 if (clear & TIOCM_RTS) {
692 control &= ~CONTROL_RTS;
693 control |= CONTROL_WRITE_RTS;
694 }
695 if (clear & TIOCM_DTR) {
696 control &= ~CONTROL_DTR;
697 control |= CONTROL_WRITE_DTR;
698 }
699
700 dbg("%s - control = 0x%.4x", __FUNCTION__, control);
701
702 return cp2101_set_config(port, CP2101_CONTROL, &control, 2);
703
704}
705
706static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
707{
708 int control, result;
709
710 dbg("%s - port %d", __FUNCTION__, port->number);
711
712 cp2101_get_config(port, CP2101_CONTROL, &control, 1);
713
714 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
715 |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
716 |((control & CONTROL_CTS) ? TIOCM_CTS : 0)
717 |((control & CONTROL_DSR) ? TIOCM_DSR : 0)
718 |((control & CONTROL_RING)? TIOCM_RI : 0)
719 |((control & CONTROL_DCD) ? TIOCM_CD : 0);
720
721 dbg("%s - control = 0x%.2x", __FUNCTION__, control);
722
723 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724}
725
726static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
727{
Craig Shelley39a66b82005-05-27 00:09:56 +0100728 int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730 dbg("%s - port %d", __FUNCTION__, port->number);
731 if (break_state == 0)
732 state = BREAK_OFF;
733 else
734 state = BREAK_ON;
735 dbg("%s - turning break %s", __FUNCTION__,
736 state==BREAK_OFF ? "off" : "on");
Craig Shelley39a66b82005-05-27 00:09:56 +0100737 cp2101_set_config(port, CP2101_BREAK, &state, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
739
740static int cp2101_startup (struct usb_serial *serial)
741{
Craig Shelley39a66b82005-05-27 00:09:56 +0100742 /* CP2101 buffers behave strangely unless device is reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 usb_reset_device(serial->dev);
744 return 0;
745}
746
747static void cp2101_shutdown (struct usb_serial *serial)
748{
749 int i;
750
751 dbg("%s", __FUNCTION__);
752
Craig Shelley39a66b82005-05-27 00:09:56 +0100753 /* Stop reads and writes on all ports */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 for (i=0; i < serial->num_ports; ++i) {
755 cp2101_cleanup(serial->port[i]);
756 }
757}
758
759static int __init cp2101_init (void)
760{
761 int retval;
762
763 retval = usb_serial_register(&cp2101_device);
764 if (retval)
Craig Shelley39a66b82005-05-27 00:09:56 +0100765 return retval; /* Failed to register */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767 retval = usb_register(&cp2101_driver);
768 if (retval) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100769 /* Failed to register */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 usb_serial_deregister(&cp2101_device);
771 return retval;
772 }
773
Craig Shelley39a66b82005-05-27 00:09:56 +0100774 /* Success */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 info(DRIVER_DESC " " DRIVER_VERSION);
776 return 0;
777}
778
779static void __exit cp2101_exit (void)
780{
781 usb_deregister (&cp2101_driver);
782 usb_serial_deregister (&cp2101_device);
783}
784
785module_init(cp2101_init);
786module_exit(cp2101_exit);
787
788MODULE_DESCRIPTION(DRIVER_DESC);
789MODULE_VERSION(DRIVER_VERSION);
790MODULE_LICENSE("GPL");
791
792module_param(debug, bool, S_IRUGO | S_IWUSR);
793MODULE_PARM_DESC(debug, "Enable verbose debugging messages");