blob: 3efdd77c75d7e53711e7749a571cd76012df57d5 [file] [log] [blame]
Hemant Kumar0cac8ed2012-01-31 14:39:23 -08001/* Copyright (c) 2012, Code Aurora Forum. All rights reserved.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 */
12
Steve Mucklef132c6c2012-06-06 18:30:57 -070013#include <linux/module.h>
Hemant Kumar0cac8ed2012-01-31 14:39:23 -080014#include <linux/slab.h>
15#include <linux/tty.h>
16#include <linux/serial.h>
17#include <linux/tty_flip.h>
18#include <linux/uaccess.h>
19#include <linux/usb.h>
20#include <linux/usb/ch9.h>
21#include <linux/usb/cdc.h>
22#include <linux/usb/serial.h>
23#include <asm/unaligned.h>
24
25
26/* output control lines*/
27#define CSVT_CTRL_DTR 0x01
28#define CSVT_CTRL_RTS 0x02
29
30/* input control lines*/
31#define CSVT_CTRL_CTS 0x01
32#define CSVT_CTRL_DSR 0x02
33#define CSVT_CTRL_RI 0x04
34#define CSVT_CTRL_CD 0x08
35
36static int debug;
37module_param(debug, int, S_IRUGO | S_IWUSR);
38
39struct csvt_ctrl_dev {
40 struct mutex dev_lock;
41
42 /* input control lines (DSR, CTS, CD, RI) */
43 unsigned int cbits_tolocal;
44
45 /* output control lines (DTR, RTS) */
46 unsigned int cbits_tomdm;
47};
48
49static const struct usb_device_id id_table[] = {
Hemant Kumar31aed6a2012-03-05 14:56:26 -080050 { USB_DEVICE_AND_INTERFACE_INFO(0x05c6 , 0x904c, 0xff, 0xfe, 0xff)},
Hemant Kumar0cac8ed2012-01-31 14:39:23 -080051 {}, /* terminating entry */
52};
53MODULE_DEVICE_TABLE(usb, id_table);
54
55static struct usb_driver csvt_driver = {
56 .name = "qc_csvt",
57 .probe = usb_serial_probe,
58 .disconnect = usb_serial_disconnect,
59 .id_table = id_table,
60 .suspend = usb_serial_suspend,
61 .resume = usb_serial_resume,
62 .supports_autosuspend = true,
63};
64
65#define CSVT_IFC_NUM 4
66
67static int csvt_probe(struct usb_serial *serial, const struct usb_device_id *id)
68{
69 struct usb_host_interface *intf =
70 serial->interface->cur_altsetting;
71
72 pr_debug("%s:\n", __func__);
73
74 if (intf->desc.bInterfaceNumber != CSVT_IFC_NUM)
75 return -ENODEV;
76
77 usb_enable_autosuspend(serial->dev);
78
79 return 0;
80}
81
82static int csvt_ctrl_write_cmd(struct csvt_ctrl_dev *dev,
83 struct usb_serial_port *port)
84{
85 struct usb_device *udev = port->serial->dev;
86 struct usb_interface *iface = port->serial->interface;
87 unsigned int iface_num;
88 int retval = 0;
89
90 retval = usb_autopm_get_interface(iface);
91 if (retval < 0) {
92 dev_err(&port->dev, "%s: Unable to resume interface: %d\n",
93 __func__, retval);
94 return retval;
95 }
96
97 dev_dbg(&port->dev, "%s: cbits to mdm 0x%x\n", __func__,
98 dev->cbits_tomdm);
99
100 iface_num = iface->cur_altsetting->desc.bInterfaceNumber;
101
102 retval = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
103 USB_CDC_REQ_SET_CONTROL_LINE_STATE,
104 (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE),
105 dev->cbits_tomdm,
106 iface_num,
107 NULL, 0, USB_CTRL_SET_TIMEOUT);
108 usb_autopm_put_interface(iface);
109
110 return retval;
111}
112
113static void csvt_ctrl_dtr_rts(struct usb_serial_port *port, int on)
114{
115 struct csvt_ctrl_dev *dev = usb_get_serial_port_data(port);
116
117 if (!dev)
118 return;
119
120 dev_dbg(&port->dev, "%s", __func__);
121
122 mutex_lock(&dev->dev_lock);
123 if (on) {
124 dev->cbits_tomdm |= CSVT_CTRL_DTR;
125 dev->cbits_tomdm |= CSVT_CTRL_RTS;
126 } else {
127 dev->cbits_tomdm &= ~CSVT_CTRL_DTR;
128 dev->cbits_tomdm &= ~CSVT_CTRL_RTS;
129 }
130 mutex_unlock(&dev->dev_lock);
131
132 csvt_ctrl_write_cmd(dev, port);
133}
134
135static int get_serial_info(struct usb_serial_port *port,
136 struct serial_struct __user *retinfo)
137{
138 struct serial_struct tmp;
139
140 if (!retinfo)
141 return -EFAULT;
142
143 memset(&tmp, 0, sizeof(tmp));
144 tmp.line = port->serial->minor;
145 tmp.port = port->number;
146 tmp.baud_base = tty_get_baud_rate(port->port.tty);
147 tmp.close_delay = port->port.close_delay / 10;
148 tmp.closing_wait =
149 port->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
150 ASYNC_CLOSING_WAIT_NONE :
151 port->port.closing_wait / 10;
152
153 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
154 return -EFAULT;
155 return 0;
156}
157
158static int set_serial_info(struct usb_serial_port *port,
159 struct serial_struct __user *newinfo)
160{
161 struct serial_struct new_serial;
162 unsigned int closing_wait;
163 unsigned int close_delay;
164 int retval = 0;
165
166 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
167 return -EFAULT;
168
169 close_delay = new_serial.close_delay * 10;
170 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
171 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
172
173 mutex_lock(&port->port.mutex);
174
175 if (!capable(CAP_SYS_ADMIN)) {
176 if ((close_delay != port->port.close_delay) ||
177 (closing_wait != port->port.closing_wait))
178 retval = -EPERM;
179 else
180 retval = -EOPNOTSUPP;
181 } else {
182 port->port.close_delay = close_delay;
183 port->port.closing_wait = closing_wait;
184 }
185
186 mutex_unlock(&port->port.mutex);
187 return retval;
188}
189
190static int csvt_ctrl_ioctl(struct tty_struct *tty, unsigned int cmd,
191 unsigned long arg)
192{
193 struct usb_serial_port *port = tty->driver_data;
194
195 dev_dbg(&port->dev, "%s cmd 0x%04x", __func__, cmd);
196
197 switch (cmd) {
198 case TIOCGSERIAL:
199 return get_serial_info(port,
200 (struct serial_struct __user *) arg);
201 case TIOCSSERIAL:
202 return set_serial_info(port,
203 (struct serial_struct __user *) arg);
204 default:
205 break;
206 }
207
208 dev_err(&port->dev, "%s arg not supported", __func__);
209
210 return -ENOIOCTLCMD;
211}
212
213static int csvt_ctrl_tiocmget(struct tty_struct *tty)
214{
215 struct usb_serial_port *port = tty->driver_data;
216 struct csvt_ctrl_dev *dev = usb_get_serial_port_data(port);
217 unsigned int control_state = 0;
218
219 if (!dev)
220 return -ENODEV;
221
222 mutex_lock(&dev->dev_lock);
223 control_state = (dev->cbits_tomdm & CSVT_CTRL_DTR ? TIOCM_DTR : 0) |
224 (dev->cbits_tomdm & CSVT_CTRL_RTS ? TIOCM_RTS : 0) |
225 (dev->cbits_tolocal & CSVT_CTRL_DSR ? TIOCM_DSR : 0) |
226 (dev->cbits_tolocal & CSVT_CTRL_RI ? TIOCM_RI : 0) |
227 (dev->cbits_tolocal & CSVT_CTRL_CD ? TIOCM_CD : 0) |
228 (dev->cbits_tolocal & CSVT_CTRL_CTS ? TIOCM_CTS : 0);
229 mutex_unlock(&dev->dev_lock);
230
231 dev_dbg(&port->dev, "%s -- %x", __func__, control_state);
232
233 return control_state;
234}
235
236static int csvt_ctrl_tiocmset(struct tty_struct *tty,
237 unsigned int set, unsigned int clear)
238{
239 struct usb_serial_port *port = tty->driver_data;
240 struct csvt_ctrl_dev *dev = usb_get_serial_port_data(port);
241
242 if (!dev)
243 return -ENODEV;
244
245 dev_dbg(&port->dev, "%s\n", __func__);
246
247 mutex_lock(&dev->dev_lock);
248 if (set & CSVT_CTRL_DTR)
249 dev->cbits_tomdm |= TIOCM_DTR;
250 if (set & CSVT_CTRL_RTS)
251 dev->cbits_tomdm |= TIOCM_RTS;
252
253 if (clear & CSVT_CTRL_DTR)
254 dev->cbits_tomdm &= ~TIOCM_DTR;
255 if (clear & CSVT_CTRL_RTS)
256 dev->cbits_tomdm &= ~TIOCM_RTS;
257 mutex_unlock(&dev->dev_lock);
258
259 return csvt_ctrl_write_cmd(dev, port);
260}
261
262static void csvt_ctrl_set_termios(struct tty_struct *tty,
263 struct usb_serial_port *port,
264 struct ktermios *old_termios)
265{
266 struct csvt_ctrl_dev *dev = usb_get_serial_port_data(port);
267
268 if (!dev)
269 return;
270
271 dev_dbg(&port->dev, "%s", __func__);
272
273 /* Doesn't support option setting */
274 tty_termios_copy_hw(tty->termios, old_termios);
275
276 csvt_ctrl_write_cmd(dev, port);
277}
278
279static void csvt_ctrl_int_cb(struct urb *urb)
280{
281 int status;
282 struct usb_cdc_notification *ctrl;
283 struct usb_serial_port *port = urb->context;
284 struct csvt_ctrl_dev *dev;
285 unsigned int ctrl_bits;
286 unsigned char *data;
287
288 switch (urb->status) {
289 case 0:
290 /*success*/
291 break;
292 case -ESHUTDOWN:
293 case -ENOENT:
294 case -ECONNRESET:
295 case -EPROTO:
296 /* unplug */
297 return;
298 case -EPIPE:
299 dev_err(&port->dev, "%s: stall on int endpoint\n", __func__);
300 /* TBD : halt to be cleared in work */
301 case -EOVERFLOW:
302 default:
303 pr_debug_ratelimited("%s: non zero urb status = %d\n",
304 __func__, urb->status);
305 goto resubmit_int_urb;
306 }
307
308 dev = usb_get_serial_port_data(port);
309 if (!dev)
310 return;
311
312 ctrl = urb->transfer_buffer;
313 data = (unsigned char *)(ctrl + 1);
314
315 usb_serial_debug_data(debug, &port->dev, __func__,
316 urb->actual_length, data);
317
318 switch (ctrl->bNotificationType) {
319 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
320 dev_dbg(&port->dev, "%s network\n", ctrl->wValue ?
321 "connected to" : "disconnected from");
322 break;
323 case USB_CDC_NOTIFY_SERIAL_STATE:
324 ctrl_bits = get_unaligned_le16(data);
325 dev_dbg(&port->dev, "serial state: %d\n", ctrl_bits);
326 dev->cbits_tolocal = ctrl_bits;
327 break;
328 default:
329 dev_err(&port->dev, "%s: unknown notification %d received:"
330 "index %d len %d data0 %d data1 %d",
331 __func__, ctrl->bNotificationType, ctrl->wIndex,
332 ctrl->wLength, data[0], data[1]);
333 }
334
335resubmit_int_urb:
336 status = usb_submit_urb(urb, GFP_ATOMIC);
337 if (status)
338 dev_err(&port->dev, "%s: Error re-submitting Int URB %d\n",
339 __func__, status);
340
341}
342
343static int csvt_ctrl_open(struct tty_struct *tty,
344 struct usb_serial_port *port)
345{
346 int retval;
347
348 dev_dbg(&port->dev, "%s port %d", __func__, port->number);
349
350 retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
351 if (retval) {
352 dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
353 return retval;
354 }
355
356 retval = usb_serial_generic_open(tty, port);
357 if (retval)
358 usb_kill_urb(port->interrupt_in_urb);
359
360 return retval;
361}
362
363static void csvt_ctrl_close(struct usb_serial_port *port)
364{
365 dev_dbg(&port->dev, "%s port %d", __func__, port->number);
366
367 usb_serial_generic_close(port);
368 usb_kill_urb(port->interrupt_in_urb);
369}
370
371static int csvt_ctrl_attach(struct usb_serial *serial)
372{
373 struct csvt_ctrl_dev *dev;
374
375 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
376 if (!dev)
377 return -ENOMEM;
378
379 mutex_init(&dev->dev_lock);
380 usb_set_serial_port_data(serial->port[0], dev);
381
382 return 0;
383}
384
385static void csvt_ctrl_release(struct usb_serial *serial)
386{
387 struct usb_serial_port *port = serial->port[0];
388 struct csvt_ctrl_dev *dev = usb_get_serial_port_data(port);
389
390 dev_dbg(&port->dev, "%s", __func__);
391
392 kfree(dev);
393 usb_set_serial_port_data(port, NULL);
394}
395
396static struct usb_serial_driver csvt_device = {
397 .driver = {
398 .owner = THIS_MODULE,
399 .name = "qc_csvt",
400 },
401 .description = "qc_csvt",
402 .id_table = id_table,
Hemant Kumar0cac8ed2012-01-31 14:39:23 -0800403 .num_ports = 1,
404 .open = csvt_ctrl_open,
405 .close = csvt_ctrl_close,
406 .probe = csvt_probe,
407 .dtr_rts = csvt_ctrl_dtr_rts,
408 .tiocmget = csvt_ctrl_tiocmget,
409 .tiocmset = csvt_ctrl_tiocmset,
410 .ioctl = csvt_ctrl_ioctl,
411 .set_termios = csvt_ctrl_set_termios,
412 .read_int_callback = csvt_ctrl_int_cb,
413 .attach = csvt_ctrl_attach,
414 .release = csvt_ctrl_release,
415};
416
Steve Mucklef132c6c2012-06-06 18:30:57 -0700417static struct usb_serial_driver * const serial_drivers[] = {
418 &csvt_device,
419 NULL,
420};
421
Hemant Kumar0cac8ed2012-01-31 14:39:23 -0800422static int __init csvt_init(void)
423{
424 int retval;
425
Steve Mucklef132c6c2012-06-06 18:30:57 -0700426 retval = usb_serial_register_drivers(&csvt_driver, serial_drivers);
Hemant Kumar0cac8ed2012-01-31 14:39:23 -0800427 if (retval) {
428 err("%s: usb serial register failed\n", __func__);
429 return retval;
430 }
431
Hemant Kumar0cac8ed2012-01-31 14:39:23 -0800432 return 0;
433}
434
435static void __exit csvt_exit(void)
436{
Steve Mucklef132c6c2012-06-06 18:30:57 -0700437 usb_serial_deregister_drivers(&csvt_driver, serial_drivers);
Hemant Kumar0cac8ed2012-01-31 14:39:23 -0800438}
439
440module_init(csvt_init);
441module_exit(csvt_exit);
442
443MODULE_LICENSE("GPL v2");