Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * MCT (Magic Control Technology Corp.) USB RS232 Converter Driver |
| 3 | * |
| 4 | * Copyright (C) 2000 Wolfgang Grandegger (wolfgang@ces.ch) |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify |
| 7 | * it under the terms of the GNU General Public License as published by |
| 8 | * the Free Software Foundation; either version 2 of the License, or |
| 9 | * (at your option) any later version. |
| 10 | * |
| 11 | * This program is largely derived from the Belkin USB Serial Adapter Driver |
| 12 | * (see belkin_sa.[ch]). All of the information about the device was acquired |
| 13 | * by using SniffUSB on Windows98. For technical details see mct_u232.h. |
| 14 | * |
| 15 | * William G. Greathouse and Greg Kroah-Hartman provided great help on how to |
| 16 | * do the reverse engineering and how to write a USB serial device driver. |
| 17 | * |
| 18 | * TO BE DONE, TO BE CHECKED: |
| 19 | * DTR/RTS signal handling may be incomplete or incorrect. I have mainly |
| 20 | * implemented what I have seen with SniffUSB or found in belkin_sa.c. |
| 21 | * For further TODOs check also belkin_sa.c. |
| 22 | * |
| 23 | * TEST STATUS: |
| 24 | * Basic tests have been performed with minicom/zmodem transfers and |
| 25 | * modem dialing under Linux 2.4.0-test10 (for me it works fine). |
| 26 | * |
| 27 | * 04-Nov-2003 Bill Marr <marr at flex dot com> |
| 28 | * - Mimic Windows driver by sending 2 USB 'device request' messages |
| 29 | * following normal 'baud rate change' message. This allows data to be |
| 30 | * transmitted to RS-232 devices which don't assert the 'CTS' signal. |
| 31 | * |
| 32 | * 10-Nov-2001 Wolfgang Grandegger |
| 33 | * - Fixed an endianess problem with the baudrate selection for PowerPC. |
| 34 | * |
| 35 | * 06-Dec-2001 Martin Hamilton <martinh@gnu.org> |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 36 | * - Added support for the Belkin F5U109 DB9 adaptor |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | * |
| 38 | * 30-May-2001 Greg Kroah-Hartman |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 39 | * - switched from using spinlock to a semaphore, which fixes lots of |
| 40 | * problems. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | * |
| 42 | * 04-May-2001 Stelian Pop |
| 43 | * - Set the maximum bulk output size for Sitecom U232-P25 model to 16 bytes |
| 44 | * instead of the device reported 32 (using 32 bytes causes many data |
| 45 | * loss, Windows driver uses 16 too). |
| 46 | * |
| 47 | * 02-May-2001 Stelian Pop |
| 48 | * - Fixed the baud calculation for Sitecom U232-P25 model |
| 49 | * |
| 50 | * 08-Apr-2001 gb |
| 51 | * - Identify version on module load. |
| 52 | * |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 53 | * 06-Jan-2001 Cornel Ciocirlan |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | * - Added support for Sitecom U232-P25 model (Product Id 0x0230) |
| 55 | * - Added support for D-Link DU-H3SP USB BAY (Product Id 0x0200) |
| 56 | * |
| 57 | * 29-Nov-2000 Greg Kroah-Hartman |
| 58 | * - Added device id table to fit with 2.4.0-test11 structure. |
| 59 | * - took out DEAL_WITH_TWO_INT_IN_ENDPOINTS #define as it's not needed |
| 60 | * (lots of things will change if/when the usb-serial core changes to |
| 61 | * handle these issues. |
| 62 | * |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 63 | * 27-Nov-2000 Wolfgang Grandegge |
| 64 | * A version for kernel 2.4.0-test10 released to the Linux community |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | * (via linux-usb-devel). |
| 66 | */ |
| 67 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | #include <linux/kernel.h> |
| 69 | #include <linux/errno.h> |
| 70 | #include <linux/init.h> |
| 71 | #include <linux/slab.h> |
| 72 | #include <linux/tty.h> |
| 73 | #include <linux/tty_driver.h> |
| 74 | #include <linux/tty_flip.h> |
| 75 | #include <linux/module.h> |
| 76 | #include <linux/spinlock.h> |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 77 | #include <linux/uaccess.h> |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 78 | #include <asm/unaligned.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | #include <linux/usb.h> |
Greg Kroah-Hartman | a969888 | 2006-07-11 21:22:58 -0700 | [diff] [blame] | 80 | #include <linux/usb/serial.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | #include "mct_u232.h" |
| 82 | |
| 83 | /* |
| 84 | * Version Information |
| 85 | */ |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 86 | #define DRIVER_VERSION "z2.1" /* Linux in-kernel version */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>" |
| 88 | #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver" |
| 89 | |
| 90 | static int debug; |
| 91 | |
| 92 | /* |
| 93 | * Function prototypes |
| 94 | */ |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 95 | static int mct_u232_startup(struct usb_serial *serial); |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 96 | static void mct_u232_release(struct usb_serial *serial); |
Alan Cox | a509a7e | 2009-09-19 13:13:26 -0700 | [diff] [blame] | 97 | static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port); |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 98 | static void mct_u232_close(struct usb_serial_port *port); |
| 99 | static void mct_u232_dtr_rts(struct usb_serial_port *port, int on); |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 100 | static void mct_u232_read_int_callback(struct urb *urb); |
| 101 | static void mct_u232_set_termios(struct tty_struct *tty, |
| 102 | struct usb_serial_port *port, struct ktermios *old); |
| 103 | static void mct_u232_break_ctl(struct tty_struct *tty, int break_state); |
| 104 | static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file); |
| 105 | static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file, |
| 106 | unsigned int set, unsigned int clear); |
| 107 | static void mct_u232_throttle(struct tty_struct *tty); |
| 108 | static void mct_u232_unthrottle(struct tty_struct *tty); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 109 | |
| 110 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | /* |
| 112 | * All of the device info needed for the MCT USB-RS232 converter. |
| 113 | */ |
Németh Márton | 7d40d7e | 2010-01-10 15:34:24 +0100 | [diff] [blame] | 114 | static const struct usb_device_id id_table_combined[] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | { USB_DEVICE(MCT_U232_VID, MCT_U232_PID) }, |
| 116 | { USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) }, |
| 117 | { USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) }, |
| 118 | { USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) }, |
| 119 | { } /* Terminating entry */ |
| 120 | }; |
| 121 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 122 | MODULE_DEVICE_TABLE(usb, id_table_combined); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | |
| 124 | static struct usb_driver mct_u232_driver = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | .name = "mct_u232", |
| 126 | .probe = usb_serial_probe, |
| 127 | .disconnect = usb_serial_disconnect, |
| 128 | .id_table = id_table_combined, |
Greg Kroah-Hartman | ba9dc65 | 2005-11-16 13:41:28 -0800 | [diff] [blame] | 129 | .no_dynamic_id = 1, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | }; |
| 131 | |
Greg Kroah-Hartman | ea65370 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 132 | static struct usb_serial_driver mct_u232_device = { |
Greg Kroah-Hartman | 18fcac3 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 133 | .driver = { |
| 134 | .owner = THIS_MODULE, |
Greg Kroah-Hartman | 269bda1 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 135 | .name = "mct_u232", |
Greg Kroah-Hartman | 18fcac3 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 136 | }, |
Greg Kroah-Hartman | 269bda1 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 137 | .description = "MCT U232", |
Johannes Hölzl | d9b1b78 | 2006-12-17 21:50:24 +0100 | [diff] [blame] | 138 | .usb_driver = &mct_u232_driver, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | .id_table = id_table_combined, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | .num_ports = 1, |
| 141 | .open = mct_u232_open, |
| 142 | .close = mct_u232_close, |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 143 | .dtr_rts = mct_u232_dtr_rts, |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 144 | .throttle = mct_u232_throttle, |
| 145 | .unthrottle = mct_u232_unthrottle, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 146 | .read_int_callback = mct_u232_read_int_callback, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | .set_termios = mct_u232_set_termios, |
| 148 | .break_ctl = mct_u232_break_ctl, |
| 149 | .tiocmget = mct_u232_tiocmget, |
| 150 | .tiocmset = mct_u232_tiocmset, |
| 151 | .attach = mct_u232_startup, |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 152 | .release = mct_u232_release, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | }; |
| 154 | |
| 155 | |
| 156 | struct mct_u232_private { |
| 157 | spinlock_t lock; |
| 158 | unsigned int control_state; /* Modem Line Setting (TIOCM) */ |
| 159 | unsigned char last_lcr; /* Line Control Register */ |
| 160 | unsigned char last_lsr; /* Line Status Register */ |
| 161 | unsigned char last_msr; /* Modem Status Register */ |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 162 | unsigned int rx_flags; /* Throttling flags */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | }; |
| 164 | |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 165 | #define THROTTLED 0x01 |
| 166 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | /* |
| 168 | * Handle vendor specific USB requests |
| 169 | */ |
| 170 | |
| 171 | #define WDR_TIMEOUT 5000 /* default urb timeout */ |
| 172 | |
| 173 | /* |
| 174 | * Later day 2.6.0-test kernels have new baud rates like B230400 which |
| 175 | * we do not know how to support. We ignore them for the moment. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | */ |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 177 | static int mct_u232_calculate_baud_rate(struct usb_serial *serial, |
| 178 | speed_t value, speed_t *result) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | { |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 180 | *result = value; |
| 181 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 183 | || le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | switch (value) { |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 185 | case 300: |
| 186 | return 0x01; |
| 187 | case 600: |
| 188 | return 0x02; /* this one not tested */ |
| 189 | case 1200: |
| 190 | return 0x03; |
| 191 | case 2400: |
| 192 | return 0x04; |
| 193 | case 4800: |
| 194 | return 0x06; |
| 195 | case 9600: |
| 196 | return 0x08; |
| 197 | case 19200: |
| 198 | return 0x09; |
| 199 | case 38400: |
| 200 | return 0x0a; |
| 201 | case 57600: |
| 202 | return 0x0b; |
| 203 | case 115200: |
| 204 | return 0x0c; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 205 | default: |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 206 | *result = 9600; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 207 | return 0x08; |
| 208 | } |
| 209 | } else { |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 210 | /* FIXME: Can we use any divider - should we do |
| 211 | divider = 115200/value; |
| 212 | real baud = 115200/divider */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | switch (value) { |
Andrew Morton | b3aceb2 | 2007-08-10 14:53:35 -0700 | [diff] [blame] | 214 | case 300: break; |
| 215 | case 600: break; |
| 216 | case 1200: break; |
| 217 | case 2400: break; |
| 218 | case 4800: break; |
| 219 | case 9600: break; |
| 220 | case 19200: break; |
| 221 | case 38400: break; |
| 222 | case 57600: break; |
| 223 | case 115200: break; |
| 224 | default: |
Andrew Morton | b3aceb2 | 2007-08-10 14:53:35 -0700 | [diff] [blame] | 225 | value = 9600; |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 226 | *result = 9600; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | } |
| 228 | return 115200/value; |
| 229 | } |
| 230 | } |
| 231 | |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 232 | static int mct_u232_set_baud_rate(struct tty_struct *tty, |
| 233 | struct usb_serial *serial, struct usb_serial_port *port, speed_t value) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | { |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 235 | unsigned int divisor; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 236 | int rc; |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 237 | unsigned char *buf; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 238 | unsigned char cts_enable_byte = 0; |
| 239 | speed_t speed; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 240 | |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 241 | buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
| 242 | if (buf == NULL) |
| 243 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 245 | divisor = mct_u232_calculate_baud_rate(serial, value, &speed); |
| 246 | put_unaligned_le32(cpu_to_le32(divisor), buf); |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 247 | rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 248 | MCT_U232_SET_BAUD_RATE_REQUEST, |
| 249 | MCT_U232_SET_REQUEST_TYPE, |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 250 | 0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE, |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 251 | WDR_TIMEOUT); |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 252 | if (rc < 0) /*FIXME: What value speed results */ |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 253 | dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n", |
| 254 | value, rc); |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 255 | else |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 256 | tty_encode_baud_rate(tty, speed, speed); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 257 | dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor); |
| 258 | |
| 259 | /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which |
| 260 | always sends two extra USB 'device request' messages after the |
| 261 | 'baud rate change' message. The actual functionality of the |
| 262 | request codes in these messages is not fully understood but these |
| 263 | particular codes are never seen in any operation besides a baud |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 264 | rate change. Both of these messages send a single byte of data. |
| 265 | In the first message, the value of this byte is always zero. |
| 266 | |
| 267 | The second message has been determined experimentally to control |
| 268 | whether data will be transmitted to a device which is not asserting |
| 269 | the 'CTS' signal. If the second message's data byte is zero, data |
| 270 | will be transmitted even if 'CTS' is not asserted (i.e. no hardware |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 271 | flow control). if the second message's data byte is nonzero (a |
| 272 | value of 1 is used by this driver), data will not be transmitted to |
| 273 | a device which is not asserting 'CTS'. |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 274 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 276 | buf[0] = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 278 | MCT_U232_SET_UNKNOWN1_REQUEST, |
| 279 | MCT_U232_SET_REQUEST_TYPE, |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 280 | 0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE, |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 281 | WDR_TIMEOUT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | if (rc < 0) |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 283 | dev_err(&port->dev, "Sending USB device request code %d " |
| 284 | "failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST, |
| 285 | rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 286 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 287 | if (port && C_CRTSCTS(tty)) |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 288 | cts_enable_byte = 1; |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 289 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 290 | dbg("set_baud_rate: send second control message, data = %02X", |
| 291 | cts_enable_byte); |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 292 | buf[0] = cts_enable_byte; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 293 | rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 294 | MCT_U232_SET_CTS_REQUEST, |
| 295 | MCT_U232_SET_REQUEST_TYPE, |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 296 | 0, 0, buf, MCT_U232_SET_CTS_SIZE, |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 297 | WDR_TIMEOUT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 298 | if (rc < 0) |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 299 | dev_err(&port->dev, "Sending USB device request code %d " |
| 300 | "failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 301 | |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 302 | kfree(buf); |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 303 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 304 | } /* mct_u232_set_baud_rate */ |
| 305 | |
| 306 | static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr) |
| 307 | { |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 308 | int rc; |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 309 | unsigned char *buf; |
| 310 | |
| 311 | buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
| 312 | if (buf == NULL) |
| 313 | return -ENOMEM; |
| 314 | |
| 315 | buf[0] = lcr; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 316 | rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 317 | MCT_U232_SET_LINE_CTRL_REQUEST, |
| 318 | MCT_U232_SET_REQUEST_TYPE, |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 319 | 0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE, |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 320 | WDR_TIMEOUT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | if (rc < 0) |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 322 | dev_err(&serial->dev->dev, |
| 323 | "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | dbg("set_line_ctrl: 0x%x", lcr); |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 325 | kfree(buf); |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 326 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | } /* mct_u232_set_line_ctrl */ |
| 328 | |
| 329 | static int mct_u232_set_modem_ctrl(struct usb_serial *serial, |
| 330 | unsigned int control_state) |
| 331 | { |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 332 | int rc; |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 333 | unsigned char mcr; |
| 334 | unsigned char *buf; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 336 | buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
| 337 | if (buf == NULL) |
| 338 | return -ENOMEM; |
| 339 | |
| 340 | mcr = MCT_U232_MCR_NONE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 341 | if (control_state & TIOCM_DTR) |
| 342 | mcr |= MCT_U232_MCR_DTR; |
| 343 | if (control_state & TIOCM_RTS) |
| 344 | mcr |= MCT_U232_MCR_RTS; |
| 345 | |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 346 | buf[0] = mcr; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 347 | rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
| 348 | MCT_U232_SET_MODEM_CTRL_REQUEST, |
| 349 | MCT_U232_SET_REQUEST_TYPE, |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 350 | 0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE, |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 351 | WDR_TIMEOUT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 352 | if (rc < 0) |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 353 | dev_err(&serial->dev->dev, |
| 354 | "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr); |
| 356 | |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 357 | kfree(buf); |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 358 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | } /* mct_u232_set_modem_ctrl */ |
| 360 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 361 | static int mct_u232_get_modem_stat(struct usb_serial *serial, |
| 362 | unsigned char *msr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 363 | { |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 364 | int rc; |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 365 | unsigned char *buf; |
| 366 | |
| 367 | buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
| 368 | if (buf == NULL) { |
| 369 | *msr = 0; |
| 370 | return -ENOMEM; |
| 371 | } |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 372 | rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), |
| 373 | MCT_U232_GET_MODEM_STAT_REQUEST, |
| 374 | MCT_U232_GET_REQUEST_TYPE, |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 375 | 0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE, |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 376 | WDR_TIMEOUT); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 377 | if (rc < 0) { |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 378 | dev_err(&serial->dev->dev, |
| 379 | "Get MODEM STATus failed (error = %d)\n", rc); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 380 | *msr = 0; |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 381 | } else { |
| 382 | *msr = buf[0]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 383 | } |
| 384 | dbg("get_modem_stat: 0x%x", *msr); |
Pete Zaitcev | af2ac1a | 2009-12-07 20:29:05 -0700 | [diff] [blame] | 385 | kfree(buf); |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 386 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | } /* mct_u232_get_modem_stat */ |
| 388 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 389 | static void mct_u232_msr_to_state(unsigned int *control_state, |
| 390 | unsigned char msr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 391 | { |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 392 | /* Translate Control Line states */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 393 | if (msr & MCT_U232_MSR_DSR) |
| 394 | *control_state |= TIOCM_DSR; |
| 395 | else |
| 396 | *control_state &= ~TIOCM_DSR; |
| 397 | if (msr & MCT_U232_MSR_CTS) |
| 398 | *control_state |= TIOCM_CTS; |
| 399 | else |
| 400 | *control_state &= ~TIOCM_CTS; |
| 401 | if (msr & MCT_U232_MSR_RI) |
| 402 | *control_state |= TIOCM_RI; |
| 403 | else |
| 404 | *control_state &= ~TIOCM_RI; |
| 405 | if (msr & MCT_U232_MSR_CD) |
| 406 | *control_state |= TIOCM_CD; |
| 407 | else |
| 408 | *control_state &= ~TIOCM_CD; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 409 | dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 410 | } /* mct_u232_msr_to_state */ |
| 411 | |
| 412 | /* |
| 413 | * Driver's tty interface functions |
| 414 | */ |
| 415 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 416 | static int mct_u232_startup(struct usb_serial *serial) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 417 | { |
| 418 | struct mct_u232_private *priv; |
| 419 | struct usb_serial_port *port, *rport; |
| 420 | |
Eric Sesterhenn | 80b6ca4 | 2006-02-27 21:29:43 +0100 | [diff] [blame] | 421 | priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 422 | if (!priv) |
| 423 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 424 | spin_lock_init(&priv->lock); |
| 425 | usb_set_serial_port_data(serial->port[0], priv); |
| 426 | |
| 427 | init_waitqueue_head(&serial->port[0]->write_wait); |
| 428 | |
| 429 | /* Puh, that's dirty */ |
| 430 | port = serial->port[0]; |
| 431 | rport = serial->port[1]; |
Mariusz Kozlowski | 73135bb | 2006-11-08 15:36:42 +0100 | [diff] [blame] | 432 | /* No unlinking, it wasn't submitted yet. */ |
| 433 | usb_free_urb(port->read_urb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 434 | port->read_urb = rport->interrupt_in_urb; |
| 435 | rport->interrupt_in_urb = NULL; |
| 436 | port->read_urb->context = port; |
| 437 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 438 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | } /* mct_u232_startup */ |
| 440 | |
| 441 | |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 442 | static void mct_u232_release(struct usb_serial *serial) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | { |
| 444 | struct mct_u232_private *priv; |
| 445 | int i; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 446 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 447 | dbg("%s", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 449 | for (i = 0; i < serial->num_ports; ++i) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 450 | /* My special items, the standard routines free my urbs */ |
| 451 | priv = usb_get_serial_port_data(serial->port[i]); |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 452 | kfree(priv); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | } |
Alan Stern | f9c99bb | 2009-06-02 11:53:55 -0400 | [diff] [blame] | 454 | } /* mct_u232_release */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 455 | |
Alan Cox | a509a7e | 2009-09-19 13:13:26 -0700 | [diff] [blame] | 456 | static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 457 | { |
| 458 | struct usb_serial *serial = port->serial; |
| 459 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
| 460 | int retval = 0; |
| 461 | unsigned int control_state; |
| 462 | unsigned long flags; |
| 463 | unsigned char last_lcr; |
| 464 | unsigned char last_msr; |
| 465 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 466 | dbg("%s port %d", __func__, port->number); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 467 | |
| 468 | /* Compensate for a hardware bug: although the Sitecom U232-P25 |
| 469 | * device reports a maximum output packet size of 32 bytes, |
| 470 | * it seems to be able to accept only 16 bytes (and that's what |
| 471 | * SniffUSB says too...) |
| 472 | */ |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 473 | if (le16_to_cpu(serial->dev->descriptor.idProduct) |
| 474 | == MCT_U232_SITECOM_PID) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 475 | port->bulk_out_size = 16; |
| 476 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 477 | /* Do a defined restart: the normal serial device seems to |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 478 | * always turn on DTR and RTS here, so do the same. I'm not |
| 479 | * sure if this is really necessary. But it should not harm |
| 480 | * either. |
| 481 | */ |
| 482 | spin_lock_irqsave(&priv->lock, flags); |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 483 | if (tty && (tty->termios->c_cflag & CBAUD)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 484 | priv->control_state = TIOCM_DTR | TIOCM_RTS; |
| 485 | else |
| 486 | priv->control_state = 0; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 487 | |
| 488 | priv->last_lcr = (MCT_U232_DATA_BITS_8 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 489 | MCT_U232_PARITY_NONE | |
| 490 | MCT_U232_STOP_BITS_1); |
| 491 | control_state = priv->control_state; |
| 492 | last_lcr = priv->last_lcr; |
| 493 | spin_unlock_irqrestore(&priv->lock, flags); |
| 494 | mct_u232_set_modem_ctrl(serial, control_state); |
| 495 | mct_u232_set_line_ctrl(serial, last_lcr); |
| 496 | |
| 497 | /* Read modem status and update control state */ |
| 498 | mct_u232_get_modem_stat(serial, &last_msr); |
| 499 | spin_lock_irqsave(&priv->lock, flags); |
| 500 | priv->last_msr = last_msr; |
| 501 | mct_u232_msr_to_state(&priv->control_state, priv->last_msr); |
| 502 | spin_unlock_irqrestore(&priv->lock, flags); |
| 503 | |
| 504 | port->read_urb->dev = port->serial->dev; |
| 505 | retval = usb_submit_urb(port->read_urb, GFP_KERNEL); |
| 506 | if (retval) { |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 507 | dev_err(&port->dev, |
| 508 | "usb_submit_urb(read bulk) failed pipe 0x%x err %d\n", |
| 509 | port->read_urb->pipe, retval); |
Oliver Neukum | 2f007de | 2007-03-29 10:45:17 +0200 | [diff] [blame] | 510 | goto error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 511 | } |
| 512 | |
| 513 | port->interrupt_in_urb->dev = port->serial->dev; |
| 514 | retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); |
Oliver Neukum | 2f007de | 2007-03-29 10:45:17 +0200 | [diff] [blame] | 515 | if (retval) { |
| 516 | usb_kill_urb(port->read_urb); |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 517 | dev_err(&port->dev, |
| 518 | "usb_submit_urb(read int) failed pipe 0x%x err %d", |
| 519 | port->interrupt_in_urb->pipe, retval); |
Oliver Neukum | 2f007de | 2007-03-29 10:45:17 +0200 | [diff] [blame] | 520 | goto error; |
| 521 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 522 | return 0; |
Oliver Neukum | 2f007de | 2007-03-29 10:45:17 +0200 | [diff] [blame] | 523 | |
| 524 | error: |
| 525 | return retval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | } /* mct_u232_open */ |
| 527 | |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 528 | static void mct_u232_dtr_rts(struct usb_serial_port *port, int on) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 529 | { |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 530 | unsigned int control_state; |
| 531 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 532 | |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 533 | mutex_lock(&port->serial->disc_mutex); |
| 534 | if (!port->serial->disconnected) { |
| 535 | /* drop DTR and RTS */ |
| 536 | spin_lock_irq(&priv->lock); |
| 537 | if (on) |
| 538 | priv->control_state |= TIOCM_DTR | TIOCM_RTS; |
| 539 | else |
Oliver Neukum | e33fe4d | 2008-01-21 17:44:10 +0100 | [diff] [blame] | 540 | priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS); |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 541 | control_state = priv->control_state; |
| 542 | spin_unlock_irq(&priv->lock); |
| 543 | mct_u232_set_modem_ctrl(port->serial, control_state); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 544 | } |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 545 | mutex_unlock(&port->serial->disc_mutex); |
| 546 | } |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 547 | |
Alan Cox | 335f851 | 2009-06-11 12:26:29 +0100 | [diff] [blame] | 548 | static void mct_u232_close(struct usb_serial_port *port) |
| 549 | { |
| 550 | dbg("%s port %d", __func__, port->number); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 551 | |
Johan Hovold | f26788d | 2010-03-17 23:00:45 +0100 | [diff] [blame] | 552 | usb_serial_generic_close(port); |
| 553 | if (port->serial->dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 554 | usb_kill_urb(port->interrupt_in_urb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 555 | } /* mct_u232_close */ |
| 556 | |
| 557 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 558 | static void mct_u232_read_int_callback(struct urb *urb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 559 | { |
Ming Lei | cdc9779 | 2008-02-24 18:41:47 +0800 | [diff] [blame] | 560 | struct usb_serial_port *port = urb->context; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 561 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
| 562 | struct usb_serial *serial = port->serial; |
| 563 | struct tty_struct *tty; |
| 564 | unsigned char *data = urb->transfer_buffer; |
Greg Kroah-Hartman | e96da39 | 2007-06-15 15:44:13 -0700 | [diff] [blame] | 565 | int retval; |
| 566 | int status = urb->status; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 567 | unsigned long flags; |
| 568 | |
Greg Kroah-Hartman | e96da39 | 2007-06-15 15:44:13 -0700 | [diff] [blame] | 569 | switch (status) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 570 | case 0: |
| 571 | /* success */ |
| 572 | break; |
| 573 | case -ECONNRESET: |
| 574 | case -ENOENT: |
| 575 | case -ESHUTDOWN: |
| 576 | /* this urb is terminated, clean up */ |
Greg Kroah-Hartman | e96da39 | 2007-06-15 15:44:13 -0700 | [diff] [blame] | 577 | dbg("%s - urb shutting down with status: %d", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 578 | __func__, status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 579 | return; |
| 580 | default: |
Greg Kroah-Hartman | e96da39 | 2007-06-15 15:44:13 -0700 | [diff] [blame] | 581 | dbg("%s - nonzero urb status received: %d", |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 582 | __func__, status); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 583 | goto exit; |
| 584 | } |
| 585 | |
| 586 | if (!serial) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 587 | dbg("%s - bad serial pointer, exiting", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 588 | return; |
| 589 | } |
| 590 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 591 | dbg("%s - port %d", __func__, port->number); |
| 592 | usb_serial_debug_data(debug, &port->dev, __func__, |
| 593 | urb->actual_length, data); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 594 | |
| 595 | /* |
| 596 | * Work-a-round: handle the 'usual' bulk-in pipe here |
| 597 | */ |
| 598 | if (urb->transfer_buffer_length > 2) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | if (urb->actual_length) { |
Jiri Slaby | 054f234 | 2009-09-06 23:10:10 +0200 | [diff] [blame] | 600 | tty = tty_port_tty_get(&port->port); |
| 601 | if (tty) { |
| 602 | tty_insert_flip_string(tty, data, |
| 603 | urb->actual_length); |
| 604 | tty_flip_buffer_push(tty); |
| 605 | } |
Alan Cox | 4a90f09 | 2008-10-13 10:39:46 +0100 | [diff] [blame] | 606 | tty_kref_put(tty); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 607 | } |
| 608 | goto exit; |
| 609 | } |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 610 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 611 | /* |
| 612 | * The interrupt-in pipe signals exceptional conditions (modem line |
| 613 | * signal changes and errors). data[0] holds MSR, data[1] holds LSR. |
| 614 | */ |
| 615 | spin_lock_irqsave(&priv->lock, flags); |
| 616 | priv->last_msr = data[MCT_U232_MSR_INDEX]; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 617 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 618 | /* Record Control Line states */ |
| 619 | mct_u232_msr_to_state(&priv->control_state, priv->last_msr); |
| 620 | |
| 621 | #if 0 |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 622 | /* Not yet handled. See belkin_sa.c for further information */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 623 | /* Now to report any errors */ |
| 624 | priv->last_lsr = data[MCT_U232_LSR_INDEX]; |
| 625 | /* |
| 626 | * fill in the flip buffer here, but I do not know the relation |
| 627 | * to the current/next receive buffer or characters. I need |
| 628 | * to look in to this before committing any code. |
| 629 | */ |
| 630 | if (priv->last_lsr & MCT_U232_LSR_ERR) { |
Alan Cox | 4a90f09 | 2008-10-13 10:39:46 +0100 | [diff] [blame] | 631 | tty = tty_port_tty_get(&port->port); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 632 | /* Overrun Error */ |
| 633 | if (priv->last_lsr & MCT_U232_LSR_OE) { |
| 634 | } |
| 635 | /* Parity Error */ |
| 636 | if (priv->last_lsr & MCT_U232_LSR_PE) { |
| 637 | } |
| 638 | /* Framing Error */ |
| 639 | if (priv->last_lsr & MCT_U232_LSR_FE) { |
| 640 | } |
| 641 | /* Break Indicator */ |
| 642 | if (priv->last_lsr & MCT_U232_LSR_BI) { |
| 643 | } |
Alan Cox | 4a90f09 | 2008-10-13 10:39:46 +0100 | [diff] [blame] | 644 | tty_kref_put(tty); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 645 | } |
| 646 | #endif |
| 647 | spin_unlock_irqrestore(&priv->lock, flags); |
| 648 | exit: |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 649 | retval = usb_submit_urb(urb, GFP_ATOMIC); |
Greg Kroah-Hartman | e96da39 | 2007-06-15 15:44:13 -0700 | [diff] [blame] | 650 | if (retval) |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 651 | dev_err(&port->dev, |
| 652 | "%s - usb_submit_urb failed with result %d\n", |
| 653 | __func__, retval); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 654 | } /* mct_u232_read_int_callback */ |
| 655 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 656 | static void mct_u232_set_termios(struct tty_struct *tty, |
| 657 | struct usb_serial_port *port, |
| 658 | struct ktermios *old_termios) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 659 | { |
| 660 | struct usb_serial *serial = port->serial; |
| 661 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 662 | struct ktermios *termios = tty->termios; |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 663 | unsigned int cflag = termios->c_cflag; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 664 | unsigned int old_cflag = old_termios->c_cflag; |
| 665 | unsigned long flags; |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 666 | unsigned int control_state; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 667 | unsigned char last_lcr; |
| 668 | |
| 669 | /* get a local copy of the current port settings */ |
| 670 | spin_lock_irqsave(&priv->lock, flags); |
| 671 | control_state = priv->control_state; |
| 672 | spin_unlock_irqrestore(&priv->lock, flags); |
| 673 | last_lcr = 0; |
| 674 | |
| 675 | /* |
| 676 | * Update baud rate. |
| 677 | * Do not attempt to cache old rates and skip settings, |
| 678 | * disconnects screw such tricks up completely. |
| 679 | * Premature optimization is the root of all evil. |
| 680 | */ |
| 681 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 682 | /* reassert DTR and RTS on transition from B0 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 683 | if ((old_cflag & CBAUD) == B0) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 684 | dbg("%s: baud was B0", __func__); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 685 | control_state |= TIOCM_DTR | TIOCM_RTS; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 686 | mct_u232_set_modem_ctrl(serial, control_state); |
| 687 | } |
| 688 | |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 689 | mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 690 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 691 | if ((cflag & CBAUD) == B0) { |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 692 | dbg("%s: baud is B0", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 693 | /* Drop RTS and DTR */ |
| 694 | control_state &= ~(TIOCM_DTR | TIOCM_RTS); |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 695 | mct_u232_set_modem_ctrl(serial, control_state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 696 | } |
| 697 | |
| 698 | /* |
| 699 | * Update line control register (LCR) |
| 700 | */ |
| 701 | |
| 702 | /* set the parity */ |
| 703 | if (cflag & PARENB) |
| 704 | last_lcr |= (cflag & PARODD) ? |
| 705 | MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN; |
| 706 | else |
| 707 | last_lcr |= MCT_U232_PARITY_NONE; |
| 708 | |
| 709 | /* set the number of data bits */ |
| 710 | switch (cflag & CSIZE) { |
| 711 | case CS5: |
| 712 | last_lcr |= MCT_U232_DATA_BITS_5; break; |
| 713 | case CS6: |
| 714 | last_lcr |= MCT_U232_DATA_BITS_6; break; |
| 715 | case CS7: |
| 716 | last_lcr |= MCT_U232_DATA_BITS_7; break; |
| 717 | case CS8: |
| 718 | last_lcr |= MCT_U232_DATA_BITS_8; break; |
| 719 | default: |
Greg Kroah-Hartman | 194343d | 2008-08-20 16:56:34 -0700 | [diff] [blame] | 720 | dev_err(&port->dev, |
| 721 | "CSIZE was not CS5-CS8, using default of 8\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 722 | last_lcr |= MCT_U232_DATA_BITS_8; |
| 723 | break; |
| 724 | } |
| 725 | |
Alan Cox | d0fab0d | 2007-12-13 16:15:29 -0800 | [diff] [blame] | 726 | termios->c_cflag &= ~CMSPAR; |
| 727 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 728 | /* set the number of stop bits */ |
| 729 | last_lcr |= (cflag & CSTOPB) ? |
| 730 | MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1; |
| 731 | |
| 732 | mct_u232_set_line_ctrl(serial, last_lcr); |
| 733 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 734 | /* save off the modified port settings */ |
| 735 | spin_lock_irqsave(&priv->lock, flags); |
| 736 | priv->control_state = control_state; |
| 737 | priv->last_lcr = last_lcr; |
| 738 | spin_unlock_irqrestore(&priv->lock, flags); |
| 739 | } /* mct_u232_set_termios */ |
| 740 | |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 741 | static void mct_u232_break_ctl(struct tty_struct *tty, int break_state) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 742 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 743 | struct usb_serial_port *port = tty->driver_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 744 | struct usb_serial *serial = port->serial; |
| 745 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
| 746 | unsigned char lcr; |
| 747 | unsigned long flags; |
| 748 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 749 | dbg("%sstate=%d", __func__, break_state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 750 | |
| 751 | spin_lock_irqsave(&priv->lock, flags); |
| 752 | lcr = priv->last_lcr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 753 | |
| 754 | if (break_state) |
| 755 | lcr |= MCT_U232_SET_BREAK; |
Alan Cox | 6b447f04 | 2009-01-02 13:48:56 +0000 | [diff] [blame] | 756 | spin_unlock_irqrestore(&priv->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 757 | |
| 758 | mct_u232_set_line_ctrl(serial, lcr); |
| 759 | } /* mct_u232_break_ctl */ |
| 760 | |
| 761 | |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 762 | static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 763 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 764 | struct usb_serial_port *port = tty->driver_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 765 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
| 766 | unsigned int control_state; |
| 767 | unsigned long flags; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 768 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 769 | dbg("%s", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 770 | |
| 771 | spin_lock_irqsave(&priv->lock, flags); |
| 772 | control_state = priv->control_state; |
| 773 | spin_unlock_irqrestore(&priv->lock, flags); |
| 774 | |
| 775 | return control_state; |
| 776 | } |
| 777 | |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 778 | static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 779 | unsigned int set, unsigned int clear) |
| 780 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 781 | struct usb_serial_port *port = tty->driver_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 782 | struct usb_serial *serial = port->serial; |
| 783 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
| 784 | unsigned int control_state; |
| 785 | unsigned long flags; |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 786 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 787 | dbg("%s", __func__); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 788 | |
| 789 | spin_lock_irqsave(&priv->lock, flags); |
| 790 | control_state = priv->control_state; |
| 791 | |
| 792 | if (set & TIOCM_RTS) |
| 793 | control_state |= TIOCM_RTS; |
| 794 | if (set & TIOCM_DTR) |
| 795 | control_state |= TIOCM_DTR; |
| 796 | if (clear & TIOCM_RTS) |
| 797 | control_state &= ~TIOCM_RTS; |
| 798 | if (clear & TIOCM_DTR) |
| 799 | control_state &= ~TIOCM_DTR; |
| 800 | |
| 801 | priv->control_state = control_state; |
| 802 | spin_unlock_irqrestore(&priv->lock, flags); |
| 803 | return mct_u232_set_modem_ctrl(serial, control_state); |
| 804 | } |
| 805 | |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 806 | static void mct_u232_throttle(struct tty_struct *tty) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 807 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 808 | struct usb_serial_port *port = tty->driver_data; |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 809 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 810 | unsigned int control_state; |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 811 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 812 | dbg("%s - port %d", __func__, port->number); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 813 | |
Oliver Neukum | 6383251 | 2009-10-07 10:50:23 +0200 | [diff] [blame] | 814 | spin_lock_irq(&priv->lock); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 815 | priv->rx_flags |= THROTTLED; |
| 816 | if (C_CRTSCTS(tty)) { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 817 | priv->control_state &= ~TIOCM_RTS; |
| 818 | control_state = priv->control_state; |
Oliver Neukum | 6383251 | 2009-10-07 10:50:23 +0200 | [diff] [blame] | 819 | spin_unlock_irq(&priv->lock); |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 820 | (void) mct_u232_set_modem_ctrl(port->serial, control_state); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 821 | } else { |
Oliver Neukum | 6383251 | 2009-10-07 10:50:23 +0200 | [diff] [blame] | 822 | spin_unlock_irq(&priv->lock); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 823 | } |
| 824 | } |
| 825 | |
| 826 | |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 827 | static void mct_u232_unthrottle(struct tty_struct *tty) |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 828 | { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 829 | struct usb_serial_port *port = tty->driver_data; |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 830 | struct mct_u232_private *priv = usb_get_serial_port_data(port); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 831 | unsigned int control_state; |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 832 | |
Harvey Harrison | 441b62c | 2008-03-03 16:08:34 -0800 | [diff] [blame] | 833 | dbg("%s - port %d", __func__, port->number); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 834 | |
Oliver Neukum | 6383251 | 2009-10-07 10:50:23 +0200 | [diff] [blame] | 835 | spin_lock_irq(&priv->lock); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 836 | if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) { |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 837 | priv->rx_flags &= ~THROTTLED; |
| 838 | priv->control_state |= TIOCM_RTS; |
| 839 | control_state = priv->control_state; |
Oliver Neukum | 6383251 | 2009-10-07 10:50:23 +0200 | [diff] [blame] | 840 | spin_unlock_irq(&priv->lock); |
Alan Cox | 95da310 | 2008-07-22 11:09:07 +0100 | [diff] [blame] | 841 | (void) mct_u232_set_modem_ctrl(port->serial, control_state); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 842 | } else { |
Oliver Neukum | 6383251 | 2009-10-07 10:50:23 +0200 | [diff] [blame] | 843 | spin_unlock_irq(&priv->lock); |
Dave Platt | 45b844d | 2007-05-08 11:00:12 -0700 | [diff] [blame] | 844 | } |
| 845 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 846 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 847 | static int __init mct_u232_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 848 | { |
| 849 | int retval; |
| 850 | retval = usb_serial_register(&mct_u232_device); |
| 851 | if (retval) |
| 852 | goto failed_usb_serial_register; |
| 853 | retval = usb_register(&mct_u232_driver); |
| 854 | if (retval) |
| 855 | goto failed_usb_register; |
Greg Kroah-Hartman | c197a8d | 2008-08-18 13:21:04 -0700 | [diff] [blame] | 856 | printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" |
| 857 | DRIVER_DESC "\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 858 | return 0; |
| 859 | failed_usb_register: |
| 860 | usb_serial_deregister(&mct_u232_device); |
| 861 | failed_usb_serial_register: |
| 862 | return retval; |
| 863 | } |
| 864 | |
| 865 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 866 | static void __exit mct_u232_exit(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 867 | { |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 868 | usb_deregister(&mct_u232_driver); |
| 869 | usb_serial_deregister(&mct_u232_device); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 870 | } |
| 871 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 872 | module_init(mct_u232_init); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 873 | module_exit(mct_u232_exit); |
| 874 | |
Alan Cox | e19b256 | 2008-07-22 11:14:30 +0100 | [diff] [blame] | 875 | MODULE_AUTHOR(DRIVER_AUTHOR); |
| 876 | MODULE_DESCRIPTION(DRIVER_DESC); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 877 | MODULE_LICENSE("GPL"); |
| 878 | |
| 879 | module_param(debug, bool, S_IRUGO | S_IWUSR); |
| 880 | MODULE_PARM_DESC(debug, "Debug enabled or not"); |