blob: 8008d0bc80ad3732a05b4fa82b04b06f3fb334fc [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>
Alan Coxff7eb602008-07-22 11:10:17 +010028#include <linux/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 */
Alan Cox95da3102008-07-22 11:09:07 +010040static int cp2101_open(struct tty_struct *, struct usb_serial_port *,
41 struct file *);
42static void cp2101_cleanup(struct usb_serial_port *);
43static void cp2101_close(struct tty_struct *, struct usb_serial_port *,
44 struct file*);
45static void cp2101_get_termios(struct tty_struct *);
46static void cp2101_set_termios(struct tty_struct *, struct usb_serial_port *,
47 struct ktermios*);
Alan Coxff7eb602008-07-22 11:10:17 +010048static int cp2101_tiocmget(struct tty_struct *, struct file *);
49static int cp2101_tiocmset(struct tty_struct *, struct file *,
Craig Shelley39a66b82005-05-27 00:09:56 +010050 unsigned int, unsigned int);
Alan Cox95da3102008-07-22 11:09:07 +010051static void cp2101_break_ctl(struct tty_struct *, int);
Alan Coxff7eb602008-07-22 11:10:17 +010052static int cp2101_startup(struct usb_serial *);
53static void cp2101_shutdown(struct usb_serial *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55
56static int debug;
57
58static struct usb_device_id id_table [] = {
Craig Shelley59fba742008-04-12 16:15:54 +010059 { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
Edouard Lafargue1f4f7142007-09-25 10:15:36 +020060 { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
Craig Shelley198b9512005-08-28 09:51:15 +010061 { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
Martin Kusserow014840e2007-12-21 12:02:17 +010062 { USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */
Craig Shelley59fba742008-04-12 16:15:54 +010063 { USB_DEVICE(0x0FCF, 0x1006) }, /* Dynastream ANT development board */
Craig Shelley198b9512005-08-28 09:51:15 +010064 { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
Craig Shelleye988fc82006-01-20 00:06:19 +000065 { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
66 { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
Craig Shelley5de8b3a2008-01-03 12:45:59 +000067 { USB_DEVICE(0x10C4, 0x800A) }, /* SPORTident BSM7-D-USB main station */
Craig Shelley59224f52006-03-11 11:29:02 +000068 { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
Craig Shelley92f5cae2007-04-20 14:37:17 +010069 { USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */
Vitja Makarov212a4b42006-05-31 00:40:06 +040070 { USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
Craig Shelleye988fc82006-01-20 00:06:19 +000071 { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
72 { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
Craig Shelley92f5cae2007-04-20 14:37:17 +010073 { USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */
Craig Shelleye988fc82006-01-20 00:06:19 +000074 { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
Craig Shelleyba0f3322008-09-04 21:28:21 +010075 { USB_DEVICE(0x10C4, 0x8115) }, /* Arygon NFC/Mifare Reader */
Craig Shelleye988fc82006-01-20 00:06:19 +000076 { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
Jon K Hellanfc4bd642007-02-28 23:04:33 +010077 { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
78 { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
Craig Shelleye988fc82006-01-20 00:06:19 +000079 { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
Bernhard Beck966236972008-05-11 09:23:13 -070080 { USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */
Craig Shelley59fba742008-04-12 16:15:54 +010081 { USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */
Bjorn Schneider78001e32006-10-28 12:42:04 +020082 { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
83 { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
Jeff Long8be27c22007-11-28 11:02:09 -050084 { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
Bjorn Schneider78001e32006-10-28 12:42:04 +020085 { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
Florian Fainellie8898682008-03-25 17:32:16 +010086 { USB_DEVICE(0x10c4, 0x8293) }, /* Telegesys ETRX2USB */
Craig Shelleyba0f3322008-09-04 21:28:21 +010087 { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
Craig Shelleye988fc82006-01-20 00:06:19 +000088 { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
Craig Shelley61926b92006-10-12 22:09:56 +010089 { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
Craig Shelley5de8b3a2008-01-03 12:45:59 +000090 { USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */
91 { USB_DEVICE(0x10C4, 0xF002) }, /* Elan Digital Systems USBwave12 */
92 { USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */
93 { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
Pozsar Balazsebaf4942007-02-16 12:47:49 +010094 { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
Johannes Hoelzle05998d2006-12-02 16:54:27 +010095 { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
Craig Shelley5de8b3a2008-01-03 12:45:59 +000096 { USB_DEVICE(0x166A, 0x0303) }, /* Clipsal 5500PCU C-Bus USB interface */
Josef Balatkab0ce84d2005-11-17 09:47:24 -080097 { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
Craig Shelleyba0f3322008-09-04 21:28:21 +010098 { USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
Craig Shelley39a66b82005-05-27 00:09:56 +010099 { } /* Terminating Entry */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100};
101
Alan Coxff7eb602008-07-22 11:10:17 +0100102MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104static struct usb_driver cp2101_driver = {
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700105 .name = "cp2101",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 .probe = usb_serial_probe,
107 .disconnect = usb_serial_disconnect,
108 .id_table = id_table,
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800109 .no_dynamic_id = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110};
111
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700112static struct usb_serial_driver cp2101_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700113 .driver = {
114 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700115 .name = "cp2101",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700116 },
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100117 .usb_driver = &cp2101_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 .id_table = id_table,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 .num_ports = 1,
120 .open = cp2101_open,
121 .close = cp2101_close,
122 .break_ctl = cp2101_break_ctl,
123 .set_termios = cp2101_set_termios,
Craig Shelley39a66b82005-05-27 00:09:56 +0100124 .tiocmget = cp2101_tiocmget,
125 .tiocmset = cp2101_tiocmset,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 .attach = cp2101_startup,
127 .shutdown = cp2101_shutdown,
128};
129
Craig Shelley39a66b82005-05-27 00:09:56 +0100130/* Config request types */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131#define REQTYPE_HOST_TO_DEVICE 0x41
132#define REQTYPE_DEVICE_TO_HOST 0xc1
133
Craig Shelley39a66b82005-05-27 00:09:56 +0100134/* Config SET requests. To GET, add 1 to the request number */
135#define CP2101_UART 0x00 /* Enable / Disable */
136#define CP2101_BAUDRATE 0x01 /* (BAUD_RATE_GEN_FREQ / baudrate) */
137#define CP2101_BITS 0x03 /* 0x(0)(databits)(parity)(stopbits) */
138#define CP2101_BREAK 0x05 /* On / Off */
139#define CP2101_CONTROL 0x07 /* Flow control line states */
140#define CP2101_MODEMCTL 0x13 /* Modem controls */
141#define CP2101_CONFIG_6 0x19 /* 6 bytes of config data ??? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Craig Shelley39a66b82005-05-27 00:09:56 +0100143/* CP2101_UART */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144#define UART_ENABLE 0x0001
145#define UART_DISABLE 0x0000
146
Craig Shelley39a66b82005-05-27 00:09:56 +0100147/* CP2101_BAUDRATE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148#define BAUD_RATE_GEN_FREQ 0x384000
149
Craig Shelley39a66b82005-05-27 00:09:56 +0100150/* CP2101_BITS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#define BITS_DATA_MASK 0X0f00
Craig Shelley39a66b82005-05-27 00:09:56 +0100152#define BITS_DATA_5 0X0500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153#define BITS_DATA_6 0X0600
154#define BITS_DATA_7 0X0700
155#define BITS_DATA_8 0X0800
156#define BITS_DATA_9 0X0900
157
158#define BITS_PARITY_MASK 0x00f0
159#define BITS_PARITY_NONE 0x0000
160#define BITS_PARITY_ODD 0x0010
161#define BITS_PARITY_EVEN 0x0020
162#define BITS_PARITY_MARK 0x0030
163#define BITS_PARITY_SPACE 0x0040
164
165#define BITS_STOP_MASK 0x000f
166#define BITS_STOP_1 0x0000
167#define BITS_STOP_1_5 0x0001
168#define BITS_STOP_2 0x0002
Craig Shelley39a66b82005-05-27 00:09:56 +0100169
170/* CP2101_BREAK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171#define BREAK_ON 0x0000
172#define BREAK_OFF 0x0001
173
Craig Shelley39a66b82005-05-27 00:09:56 +0100174/* CP2101_CONTROL */
175#define CONTROL_DTR 0x0001
176#define CONTROL_RTS 0x0002
177#define CONTROL_CTS 0x0010
178#define CONTROL_DSR 0x0020
179#define CONTROL_RING 0x0040
180#define CONTROL_DCD 0x0080
181#define CONTROL_WRITE_DTR 0x0100
182#define CONTROL_WRITE_RTS 0x0200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
Craig Shelley39a66b82005-05-27 00:09:56 +0100184/*
185 * cp2101_get_config
186 * Reads from the CP2101 configuration registers
187 * 'size' is specified in bytes.
188 * 'data' is a pointer to a pre-allocated array of integers large
189 * enough to hold 'size' bytes (with 4 bytes to each integer)
190 */
Alan Cox95da3102008-07-22 11:09:07 +0100191static int cp2101_get_config(struct usb_serial_port *port, u8 request,
Craig Shelley39a66b82005-05-27 00:09:56 +0100192 unsigned int *data, int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
194 struct usb_serial *serial = port->serial;
Al Viro53ebb3b2007-02-09 16:39:55 +0000195 __le32 *buf;
Craig Shelley39a66b82005-05-27 00:09:56 +0100196 int result, i, length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
Craig Shelley39a66b82005-05-27 00:09:56 +0100198 /* Number of integers required to contain the array */
199 length = (((size - 1) | 3) + 1)/4;
200
Al Viro53ebb3b2007-02-09 16:39:55 +0000201 buf = kcalloc(length, sizeof(__le32), GFP_KERNEL);
Craig Shelley39a66b82005-05-27 00:09:56 +0100202 if (!buf) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800203 dev_err(&port->dev, "%s - out of memory.\n", __func__);
Craig Shelley39a66b82005-05-27 00:09:56 +0100204 return -ENOMEM;
205 }
206
207 /* For get requests, the request number must be incremented */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 request++;
209
Craig Shelley39a66b82005-05-27 00:09:56 +0100210 /* Issue the request, attempting to read 'size' bytes */
Alan Coxff7eb602008-07-22 11:10:17 +0100211 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 request, REQTYPE_DEVICE_TO_HOST, 0x0000,
Craig Shelley39a66b82005-05-27 00:09:56 +0100213 0, buf, size, 300);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Craig Shelley39a66b82005-05-27 00:09:56 +0100215 /* Convert data into an array of integers */
Alan Coxff7eb602008-07-22 11:10:17 +0100216 for (i = 0; i < length; i++)
Craig Shelley39a66b82005-05-27 00:09:56 +0100217 data[i] = le32_to_cpu(buf[i]);
218
219 kfree(buf);
220
221 if (result != size) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 dev_err(&port->dev, "%s - Unable to send config request, "
Craig Shelley39a66b82005-05-27 00:09:56 +0100223 "request=0x%x size=%d result=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800224 __func__, request, size, result);
Craig Shelley39a66b82005-05-27 00:09:56 +0100225 return -EPROTO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 }
227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 return 0;
229}
230
Craig Shelley39a66b82005-05-27 00:09:56 +0100231/*
232 * cp2101_set_config
233 * Writes to the CP2101 configuration registers
234 * Values less than 16 bits wide are sent directly
235 * 'size' is specified in bytes.
236 */
Alan Cox95da3102008-07-22 11:09:07 +0100237static int cp2101_set_config(struct usb_serial_port *port, u8 request,
Craig Shelley39a66b82005-05-27 00:09:56 +0100238 unsigned int *data, int size)
239{
240 struct usb_serial *serial = port->serial;
Al Viro53ebb3b2007-02-09 16:39:55 +0000241 __le32 *buf;
Craig Shelley39a66b82005-05-27 00:09:56 +0100242 int result, i, length;
243
244 /* Number of integers required to contain the array */
245 length = (((size - 1) | 3) + 1)/4;
246
Al Viro53ebb3b2007-02-09 16:39:55 +0000247 buf = kmalloc(length * sizeof(__le32), GFP_KERNEL);
Craig Shelley39a66b82005-05-27 00:09:56 +0100248 if (!buf) {
249 dev_err(&port->dev, "%s - out of memory.\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800250 __func__);
Craig Shelley39a66b82005-05-27 00:09:56 +0100251 return -ENOMEM;
252 }
253
254 /* Array of integers into bytes */
255 for (i = 0; i < length; i++)
256 buf[i] = cpu_to_le32(data[i]);
257
258 if (size > 2) {
Alan Coxff7eb602008-07-22 11:10:17 +0100259 result = usb_control_msg(serial->dev,
Craig Shelley39a66b82005-05-27 00:09:56 +0100260 usb_sndctrlpipe(serial->dev, 0),
261 request, REQTYPE_HOST_TO_DEVICE, 0x0000,
262 0, buf, size, 300);
263 } else {
Alan Coxff7eb602008-07-22 11:10:17 +0100264 result = usb_control_msg(serial->dev,
Craig Shelley39a66b82005-05-27 00:09:56 +0100265 usb_sndctrlpipe(serial->dev, 0),
266 request, REQTYPE_HOST_TO_DEVICE, data[0],
267 0, NULL, 0, 300);
268 }
269
270 kfree(buf);
271
272 if ((size > 2 && result != size) || result < 0) {
273 dev_err(&port->dev, "%s - Unable to send request, "
274 "request=0x%x size=%d result=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800275 __func__, request, size, result);
Craig Shelley39a66b82005-05-27 00:09:56 +0100276 return -EPROTO;
277 }
278
279 /* Single data value */
Alan Coxff7eb602008-07-22 11:10:17 +0100280 result = usb_control_msg(serial->dev,
Craig Shelley39a66b82005-05-27 00:09:56 +0100281 usb_sndctrlpipe(serial->dev, 0),
282 request, REQTYPE_HOST_TO_DEVICE, data[0],
283 0, NULL, 0, 300);
284 return 0;
285}
286
287/*
288 * cp2101_set_config_single
289 * Convenience function for calling cp2101_set_config on single data values
290 * without requiring an integer pointer
291 */
Alan Cox95da3102008-07-22 11:09:07 +0100292static inline int cp2101_set_config_single(struct usb_serial_port *port,
Craig Shelley39a66b82005-05-27 00:09:56 +0100293 u8 request, unsigned int data)
294{
295 return cp2101_set_config(port, request, &data, 2);
296}
297
Alan Coxff7eb602008-07-22 11:10:17 +0100298static int cp2101_open(struct tty_struct *tty, struct usb_serial_port *port,
Alan Cox95da3102008-07-22 11:09:07 +0100299 struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
301 struct usb_serial *serial = port->serial;
302 int result;
303
Harvey Harrison441b62c2008-03-03 16:08:34 -0800304 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Craig Shelley39a66b82005-05-27 00:09:56 +0100306 if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 dev_err(&port->dev, "%s - Unable to enable UART\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800308 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return -EPROTO;
310 }
311
312 /* Start reading from the device */
Alan Coxff7eb602008-07-22 11:10:17 +0100313 usb_fill_bulk_urb(port->read_urb, serial->dev,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 usb_rcvbulkpipe(serial->dev,
315 port->bulk_in_endpointAddress),
316 port->read_urb->transfer_buffer,
317 port->read_urb->transfer_buffer_length,
318 serial->type->read_bulk_callback,
319 port);
320 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
321 if (result) {
322 dev_err(&port->dev, "%s - failed resubmitting read urb, "
Harvey Harrison441b62c2008-03-03 16:08:34 -0800323 "error %d\n", __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 return result;
325 }
326
Craig Shelley39a66b82005-05-27 00:09:56 +0100327 /* Configure the termios structure */
Alan Cox95da3102008-07-22 11:09:07 +0100328 cp2101_get_termios(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Craig Shelley39a66b82005-05-27 00:09:56 +0100330 /* Set the DTR and RTS pins low */
Alan Cox95da3102008-07-22 11:09:07 +0100331 cp2101_tiocmset(tty, NULL, TIOCM_DTR | TIOCM_RTS, 0);
Craig Shelley39a66b82005-05-27 00:09:56 +0100332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 return 0;
334}
335
Alan Coxff7eb602008-07-22 11:10:17 +0100336static void cp2101_cleanup(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
338 struct usb_serial *serial = port->serial;
339
Harvey Harrison441b62c2008-03-03 16:08:34 -0800340 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342 if (serial->dev) {
343 /* shutdown any bulk reads that might be going on */
344 if (serial->num_bulk_out)
345 usb_kill_urb(port->write_urb);
346 if (serial->num_bulk_in)
347 usb_kill_urb(port->read_urb);
348 }
349}
350
Alan Cox95da3102008-07-22 11:09:07 +0100351static void cp2101_close(struct tty_struct *tty, struct usb_serial_port *port,
Alan Coxff7eb602008-07-22 11:10:17 +0100352 struct file *filp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800354 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
356 /* shutdown our urbs */
Harvey Harrison441b62c2008-03-03 16:08:34 -0800357 dbg("%s - shutting down urbs", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 usb_kill_urb(port->write_urb);
359 usb_kill_urb(port->read_urb);
360
Oliver Neukum95bef012008-01-22 13:56:18 +0100361 mutex_lock(&port->serial->disc_mutex);
362 if (!port->serial->disconnected)
363 cp2101_set_config_single(port, CP2101_UART, UART_DISABLE);
364 mutex_unlock(&port->serial->disc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365}
366
Craig Shelley39a66b82005-05-27 00:09:56 +0100367/*
368 * cp2101_get_termios
369 * Reads the baud rate, data bits, parity, stop bits and flow control mode
370 * from the device, corrects any unsupported values, and configures the
371 * termios structure to reflect the state of the device
372 */
Alan Cox95da3102008-07-22 11:09:07 +0100373static void cp2101_get_termios (struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
Alan Cox95da3102008-07-22 11:09:07 +0100375 struct usb_serial_port *port = tty->driver_data;
Craig Shelley39a66b82005-05-27 00:09:56 +0100376 unsigned int cflag, modem_ctl[4];
Harvey Harrisonb2bdd1f2008-05-30 10:29:55 -0700377 unsigned int baud;
378 unsigned int bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379
Harvey Harrison441b62c2008-03-03 16:08:34 -0800380 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Craig Shelley39a66b82005-05-27 00:09:56 +0100382 cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
383 /* Convert to baudrate */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 if (baud)
385 baud = BAUD_RATE_GEN_FREQ / baud;
386
Harvey Harrison441b62c2008-03-03 16:08:34 -0800387 dbg("%s - baud rate = %d", __func__, baud);
Alan Cox9ab0f202007-10-18 01:24:24 -0700388
Alan Cox95da3102008-07-22 11:09:07 +0100389 tty_encode_baud_rate(tty, baud, baud);
390 cflag = tty->termios->c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Craig Shelley39a66b82005-05-27 00:09:56 +0100392 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 cflag &= ~CSIZE;
Alan Coxff7eb602008-07-22 11:10:17 +0100394 switch (bits & BITS_DATA_MASK) {
395 case BITS_DATA_5:
396 dbg("%s - data bits = 5", __func__);
397 cflag |= CS5;
398 break;
399 case BITS_DATA_6:
400 dbg("%s - data bits = 6", __func__);
401 cflag |= CS6;
402 break;
403 case BITS_DATA_7:
404 dbg("%s - data bits = 7", __func__);
405 cflag |= CS7;
406 break;
407 case BITS_DATA_8:
408 dbg("%s - data bits = 8", __func__);
409 cflag |= CS8;
410 break;
411 case BITS_DATA_9:
412 dbg("%s - data bits = 9 (not supported, using 8 data bits)",
413 __func__);
414 cflag |= CS8;
415 bits &= ~BITS_DATA_MASK;
416 bits |= BITS_DATA_8;
417 cp2101_set_config(port, CP2101_BITS, &bits, 2);
418 break;
419 default:
420 dbg("%s - Unknown number of data bits, using 8", __func__);
421 cflag |= CS8;
422 bits &= ~BITS_DATA_MASK;
423 bits |= BITS_DATA_8;
424 cp2101_set_config(port, CP2101_BITS, &bits, 2);
425 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 }
427
Alan Coxff7eb602008-07-22 11:10:17 +0100428 switch (bits & BITS_PARITY_MASK) {
429 case BITS_PARITY_NONE:
430 dbg("%s - parity = NONE", __func__);
431 cflag &= ~PARENB;
432 break;
433 case BITS_PARITY_ODD:
434 dbg("%s - parity = ODD", __func__);
435 cflag |= (PARENB|PARODD);
436 break;
437 case BITS_PARITY_EVEN:
438 dbg("%s - parity = EVEN", __func__);
439 cflag &= ~PARODD;
440 cflag |= PARENB;
441 break;
442 case BITS_PARITY_MARK:
443 dbg("%s - parity = MARK (not supported, disabling parity)",
444 __func__);
445 cflag &= ~PARENB;
446 bits &= ~BITS_PARITY_MASK;
447 cp2101_set_config(port, CP2101_BITS, &bits, 2);
448 break;
449 case BITS_PARITY_SPACE:
450 dbg("%s - parity = SPACE (not supported, disabling parity)",
451 __func__);
452 cflag &= ~PARENB;
453 bits &= ~BITS_PARITY_MASK;
454 cp2101_set_config(port, CP2101_BITS, &bits, 2);
455 break;
456 default:
457 dbg("%s - Unknown parity mode, disabling parity", __func__);
458 cflag &= ~PARENB;
459 bits &= ~BITS_PARITY_MASK;
460 cp2101_set_config(port, CP2101_BITS, &bits, 2);
461 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 }
463
464 cflag &= ~CSTOPB;
Alan Coxff7eb602008-07-22 11:10:17 +0100465 switch (bits & BITS_STOP_MASK) {
466 case BITS_STOP_1:
467 dbg("%s - stop bits = 1", __func__);
468 break;
469 case BITS_STOP_1_5:
470 dbg("%s - stop bits = 1.5 (not supported, using 1 stop bit)",
471 __func__);
472 bits &= ~BITS_STOP_MASK;
473 cp2101_set_config(port, CP2101_BITS, &bits, 2);
474 break;
475 case BITS_STOP_2:
476 dbg("%s - stop bits = 2", __func__);
477 cflag |= CSTOPB;
478 break;
479 default:
480 dbg("%s - Unknown number of stop bits, using 1 stop bit",
481 __func__);
482 bits &= ~BITS_STOP_MASK;
483 cp2101_set_config(port, CP2101_BITS, &bits, 2);
484 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 }
486
Craig Shelley39a66b82005-05-27 00:09:56 +0100487 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
488 if (modem_ctl[0] & 0x0008) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800489 dbg("%s - flow control = CRTSCTS", __func__);
Craig Shelley39a66b82005-05-27 00:09:56 +0100490 cflag |= CRTSCTS;
491 } else {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800492 dbg("%s - flow control = NONE", __func__);
Craig Shelley39a66b82005-05-27 00:09:56 +0100493 cflag &= ~CRTSCTS;
494 }
495
Alan Cox95da3102008-07-22 11:09:07 +0100496 tty->termios->c_cflag = cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497}
498
Alan Coxff7eb602008-07-22 11:10:17 +0100499static void cp2101_set_termios(struct tty_struct *tty,
Alan Cox95da3102008-07-22 11:09:07 +0100500 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
Alan Cox9ab0f202007-10-18 01:24:24 -0700502 unsigned int cflag, old_cflag;
Harvey Harrisonb2bdd1f2008-05-30 10:29:55 -0700503 unsigned int baud = 0, bits;
Craig Shelley39a66b82005-05-27 00:09:56 +0100504 unsigned int modem_ctl[4];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Harvey Harrison441b62c2008-03-03 16:08:34 -0800506 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Alan Cox95da3102008-07-22 11:09:07 +0100508 if (!tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 return;
Alan Cox9ab0f202007-10-18 01:24:24 -0700510
Alan Cox95da3102008-07-22 11:09:07 +0100511 tty->termios->c_cflag &= ~CMSPAR;
512 cflag = tty->termios->c_cflag;
Alan Cox01e96d22007-07-26 18:54:12 +0100513 old_cflag = old_termios->c_cflag;
Alan Cox95da3102008-07-22 11:09:07 +0100514 baud = tty_get_baud_rate(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
516 /* If the baud rate is to be updated*/
Alan Cox01e96d22007-07-26 18:54:12 +0100517 if (baud != tty_termios_baud_rate(old_termios)) {
518 switch (baud) {
Alan Coxff7eb602008-07-22 11:10:17 +0100519 case 0:
520 case 600:
521 case 1200:
522 case 1800:
523 case 2400:
524 case 4800:
525 case 7200:
526 case 9600:
527 case 14400:
528 case 19200:
529 case 28800:
530 case 38400:
531 case 55854:
532 case 57600:
533 case 115200:
534 case 127117:
535 case 230400:
536 case 460800:
537 case 921600:
538 case 3686400:
539 break;
540 default:
541 baud = 9600;
542 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 }
544
545 if (baud) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800546 dbg("%s - Setting baud rate to %d baud", __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 baud);
Craig Shelley39a66b82005-05-27 00:09:56 +0100548 if (cp2101_set_config_single(port, CP2101_BAUDRATE,
Alan Cox9ab0f202007-10-18 01:24:24 -0700549 (BAUD_RATE_GEN_FREQ / baud))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 dev_err(&port->dev, "Baud rate requested not "
551 "supported by device\n");
Alan Cox9ab0f202007-10-18 01:24:24 -0700552 baud = tty_termios_baud_rate(old_termios);
553 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 }
555 }
Alan Cox9ab0f202007-10-18 01:24:24 -0700556 /* Report back the resulting baud rate */
Alan Cox95da3102008-07-22 11:09:07 +0100557 tty_encode_baud_rate(tty, baud, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Craig Shelley39a66b82005-05-27 00:09:56 +0100559 /* If the number of data bits is to be updated */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100561 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 bits &= ~BITS_DATA_MASK;
563 switch (cflag & CSIZE) {
Alan Coxff7eb602008-07-22 11:10:17 +0100564 case CS5:
565 bits |= BITS_DATA_5;
566 dbg("%s - data bits = 5", __func__);
567 break;
568 case CS6:
569 bits |= BITS_DATA_6;
570 dbg("%s - data bits = 6", __func__);
571 break;
572 case CS7:
573 bits |= BITS_DATA_7;
574 dbg("%s - data bits = 7", __func__);
575 break;
576 case CS8:
577 bits |= BITS_DATA_8;
578 dbg("%s - data bits = 8", __func__);
579 break;
580 /*case CS9:
581 bits |= BITS_DATA_9;
582 dbg("%s - data bits = 9", __func__);
583 break;*/
584 default:
585 dev_err(&port->dev, "cp2101 driver does not "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 "support the number of bits requested,"
587 " using 8 bit mode\n");
588 bits |= BITS_DATA_8;
589 break;
590 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100591 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 dev_err(&port->dev, "Number of data bits requested "
593 "not supported by device\n");
594 }
595
596 if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100597 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 bits &= ~BITS_PARITY_MASK;
599 if (cflag & PARENB) {
600 if (cflag & PARODD) {
601 bits |= BITS_PARITY_ODD;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800602 dbg("%s - parity = ODD", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 } else {
604 bits |= BITS_PARITY_EVEN;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800605 dbg("%s - parity = EVEN", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 }
607 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100608 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 dev_err(&port->dev, "Parity mode not supported "
610 "by device\n");
611 }
612
613 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100614 cp2101_get_config(port, CP2101_BITS, &bits, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 bits &= ~BITS_STOP_MASK;
616 if (cflag & CSTOPB) {
617 bits |= BITS_STOP_2;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800618 dbg("%s - stop bits = 2", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 } else {
620 bits |= BITS_STOP_1;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800621 dbg("%s - stop bits = 1", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100623 if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 dev_err(&port->dev, "Number of stop bits requested "
625 "not supported by device\n");
626 }
Craig Shelley39a66b82005-05-27 00:09:56 +0100627
628 if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
629 cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
630 dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800631 __func__, modem_ctl[0], modem_ctl[1],
Craig Shelley39a66b82005-05-27 00:09:56 +0100632 modem_ctl[2], modem_ctl[3]);
633
634 if (cflag & CRTSCTS) {
635 modem_ctl[0] &= ~0x7B;
636 modem_ctl[0] |= 0x09;
637 modem_ctl[1] = 0x80;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800638 dbg("%s - flow control = CRTSCTS", __func__);
Craig Shelley39a66b82005-05-27 00:09:56 +0100639 } else {
640 modem_ctl[0] &= ~0x7B;
641 modem_ctl[0] |= 0x01;
642 modem_ctl[1] |= 0x40;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800643 dbg("%s - flow control = NONE", __func__);
Craig Shelley39a66b82005-05-27 00:09:56 +0100644 }
645
646 dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800647 __func__, modem_ctl[0], modem_ctl[1],
Craig Shelley39a66b82005-05-27 00:09:56 +0100648 modem_ctl[2], modem_ctl[3]);
649 cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16);
650 }
651
652}
653
Alan Cox95da3102008-07-22 11:09:07 +0100654static int cp2101_tiocmset (struct tty_struct *tty, struct file *file,
Craig Shelley39a66b82005-05-27 00:09:56 +0100655 unsigned int set, unsigned int clear)
656{
Alan Cox95da3102008-07-22 11:09:07 +0100657 struct usb_serial_port *port = tty->driver_data;
Harvey Harrisonb2bdd1f2008-05-30 10:29:55 -0700658 unsigned int control = 0;
Craig Shelley39a66b82005-05-27 00:09:56 +0100659
Harvey Harrison441b62c2008-03-03 16:08:34 -0800660 dbg("%s - port %d", __func__, port->number);
Craig Shelley39a66b82005-05-27 00:09:56 +0100661
662 if (set & TIOCM_RTS) {
663 control |= CONTROL_RTS;
664 control |= CONTROL_WRITE_RTS;
665 }
666 if (set & TIOCM_DTR) {
667 control |= CONTROL_DTR;
668 control |= CONTROL_WRITE_DTR;
669 }
670 if (clear & TIOCM_RTS) {
671 control &= ~CONTROL_RTS;
672 control |= CONTROL_WRITE_RTS;
673 }
674 if (clear & TIOCM_DTR) {
675 control &= ~CONTROL_DTR;
676 control |= CONTROL_WRITE_DTR;
677 }
678
Harvey Harrison441b62c2008-03-03 16:08:34 -0800679 dbg("%s - control = 0x%.4x", __func__, control);
Craig Shelley39a66b82005-05-27 00:09:56 +0100680
681 return cp2101_set_config(port, CP2101_CONTROL, &control, 2);
682
683}
684
Alan Cox95da3102008-07-22 11:09:07 +0100685static int cp2101_tiocmget (struct tty_struct *tty, struct file *file)
Craig Shelley39a66b82005-05-27 00:09:56 +0100686{
Alan Cox95da3102008-07-22 11:09:07 +0100687 struct usb_serial_port *port = tty->driver_data;
Harvey Harrisonb2bdd1f2008-05-30 10:29:55 -0700688 unsigned int control;
689 int result;
Craig Shelley39a66b82005-05-27 00:09:56 +0100690
Harvey Harrison441b62c2008-03-03 16:08:34 -0800691 dbg("%s - port %d", __func__, port->number);
Craig Shelley39a66b82005-05-27 00:09:56 +0100692
693 cp2101_get_config(port, CP2101_CONTROL, &control, 1);
694
695 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
696 |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
697 |((control & CONTROL_CTS) ? TIOCM_CTS : 0)
698 |((control & CONTROL_DSR) ? TIOCM_DSR : 0)
699 |((control & CONTROL_RING)? TIOCM_RI : 0)
700 |((control & CONTROL_DCD) ? TIOCM_CD : 0);
701
Harvey Harrison441b62c2008-03-03 16:08:34 -0800702 dbg("%s - control = 0x%.2x", __func__, control);
Craig Shelley39a66b82005-05-27 00:09:56 +0100703
704 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
Alan Cox95da3102008-07-22 11:09:07 +0100707static void cp2101_break_ctl (struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708{
Alan Cox95da3102008-07-22 11:09:07 +0100709 struct usb_serial_port *port = tty->driver_data;
Harvey Harrisonb2bdd1f2008-05-30 10:29:55 -0700710 unsigned int state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
Harvey Harrison441b62c2008-03-03 16:08:34 -0800712 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 if (break_state == 0)
714 state = BREAK_OFF;
715 else
716 state = BREAK_ON;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800717 dbg("%s - turning break %s", __func__,
Alan Coxff7eb602008-07-22 11:10:17 +0100718 state == BREAK_OFF ? "off" : "on");
Craig Shelley39a66b82005-05-27 00:09:56 +0100719 cp2101_set_config(port, CP2101_BREAK, &state, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720}
721
Alan Coxff7eb602008-07-22 11:10:17 +0100722static int cp2101_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
Craig Shelley39a66b82005-05-27 00:09:56 +0100724 /* CP2101 buffers behave strangely unless device is reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 usb_reset_device(serial->dev);
726 return 0;
727}
728
Alan Coxff7eb602008-07-22 11:10:17 +0100729static void cp2101_shutdown(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730{
731 int i;
732
Harvey Harrison441b62c2008-03-03 16:08:34 -0800733 dbg("%s", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
Craig Shelley39a66b82005-05-27 00:09:56 +0100735 /* Stop reads and writes on all ports */
Alan Coxff7eb602008-07-22 11:10:17 +0100736 for (i = 0; i < serial->num_ports; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 cp2101_cleanup(serial->port[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
739
Alan Coxff7eb602008-07-22 11:10:17 +0100740static int __init cp2101_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741{
742 int retval;
743
744 retval = usb_serial_register(&cp2101_device);
745 if (retval)
Craig Shelley39a66b82005-05-27 00:09:56 +0100746 return retval; /* Failed to register */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 retval = usb_register(&cp2101_driver);
749 if (retval) {
Craig Shelley39a66b82005-05-27 00:09:56 +0100750 /* Failed to register */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 usb_serial_deregister(&cp2101_device);
752 return retval;
753 }
754
Craig Shelley39a66b82005-05-27 00:09:56 +0100755 /* Success */
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -0700756 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
757 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 return 0;
759}
760
Alan Coxff7eb602008-07-22 11:10:17 +0100761static void __exit cp2101_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
Alan Coxff7eb602008-07-22 11:10:17 +0100763 usb_deregister(&cp2101_driver);
764 usb_serial_deregister(&cp2101_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765}
766
767module_init(cp2101_init);
768module_exit(cp2101_exit);
769
770MODULE_DESCRIPTION(DRIVER_DESC);
771MODULE_VERSION(DRIVER_VERSION);
772MODULE_LICENSE("GPL");
773
774module_param(debug, bool, S_IRUGO | S_IWUSR);
775MODULE_PARM_DESC(debug, "Enable verbose debugging messages");