Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 1c1eaba8e72768156db4faff3a2c3a6ca7dea129

Authored by Greg Kroah-Hartman
1 parent 450279822f
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

USB: serial: ch341: make the reset_resume callback actually work. 

I hooked up the wrong callback in my previous patch, this should fix it.

Reported-by: Alan Stern <stern@rowland.harvard.edu>
Cc: Johan Hovold <jhovold@gmail.com>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Mauro Carvalho Chehab <mchehab@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

drivers/usb/serial/ch341.c
Diff comments   View file @ 1c1eaba
1 /* 1 /*
2 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk> 2 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk>
3 * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de> 3 * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de>
4 * Copyright 2009, Boris Hajduk <boris@hajduk.org> 4 * Copyright 2009, Boris Hajduk <boris@hajduk.org>
5 * 5 *
6 * ch341.c implements a serial port driver for the Winchiphead CH341. 6 * ch341.c implements a serial port driver for the Winchiphead CH341.
7 * 7 *
8 * The CH341 device can be used to implement an RS232 asynchronous 8 * The CH341 device can be used to implement an RS232 asynchronous
9 * serial port, an IEEE-1284 parallel printer port or a memory-like 9 * serial port, an IEEE-1284 parallel printer port or a memory-like
10 * interface. In all cases the CH341 supports an I2C interface as well. 10 * interface. In all cases the CH341 supports an I2C interface as well.
11 * This driver only supports the asynchronous serial interface. 11 * This driver only supports the asynchronous serial interface.
12 * 12 *
13 * This program is free software; you can redistribute it and/or 13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License version 14 * modify it under the terms of the GNU General Public License version
15 * 2 as published by the Free Software Foundation. 15 * 2 as published by the Free Software Foundation.
16 */ 16 */
17 17
18 #include <linux/kernel.h> 18 #include <linux/kernel.h>
19 #include <linux/init.h> 19 #include <linux/init.h>
20 #include <linux/tty.h> 20 #include <linux/tty.h>
21 #include <linux/module.h> 21 #include <linux/module.h>
22 #include <linux/slab.h> 22 #include <linux/slab.h>
23 #include <linux/usb.h> 23 #include <linux/usb.h>
24 #include <linux/usb/serial.h> 24 #include <linux/usb/serial.h>
25 #include <linux/serial.h> 25 #include <linux/serial.h>
26 #include <asm/unaligned.h> 26 #include <asm/unaligned.h>
27 27
28 #define DEFAULT_BAUD_RATE 9600 28 #define DEFAULT_BAUD_RATE 9600
29 #define DEFAULT_TIMEOUT 1000 29 #define DEFAULT_TIMEOUT 1000
30 30
31 /* flags for IO-Bits */ 31 /* flags for IO-Bits */
32 #define CH341_BIT_RTS (1 << 6) 32 #define CH341_BIT_RTS (1 << 6)
33 #define CH341_BIT_DTR (1 << 5) 33 #define CH341_BIT_DTR (1 << 5)
34 34
35 /******************************/ 35 /******************************/
36 /* interrupt pipe definitions */ 36 /* interrupt pipe definitions */
37 /******************************/ 37 /******************************/
38 /* always 4 interrupt bytes */ 38 /* always 4 interrupt bytes */
39 /* first irq byte normally 0x08 */ 39 /* first irq byte normally 0x08 */
40 /* second irq byte base 0x7d + below */ 40 /* second irq byte base 0x7d + below */
41 /* third irq byte base 0x94 + below */ 41 /* third irq byte base 0x94 + below */
42 /* fourth irq byte normally 0xee */ 42 /* fourth irq byte normally 0xee */
43 43
44 /* second interrupt byte */ 44 /* second interrupt byte */
45 #define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */ 45 #define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */
46 46
47 /* status returned in third interrupt answer byte, inverted in data 47 /* status returned in third interrupt answer byte, inverted in data
48 from irq */ 48 from irq */
49 #define CH341_BIT_CTS 0x01 49 #define CH341_BIT_CTS 0x01
50 #define CH341_BIT_DSR 0x02 50 #define CH341_BIT_DSR 0x02
51 #define CH341_BIT_RI 0x04 51 #define CH341_BIT_RI 0x04
52 #define CH341_BIT_DCD 0x08 52 #define CH341_BIT_DCD 0x08
53 #define CH341_BITS_MODEM_STAT 0x0f /* all bits */ 53 #define CH341_BITS_MODEM_STAT 0x0f /* all bits */
54 54
55 /*******************************/ 55 /*******************************/
56 /* baudrate calculation factor */ 56 /* baudrate calculation factor */
57 /*******************************/ 57 /*******************************/
58 #define CH341_BAUDBASE_FACTOR 1532620800 58 #define CH341_BAUDBASE_FACTOR 1532620800
59 #define CH341_BAUDBASE_DIVMAX 3 59 #define CH341_BAUDBASE_DIVMAX 3
60 60
61 /* Break support - the information used to implement this was gleaned from 61 /* Break support - the information used to implement this was gleaned from
62 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato. 62 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato.
63 */ 63 */
64 64
65 #define CH341_REQ_WRITE_REG 0x9A 65 #define CH341_REQ_WRITE_REG 0x9A
66 #define CH341_REQ_READ_REG 0x95 66 #define CH341_REQ_READ_REG 0x95
67 #define CH341_REG_BREAK1 0x05 67 #define CH341_REG_BREAK1 0x05
68 #define CH341_REG_BREAK2 0x18 68 #define CH341_REG_BREAK2 0x18
69 #define CH341_NBREAK_BITS_REG1 0x01 69 #define CH341_NBREAK_BITS_REG1 0x01
70 #define CH341_NBREAK_BITS_REG2 0x40 70 #define CH341_NBREAK_BITS_REG2 0x40
71 71
72 72
73 static bool debug; 73 static bool debug;
74 74
75 static const struct usb_device_id id_table[] = { 75 static const struct usb_device_id id_table[] = {
76 { USB_DEVICE(0x4348, 0x5523) }, 76 { USB_DEVICE(0x4348, 0x5523) },
77 { USB_DEVICE(0x1a86, 0x7523) }, 77 { USB_DEVICE(0x1a86, 0x7523) },
78 { USB_DEVICE(0x1a86, 0x5523) }, 78 { USB_DEVICE(0x1a86, 0x5523) },
79 { }, 79 { },
80 }; 80 };
81 MODULE_DEVICE_TABLE(usb, id_table); 81 MODULE_DEVICE_TABLE(usb, id_table);
82 82
83 struct ch341_private { 83 struct ch341_private {
84 spinlock_t lock; /* access lock */ 84 spinlock_t lock; /* access lock */
85 wait_queue_head_t delta_msr_wait; /* wait queue for modem status */ 85 wait_queue_head_t delta_msr_wait; /* wait queue for modem status */
86 unsigned baud_rate; /* set baud rate */ 86 unsigned baud_rate; /* set baud rate */
87 u8 line_control; /* set line control value RTS/DTR */ 87 u8 line_control; /* set line control value RTS/DTR */
88 u8 line_status; /* active status of modem control inputs */ 88 u8 line_status; /* active status of modem control inputs */
89 u8 multi_status_change; /* status changed multiple since last call */ 89 u8 multi_status_change; /* status changed multiple since last call */
90 }; 90 };
91 91
92 static int ch341_control_out(struct usb_device *dev, u8 request, 92 static int ch341_control_out(struct usb_device *dev, u8 request,
93 u16 value, u16 index) 93 u16 value, u16 index)
94 { 94 {
95 int r; 95 int r;
96 dbg("ch341_control_out(%02x,%02x,%04x,%04x)", USB_DIR_OUT|0x40, 96 dbg("ch341_control_out(%02x,%02x,%04x,%04x)", USB_DIR_OUT|0x40,
97 (int)request, (int)value, (int)index); 97 (int)request, (int)value, (int)index);
98 98
99 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request, 99 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
100 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 100 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
101 value, index, NULL, 0, DEFAULT_TIMEOUT); 101 value, index, NULL, 0, DEFAULT_TIMEOUT);
102 102
103 return r; 103 return r;
104 } 104 }
105 105
106 static int ch341_control_in(struct usb_device *dev, 106 static int ch341_control_in(struct usb_device *dev,
107 u8 request, u16 value, u16 index, 107 u8 request, u16 value, u16 index,
108 char *buf, unsigned bufsize) 108 char *buf, unsigned bufsize)
109 { 109 {
110 int r; 110 int r;
111 dbg("ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)", USB_DIR_IN|0x40, 111 dbg("ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)", USB_DIR_IN|0x40,
112 (int)request, (int)value, (int)index, buf, (int)bufsize); 112 (int)request, (int)value, (int)index, buf, (int)bufsize);
113 113
114 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request, 114 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
115 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 115 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
116 value, index, buf, bufsize, DEFAULT_TIMEOUT); 116 value, index, buf, bufsize, DEFAULT_TIMEOUT);
117 return r; 117 return r;
118 } 118 }
119 119
120 static int ch341_set_baudrate(struct usb_device *dev, 120 static int ch341_set_baudrate(struct usb_device *dev,
121 struct ch341_private *priv) 121 struct ch341_private *priv)
122 { 122 {
123 short a, b; 123 short a, b;
124 int r; 124 int r;
125 unsigned long factor; 125 unsigned long factor;
126 short divisor; 126 short divisor;
127 127
128 if (!priv->baud_rate) 128 if (!priv->baud_rate)
129 return -EINVAL; 129 return -EINVAL;
130 factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate); 130 factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate);
131 divisor = CH341_BAUDBASE_DIVMAX; 131 divisor = CH341_BAUDBASE_DIVMAX;
132 132
133 while ((factor > 0xfff0) && divisor) { 133 while ((factor > 0xfff0) && divisor) {
134 factor >>= 3; 134 factor >>= 3;
135 divisor--; 135 divisor--;
136 } 136 }
137 137
138 if (factor > 0xfff0) 138 if (factor > 0xfff0)
139 return -EINVAL; 139 return -EINVAL;
140 140
141 factor = 0x10000 - factor; 141 factor = 0x10000 - factor;
142 a = (factor & 0xff00) | divisor; 142 a = (factor & 0xff00) | divisor;
143 b = factor & 0xff; 143 b = factor & 0xff;
144 144
145 r = ch341_control_out(dev, 0x9a, 0x1312, a); 145 r = ch341_control_out(dev, 0x9a, 0x1312, a);
146 if (!r) 146 if (!r)
147 r = ch341_control_out(dev, 0x9a, 0x0f2c, b); 147 r = ch341_control_out(dev, 0x9a, 0x0f2c, b);
148 148
149 return r; 149 return r;
150 } 150 }
151 151
152 static int ch341_set_handshake(struct usb_device *dev, u8 control) 152 static int ch341_set_handshake(struct usb_device *dev, u8 control)
153 { 153 {
154 return ch341_control_out(dev, 0xa4, ~control, 0); 154 return ch341_control_out(dev, 0xa4, ~control, 0);
155 } 155 }
156 156
157 static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv) 157 static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv)
158 { 158 {
159 char *buffer; 159 char *buffer;
160 int r; 160 int r;
161 const unsigned size = 8; 161 const unsigned size = 8;
162 unsigned long flags; 162 unsigned long flags;
163 163
164 buffer = kmalloc(size, GFP_KERNEL); 164 buffer = kmalloc(size, GFP_KERNEL);
165 if (!buffer) 165 if (!buffer)
166 return -ENOMEM; 166 return -ENOMEM;
167 167
168 r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size); 168 r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size);
169 if (r < 0) 169 if (r < 0)
170 goto out; 170 goto out;
171 171
172 /* setup the private status if available */ 172 /* setup the private status if available */
173 if (r == 2) { 173 if (r == 2) {
174 r = 0; 174 r = 0;
175 spin_lock_irqsave(&priv->lock, flags); 175 spin_lock_irqsave(&priv->lock, flags);
176 priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT; 176 priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT;
177 priv->multi_status_change = 0; 177 priv->multi_status_change = 0;
178 spin_unlock_irqrestore(&priv->lock, flags); 178 spin_unlock_irqrestore(&priv->lock, flags);
179 } else 179 } else
180 r = -EPROTO; 180 r = -EPROTO;
181 181
182 out: kfree(buffer); 182 out: kfree(buffer);
183 return r; 183 return r;
184 } 184 }
185 185
186 /* -------------------------------------------------------------------------- */ 186 /* -------------------------------------------------------------------------- */
187 187
188 static int ch341_configure(struct usb_device *dev, struct ch341_private *priv) 188 static int ch341_configure(struct usb_device *dev, struct ch341_private *priv)
189 { 189 {
190 char *buffer; 190 char *buffer;
191 int r; 191 int r;
192 const unsigned size = 8; 192 const unsigned size = 8;
193 193
194 buffer = kmalloc(size, GFP_KERNEL); 194 buffer = kmalloc(size, GFP_KERNEL);
195 if (!buffer) 195 if (!buffer)
196 return -ENOMEM; 196 return -ENOMEM;
197 197
198 /* expect two bytes 0x27 0x00 */ 198 /* expect two bytes 0x27 0x00 */
199 r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size); 199 r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size);
200 if (r < 0) 200 if (r < 0)
201 goto out; 201 goto out;
202 202
203 r = ch341_control_out(dev, 0xa1, 0, 0); 203 r = ch341_control_out(dev, 0xa1, 0, 0);
204 if (r < 0) 204 if (r < 0)
205 goto out; 205 goto out;
206 206
207 r = ch341_set_baudrate(dev, priv); 207 r = ch341_set_baudrate(dev, priv);
208 if (r < 0) 208 if (r < 0)
209 goto out; 209 goto out;
210 210
211 /* expect two bytes 0x56 0x00 */ 211 /* expect two bytes 0x56 0x00 */
212 r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size); 212 r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size);
213 if (r < 0) 213 if (r < 0)
214 goto out; 214 goto out;
215 215
216 r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050); 216 r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050);
217 if (r < 0) 217 if (r < 0)
218 goto out; 218 goto out;
219 219
220 /* expect 0xff 0xee */ 220 /* expect 0xff 0xee */
221 r = ch341_get_status(dev, priv); 221 r = ch341_get_status(dev, priv);
222 if (r < 0) 222 if (r < 0)
223 goto out; 223 goto out;
224 224
225 r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a); 225 r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a);
226 if (r < 0) 226 if (r < 0)
227 goto out; 227 goto out;
228 228
229 r = ch341_set_baudrate(dev, priv); 229 r = ch341_set_baudrate(dev, priv);
230 if (r < 0) 230 if (r < 0)
231 goto out; 231 goto out;
232 232
233 r = ch341_set_handshake(dev, priv->line_control); 233 r = ch341_set_handshake(dev, priv->line_control);
234 if (r < 0) 234 if (r < 0)
235 goto out; 235 goto out;
236 236
237 /* expect 0x9f 0xee */ 237 /* expect 0x9f 0xee */
238 r = ch341_get_status(dev, priv); 238 r = ch341_get_status(dev, priv);
239 239
240 out: kfree(buffer); 240 out: kfree(buffer);
241 return r; 241 return r;
242 } 242 }
243 243
244 /* allocate private data */ 244 /* allocate private data */
245 static int ch341_attach(struct usb_serial *serial) 245 static int ch341_attach(struct usb_serial *serial)
246 { 246 {
247 struct ch341_private *priv; 247 struct ch341_private *priv;
248 int r; 248 int r;
249 249
250 /* private data */ 250 /* private data */
251 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL); 251 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL);
252 if (!priv) 252 if (!priv)
253 return -ENOMEM; 253 return -ENOMEM;
254 254
255 spin_lock_init(&priv->lock); 255 spin_lock_init(&priv->lock);
256 init_waitqueue_head(&priv->delta_msr_wait); 256 init_waitqueue_head(&priv->delta_msr_wait);
257 priv->baud_rate = DEFAULT_BAUD_RATE; 257 priv->baud_rate = DEFAULT_BAUD_RATE;
258 priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR; 258 priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;
259 259
260 r = ch341_configure(serial->dev, priv); 260 r = ch341_configure(serial->dev, priv);
261 if (r < 0) 261 if (r < 0)
262 goto error; 262 goto error;
263 263
264 usb_set_serial_port_data(serial->port[0], priv); 264 usb_set_serial_port_data(serial->port[0], priv);
265 return 0; 265 return 0;
266 266
267 error: kfree(priv); 267 error: kfree(priv);
268 return r; 268 return r;
269 } 269 }
270 270
271 static int ch341_carrier_raised(struct usb_serial_port *port) 271 static int ch341_carrier_raised(struct usb_serial_port *port)
272 { 272 {
273 struct ch341_private *priv = usb_get_serial_port_data(port); 273 struct ch341_private *priv = usb_get_serial_port_data(port);
274 if (priv->line_status & CH341_BIT_DCD) 274 if (priv->line_status & CH341_BIT_DCD)
275 return 1; 275 return 1;
276 return 0; 276 return 0;
277 } 277 }
278 278
279 static void ch341_dtr_rts(struct usb_serial_port *port, int on) 279 static void ch341_dtr_rts(struct usb_serial_port *port, int on)
280 { 280 {
281 struct ch341_private *priv = usb_get_serial_port_data(port); 281 struct ch341_private *priv = usb_get_serial_port_data(port);
282 unsigned long flags; 282 unsigned long flags;
283 283
284 /* drop DTR and RTS */ 284 /* drop DTR and RTS */
285 spin_lock_irqsave(&priv->lock, flags); 285 spin_lock_irqsave(&priv->lock, flags);
286 if (on) 286 if (on)
287 priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR; 287 priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR;
288 else 288 else
289 priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR); 289 priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR);
290 spin_unlock_irqrestore(&priv->lock, flags); 290 spin_unlock_irqrestore(&priv->lock, flags);
291 ch341_set_handshake(port->serial->dev, priv->line_control); 291 ch341_set_handshake(port->serial->dev, priv->line_control);
292 wake_up_interruptible(&priv->delta_msr_wait); 292 wake_up_interruptible(&priv->delta_msr_wait);
293 } 293 }
294 294
295 static void ch341_close(struct usb_serial_port *port) 295 static void ch341_close(struct usb_serial_port *port)
296 { 296 {
297 usb_serial_generic_close(port); 297 usb_serial_generic_close(port);
298 usb_kill_urb(port->interrupt_in_urb); 298 usb_kill_urb(port->interrupt_in_urb);
299 } 299 }
300 300
301 301
302 /* open this device, set default parameters */ 302 /* open this device, set default parameters */
303 static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) 303 static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
304 { 304 {
305 struct usb_serial *serial = port->serial; 305 struct usb_serial *serial = port->serial;
306 struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]); 306 struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
307 int r; 307 int r;
308 308
309 priv->baud_rate = DEFAULT_BAUD_RATE; 309 priv->baud_rate = DEFAULT_BAUD_RATE;
310 310
311 r = ch341_configure(serial->dev, priv); 311 r = ch341_configure(serial->dev, priv);
312 if (r) 312 if (r)
313 goto out; 313 goto out;
314 314
315 r = ch341_set_handshake(serial->dev, priv->line_control); 315 r = ch341_set_handshake(serial->dev, priv->line_control);
316 if (r) 316 if (r)
317 goto out; 317 goto out;
318 318
319 r = ch341_set_baudrate(serial->dev, priv); 319 r = ch341_set_baudrate(serial->dev, priv);
320 if (r) 320 if (r)
321 goto out; 321 goto out;
322 322
323 dbg("%s - submitting interrupt urb", __func__); 323 dbg("%s - submitting interrupt urb", __func__);
324 r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 324 r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
325 if (r) { 325 if (r) {
326 dev_err(&port->dev, "%s - failed submitting interrupt urb," 326 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
327 " error %d\n", __func__, r); 327 " error %d\n", __func__, r);
328 ch341_close(port); 328 ch341_close(port);
329 goto out; 329 goto out;
330 } 330 }
331 331
332 r = usb_serial_generic_open(tty, port); 332 r = usb_serial_generic_open(tty, port);
333 333
334 out: return r; 334 out: return r;
335 } 335 }
336 336
337 /* Old_termios contains the original termios settings and 337 /* Old_termios contains the original termios settings and
338 * tty->termios contains the new setting to be used. 338 * tty->termios contains the new setting to be used.
339 */ 339 */
340 static void ch341_set_termios(struct tty_struct *tty, 340 static void ch341_set_termios(struct tty_struct *tty,
341 struct usb_serial_port *port, struct ktermios *old_termios) 341 struct usb_serial_port *port, struct ktermios *old_termios)
342 { 342 {
343 struct ch341_private *priv = usb_get_serial_port_data(port); 343 struct ch341_private *priv = usb_get_serial_port_data(port);
344 unsigned baud_rate; 344 unsigned baud_rate;
345 unsigned long flags; 345 unsigned long flags;
346 346
347 baud_rate = tty_get_baud_rate(tty); 347 baud_rate = tty_get_baud_rate(tty);
348 348
349 priv->baud_rate = baud_rate; 349 priv->baud_rate = baud_rate;
350 350
351 if (baud_rate) { 351 if (baud_rate) {
352 spin_lock_irqsave(&priv->lock, flags); 352 spin_lock_irqsave(&priv->lock, flags);
353 priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS); 353 priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS);
354 spin_unlock_irqrestore(&priv->lock, flags); 354 spin_unlock_irqrestore(&priv->lock, flags);
355 ch341_set_baudrate(port->serial->dev, priv); 355 ch341_set_baudrate(port->serial->dev, priv);
356 } else { 356 } else {
357 spin_lock_irqsave(&priv->lock, flags); 357 spin_lock_irqsave(&priv->lock, flags);
358 priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS); 358 priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS);
359 spin_unlock_irqrestore(&priv->lock, flags); 359 spin_unlock_irqrestore(&priv->lock, flags);
360 } 360 }
361 361
362 ch341_set_handshake(port->serial->dev, priv->line_control); 362 ch341_set_handshake(port->serial->dev, priv->line_control);
363 363
364 /* Unimplemented: 364 /* Unimplemented:
365 * (cflag & CSIZE) : data bits [5, 8] 365 * (cflag & CSIZE) : data bits [5, 8]
366 * (cflag & PARENB) : parity {NONE, EVEN, ODD} 366 * (cflag & PARENB) : parity {NONE, EVEN, ODD}
367 * (cflag & CSTOPB) : stop bits [1, 2] 367 * (cflag & CSTOPB) : stop bits [1, 2]
368 */ 368 */
369 } 369 }
370 370
371 static void ch341_break_ctl(struct tty_struct *tty, int break_state) 371 static void ch341_break_ctl(struct tty_struct *tty, int break_state)
372 { 372 {
373 const uint16_t ch341_break_reg = 373 const uint16_t ch341_break_reg =
374 CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8); 374 CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8);
375 struct usb_serial_port *port = tty->driver_data; 375 struct usb_serial_port *port = tty->driver_data;
376 int r; 376 int r;
377 uint16_t reg_contents; 377 uint16_t reg_contents;
378 uint8_t *break_reg; 378 uint8_t *break_reg;
379 379
380 break_reg = kmalloc(2, GFP_KERNEL); 380 break_reg = kmalloc(2, GFP_KERNEL);
381 if (!break_reg) { 381 if (!break_reg) {
382 dev_err(&port->dev, "%s - kmalloc failed\n", __func__); 382 dev_err(&port->dev, "%s - kmalloc failed\n", __func__);
383 return; 383 return;
384 } 384 }
385 385
386 r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG, 386 r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
387 ch341_break_reg, 0, break_reg, 2); 387 ch341_break_reg, 0, break_reg, 2);
388 if (r < 0) { 388 if (r < 0) {
389 dev_err(&port->dev, "%s - USB control read error (%d)\n", 389 dev_err(&port->dev, "%s - USB control read error (%d)\n",
390 __func__, r); 390 __func__, r);
391 goto out; 391 goto out;
392 } 392 }
393 dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x", 393 dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x",
394 __func__, break_reg[0], break_reg[1]); 394 __func__, break_reg[0], break_reg[1]);
395 if (break_state != 0) { 395 if (break_state != 0) {
396 dbg("%s - Enter break state requested", __func__); 396 dbg("%s - Enter break state requested", __func__);
397 break_reg[0] &= ~CH341_NBREAK_BITS_REG1; 397 break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
398 break_reg[1] &= ~CH341_NBREAK_BITS_REG2; 398 break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
399 } else { 399 } else {
400 dbg("%s - Leave break state requested", __func__); 400 dbg("%s - Leave break state requested", __func__);
401 break_reg[0] |= CH341_NBREAK_BITS_REG1; 401 break_reg[0] |= CH341_NBREAK_BITS_REG1;
402 break_reg[1] |= CH341_NBREAK_BITS_REG2; 402 break_reg[1] |= CH341_NBREAK_BITS_REG2;
403 } 403 }
404 dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x", 404 dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x",
405 __func__, break_reg[0], break_reg[1]); 405 __func__, break_reg[0], break_reg[1]);
406 reg_contents = get_unaligned_le16(break_reg); 406 reg_contents = get_unaligned_le16(break_reg);
407 r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG, 407 r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
408 ch341_break_reg, reg_contents); 408 ch341_break_reg, reg_contents);
409 if (r < 0) 409 if (r < 0)
410 dev_err(&port->dev, "%s - USB control write error (%d)\n", 410 dev_err(&port->dev, "%s - USB control write error (%d)\n",
411 __func__, r); 411 __func__, r);
412 out: 412 out:
413 kfree(break_reg); 413 kfree(break_reg);
414 } 414 }
415 415
416 static int ch341_tiocmset(struct tty_struct *tty, 416 static int ch341_tiocmset(struct tty_struct *tty,
417 unsigned int set, unsigned int clear) 417 unsigned int set, unsigned int clear)
418 { 418 {
419 struct usb_serial_port *port = tty->driver_data; 419 struct usb_serial_port *port = tty->driver_data;
420 struct ch341_private *priv = usb_get_serial_port_data(port); 420 struct ch341_private *priv = usb_get_serial_port_data(port);
421 unsigned long flags; 421 unsigned long flags;
422 u8 control; 422 u8 control;
423 423
424 spin_lock_irqsave(&priv->lock, flags); 424 spin_lock_irqsave(&priv->lock, flags);
425 if (set & TIOCM_RTS) 425 if (set & TIOCM_RTS)
426 priv->line_control |= CH341_BIT_RTS; 426 priv->line_control |= CH341_BIT_RTS;
427 if (set & TIOCM_DTR) 427 if (set & TIOCM_DTR)
428 priv->line_control |= CH341_BIT_DTR; 428 priv->line_control |= CH341_BIT_DTR;
429 if (clear & TIOCM_RTS) 429 if (clear & TIOCM_RTS)
430 priv->line_control &= ~CH341_BIT_RTS; 430 priv->line_control &= ~CH341_BIT_RTS;
431 if (clear & TIOCM_DTR) 431 if (clear & TIOCM_DTR)
432 priv->line_control &= ~CH341_BIT_DTR; 432 priv->line_control &= ~CH341_BIT_DTR;
433 control = priv->line_control; 433 control = priv->line_control;
434 spin_unlock_irqrestore(&priv->lock, flags); 434 spin_unlock_irqrestore(&priv->lock, flags);
435 435
436 return ch341_set_handshake(port->serial->dev, control); 436 return ch341_set_handshake(port->serial->dev, control);
437 } 437 }
438 438
439 static void ch341_read_int_callback(struct urb *urb) 439 static void ch341_read_int_callback(struct urb *urb)
440 { 440 {
441 struct usb_serial_port *port = (struct usb_serial_port *) urb->context; 441 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
442 unsigned char *data = urb->transfer_buffer; 442 unsigned char *data = urb->transfer_buffer;
443 unsigned int actual_length = urb->actual_length; 443 unsigned int actual_length = urb->actual_length;
444 int status; 444 int status;
445 445
446 switch (urb->status) { 446 switch (urb->status) {
447 case 0: 447 case 0:
448 /* success */ 448 /* success */
449 break; 449 break;
450 case -ECONNRESET: 450 case -ECONNRESET:
451 case -ENOENT: 451 case -ENOENT:
452 case -ESHUTDOWN: 452 case -ESHUTDOWN:
453 /* this urb is terminated, clean up */ 453 /* this urb is terminated, clean up */
454 dbg("%s - urb shutting down with status: %d", __func__, 454 dbg("%s - urb shutting down with status: %d", __func__,
455 urb->status); 455 urb->status);
456 return; 456 return;
457 default: 457 default:
458 dbg("%s - nonzero urb status received: %d", __func__, 458 dbg("%s - nonzero urb status received: %d", __func__,
459 urb->status); 459 urb->status);
460 goto exit; 460 goto exit;
461 } 461 }
462 462
463 usb_serial_debug_data(debug, &port->dev, __func__, 463 usb_serial_debug_data(debug, &port->dev, __func__,
464 urb->actual_length, urb->transfer_buffer); 464 urb->actual_length, urb->transfer_buffer);
465 465
466 if (actual_length >= 4) { 466 if (actual_length >= 4) {
467 struct ch341_private *priv = usb_get_serial_port_data(port); 467 struct ch341_private *priv = usb_get_serial_port_data(port);
468 unsigned long flags; 468 unsigned long flags;
469 u8 prev_line_status = priv->line_status; 469 u8 prev_line_status = priv->line_status;
470 470
471 spin_lock_irqsave(&priv->lock, flags); 471 spin_lock_irqsave(&priv->lock, flags);
472 priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT; 472 priv->line_status = (~(data[2])) & CH341_BITS_MODEM_STAT;
473 if ((data[1] & CH341_MULT_STAT)) 473 if ((data[1] & CH341_MULT_STAT))
474 priv->multi_status_change = 1; 474 priv->multi_status_change = 1;
475 spin_unlock_irqrestore(&priv->lock, flags); 475 spin_unlock_irqrestore(&priv->lock, flags);
476 476
477 if ((priv->line_status ^ prev_line_status) & CH341_BIT_DCD) { 477 if ((priv->line_status ^ prev_line_status) & CH341_BIT_DCD) {
478 struct tty_struct *tty = tty_port_tty_get(&port->port); 478 struct tty_struct *tty = tty_port_tty_get(&port->port);
479 if (tty) 479 if (tty)
480 usb_serial_handle_dcd_change(port, tty, 480 usb_serial_handle_dcd_change(port, tty,
481 priv->line_status & CH341_BIT_DCD); 481 priv->line_status & CH341_BIT_DCD);
482 tty_kref_put(tty); 482 tty_kref_put(tty);
483 } 483 }
484 484
485 wake_up_interruptible(&priv->delta_msr_wait); 485 wake_up_interruptible(&priv->delta_msr_wait);
486 } 486 }
487 487
488 exit: 488 exit:
489 status = usb_submit_urb(urb, GFP_ATOMIC); 489 status = usb_submit_urb(urb, GFP_ATOMIC);
490 if (status) 490 if (status)
491 dev_err(&urb->dev->dev, 491 dev_err(&urb->dev->dev,
492 "%s - usb_submit_urb failed with result %d\n", 492 "%s - usb_submit_urb failed with result %d\n",
493 __func__, status); 493 __func__, status);
494 } 494 }
495 495
496 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg) 496 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
497 { 497 {
498 struct ch341_private *priv = usb_get_serial_port_data(port); 498 struct ch341_private *priv = usb_get_serial_port_data(port);
499 unsigned long flags; 499 unsigned long flags;
500 u8 prevstatus; 500 u8 prevstatus;
501 u8 status; 501 u8 status;
502 u8 changed; 502 u8 changed;
503 u8 multi_change = 0; 503 u8 multi_change = 0;
504 504
505 spin_lock_irqsave(&priv->lock, flags); 505 spin_lock_irqsave(&priv->lock, flags);
506 prevstatus = priv->line_status; 506 prevstatus = priv->line_status;
507 priv->multi_status_change = 0; 507 priv->multi_status_change = 0;
508 spin_unlock_irqrestore(&priv->lock, flags); 508 spin_unlock_irqrestore(&priv->lock, flags);
509 509
510 while (!multi_change) { 510 while (!multi_change) {
511 interruptible_sleep_on(&priv->delta_msr_wait); 511 interruptible_sleep_on(&priv->delta_msr_wait);
512 /* see if a signal did it */ 512 /* see if a signal did it */
513 if (signal_pending(current)) 513 if (signal_pending(current))
514 return -ERESTARTSYS; 514 return -ERESTARTSYS;
515 515
516 spin_lock_irqsave(&priv->lock, flags); 516 spin_lock_irqsave(&priv->lock, flags);
517 status = priv->line_status; 517 status = priv->line_status;
518 multi_change = priv->multi_status_change; 518 multi_change = priv->multi_status_change;
519 spin_unlock_irqrestore(&priv->lock, flags); 519 spin_unlock_irqrestore(&priv->lock, flags);
520 520
521 changed = prevstatus ^ status; 521 changed = prevstatus ^ status;
522 522
523 if (((arg & TIOCM_RNG) && (changed & CH341_BIT_RI)) || 523 if (((arg & TIOCM_RNG) && (changed & CH341_BIT_RI)) ||
524 ((arg & TIOCM_DSR) && (changed & CH341_BIT_DSR)) || 524 ((arg & TIOCM_DSR) && (changed & CH341_BIT_DSR)) ||
525 ((arg & TIOCM_CD) && (changed & CH341_BIT_DCD)) || 525 ((arg & TIOCM_CD) && (changed & CH341_BIT_DCD)) ||
526 ((arg & TIOCM_CTS) && (changed & CH341_BIT_CTS))) { 526 ((arg & TIOCM_CTS) && (changed & CH341_BIT_CTS))) {
527 return 0; 527 return 0;
528 } 528 }
529 prevstatus = status; 529 prevstatus = status;
530 } 530 }
531 531
532 return 0; 532 return 0;
533 } 533 }
534 534
535 static int ch341_ioctl(struct tty_struct *tty, 535 static int ch341_ioctl(struct tty_struct *tty,
536 unsigned int cmd, unsigned long arg) 536 unsigned int cmd, unsigned long arg)
537 { 537 {
538 struct usb_serial_port *port = tty->driver_data; 538 struct usb_serial_port *port = tty->driver_data;
539 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd); 539 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
540 540
541 switch (cmd) { 541 switch (cmd) {
542 case TIOCMIWAIT: 542 case TIOCMIWAIT:
543 dbg("%s (%d) TIOCMIWAIT", __func__, port->number); 543 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
544 return wait_modem_info(port, arg); 544 return wait_modem_info(port, arg);
545 545
546 default: 546 default:
547 dbg("%s not supported = 0x%04x", __func__, cmd); 547 dbg("%s not supported = 0x%04x", __func__, cmd);
548 break; 548 break;
549 } 549 }
550 550
551 return -ENOIOCTLCMD; 551 return -ENOIOCTLCMD;
552 } 552 }
553 553
554 static int ch341_tiocmget(struct tty_struct *tty) 554 static int ch341_tiocmget(struct tty_struct *tty)
555 { 555 {
556 struct usb_serial_port *port = tty->driver_data; 556 struct usb_serial_port *port = tty->driver_data;
557 struct ch341_private *priv = usb_get_serial_port_data(port); 557 struct ch341_private *priv = usb_get_serial_port_data(port);
558 unsigned long flags; 558 unsigned long flags;
559 u8 mcr; 559 u8 mcr;
560 u8 status; 560 u8 status;
561 unsigned int result; 561 unsigned int result;
562 562
563 spin_lock_irqsave(&priv->lock, flags); 563 spin_lock_irqsave(&priv->lock, flags);
564 mcr = priv->line_control; 564 mcr = priv->line_control;
565 status = priv->line_status; 565 status = priv->line_status;
566 spin_unlock_irqrestore(&priv->lock, flags); 566 spin_unlock_irqrestore(&priv->lock, flags);
567 567
568 result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0) 568 result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0)
569 | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0) 569 | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0)
570 | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0) 570 | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0)
571 | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0) 571 | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0)
572 | ((status & CH341_BIT_RI) ? TIOCM_RI : 0) 572 | ((status & CH341_BIT_RI) ? TIOCM_RI : 0)
573 | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0); 573 | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0);
574 574
575 dbg("%s - result = %x", __func__, result); 575 dbg("%s - result = %x", __func__, result);
576 576
577 return result; 577 return result;
578 } 578 }
579 579
580 static int ch341_reset_resume(struct usb_serial *serial) 580 static int ch341_reset_resume(struct usb_serial *serial)
581 { 581 {
582 struct ch341_private *priv; 582 struct ch341_private *priv;
583 583
584 priv = usb_get_serial_port_data(serial->port[0]); 584 priv = usb_get_serial_port_data(serial->port[0]);
585 585
586 /* reconfigure ch341 serial port after bus-reset */ 586 /* reconfigure ch341 serial port after bus-reset */
587 ch341_configure(serial->dev, priv); 587 ch341_configure(serial->dev, priv);
588 588
589 return 0; 589 return 0;
590 } 590 }
591 591
592 static struct usb_serial_driver ch341_device = { 592 static struct usb_serial_driver ch341_device = {
593 .driver = { 593 .driver = {
594 .owner = THIS_MODULE, 594 .owner = THIS_MODULE,
595 .name = "ch341-uart", 595 .name = "ch341-uart",
596 }, 596 },
597 .id_table = id_table, 597 .id_table = id_table,
598 .num_ports = 1, 598 .num_ports = 1,
599 .open = ch341_open, 599 .open = ch341_open,
600 .dtr_rts = ch341_dtr_rts, 600 .dtr_rts = ch341_dtr_rts,
601 .carrier_raised = ch341_carrier_raised, 601 .carrier_raised = ch341_carrier_raised,
602 .close = ch341_close, 602 .close = ch341_close,
603 .ioctl = ch341_ioctl, 603 .ioctl = ch341_ioctl,
604 .set_termios = ch341_set_termios, 604 .set_termios = ch341_set_termios,
605 .break_ctl = ch341_break_ctl, 605 .break_ctl = ch341_break_ctl,
606 .tiocmget = ch341_tiocmget, 606 .tiocmget = ch341_tiocmget,
607 .tiocmset = ch341_tiocmset, 607 .tiocmset = ch341_tiocmset,
608 .read_int_callback = ch341_read_int_callback, 608 .read_int_callback = ch341_read_int_callback,
609 .attach = ch341_attach, 609 .attach = ch341_attach,
610 .resume = ch341_reset_resume, 610 .reset_resume = ch341_reset_resume,
611 }; 611 };
612 612
613 static struct usb_serial_driver * const serial_drivers[] = { 613 static struct usb_serial_driver * const serial_drivers[] = {
614 &ch341_device, NULL 614 &ch341_device, NULL
615 }; 615 };
616 616
617 module_usb_serial_driver(serial_drivers, id_table); 617 module_usb_serial_driver(serial_drivers, id_table);
618 618
619 MODULE_LICENSE("GPL"); 619 MODULE_LICENSE("GPL");
620 620
621 module_param(debug, bool, S_IRUGO | S_IWUSR); 621 module_param(debug, bool, S_IRUGO | S_IWUSR);
622 MODULE_PARM_DESC(debug, "Debug enabled or not"); 622 MODULE_PARM_DESC(debug, "Debug enabled or not");
623 623