USB: serial: usb_wwan: Add missing uaccess.h / fix build failure
[linux-2.6.git] / drivers / usb / serial / opticon.c
1 /*
2  * Opticon USB barcode to serial driver
3  *
4  * Copyright (C) 2008 - 2009 Greg Kroah-Hartman <gregkh@suse.de>
5  * Copyright (C) 2008 - 2009 Novell Inc.
6  *
7  *      This program is free software; you can redistribute it and/or
8  *      modify it under the terms of the GNU General Public License version
9  *      2 as published by the Free Software Foundation.
10  */
11
12 #include <linux/kernel.h>
13 #include <linux/init.h>
14 #include <linux/tty.h>
15 #include <linux/tty_driver.h>
16 #include <linux/slab.h>
17 #include <linux/tty_flip.h>
18 #include <linux/serial.h>
19 #include <linux/module.h>
20 #include <linux/usb.h>
21 #include <linux/usb/serial.h>
22 #include <linux/uaccess.h>
23
24 static int debug;
25
26 static const struct usb_device_id id_table[] = {
27         { USB_DEVICE(0x065a, 0x0009) },
28         { },
29 };
30 MODULE_DEVICE_TABLE(usb, id_table);
31
32 /* This structure holds all of the individual device information */
33 struct opticon_private {
34         struct usb_device *udev;
35         struct usb_serial *serial;
36         struct usb_serial_port *port;
37         unsigned char *bulk_in_buffer;
38         struct urb *bulk_read_urb;
39         int buffer_size;
40         u8 bulk_address;
41         spinlock_t lock;        /* protects the following flags */
42         bool throttled;
43         bool actually_throttled;
44         bool rts;
45         int outstanding_urbs;
46 };
47
48 /* max number of write urbs in flight */
49 #define URB_UPPER_LIMIT 4
50
51 static void opticon_bulk_callback(struct urb *urb)
52 {
53         struct opticon_private *priv = urb->context;
54         unsigned char *data = urb->transfer_buffer;
55         struct usb_serial_port *port = priv->port;
56         int status = urb->status;
57         struct tty_struct *tty;
58         int result;
59         int data_length;
60
61         dbg("%s - port %d", __func__, port->number);
62
63         switch (status) {
64         case 0:
65                 /* success */
66                 break;
67         case -ECONNRESET:
68         case -ENOENT:
69         case -ESHUTDOWN:
70                 /* this urb is terminated, clean up */
71                 dbg("%s - urb shutting down with status: %d",
72                     __func__, status);
73                 return;
74         default:
75                 dbg("%s - nonzero urb status received: %d",
76                     __func__, status);
77                 goto exit;
78         }
79
80         usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
81                               data);
82
83         if (urb->actual_length > 2) {
84                 data_length = urb->actual_length - 2;
85
86                 /*
87                  * Data from the device comes with a 2 byte header:
88                  *
89                  * <0x00><0x00>data...
90                  *      This is real data to be sent to the tty layer
91                  * <0x00><0x01)level
92                  *      This is a RTS level change, the third byte is the RTS
93                  *      value (0 for low, 1 for high).
94                  */
95                 if ((data[0] == 0x00) && (data[1] == 0x00)) {
96                         /* real data, send it to the tty layer */
97                         tty = tty_port_tty_get(&port->port);
98                         if (tty) {
99                                 tty_insert_flip_string(tty, data + 2,
100                                                        data_length);
101                                 tty_flip_buffer_push(tty);
102                                 tty_kref_put(tty);
103                         }
104                 } else {
105                         if ((data[0] == 0x00) && (data[1] == 0x01)) {
106                                 if (data[2] == 0x00)
107                                         priv->rts = false;
108                                 else
109                                         priv->rts = true;
110                         } else {
111                                 dev_dbg(&priv->udev->dev,
112                                         "Unknown data packet received from the device:"
113                                         " %2x %2x\n",
114                                         data[0], data[1]);
115                         }
116                 }
117         } else {
118                 dev_dbg(&priv->udev->dev,
119                         "Improper amount of data received from the device, "
120                         "%d bytes", urb->actual_length);
121         }
122
123 exit:
124         spin_lock(&priv->lock);
125
126         /* Continue trying to always read if we should */
127         if (!priv->throttled) {
128                 usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
129                                   usb_rcvbulkpipe(priv->udev,
130                                                   priv->bulk_address),
131                                   priv->bulk_in_buffer, priv->buffer_size,
132                                   opticon_bulk_callback, priv);
133                 result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);
134                 if (result)
135                         dev_err(&port->dev,
136                             "%s - failed resubmitting read urb, error %d\n",
137                                                         __func__, result);
138         } else
139                 priv->actually_throttled = true;
140         spin_unlock(&priv->lock);
141 }
142
143 static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port)
144 {
145         struct opticon_private *priv = usb_get_serial_data(port->serial);
146         unsigned long flags;
147         int result = 0;
148
149         dbg("%s - port %d", __func__, port->number);
150
151         spin_lock_irqsave(&priv->lock, flags);
152         priv->throttled = false;
153         priv->actually_throttled = false;
154         priv->port = port;
155         spin_unlock_irqrestore(&priv->lock, flags);
156
157         /* Start reading from the device */
158         usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
159                           usb_rcvbulkpipe(priv->udev,
160                                           priv->bulk_address),
161                           priv->bulk_in_buffer, priv->buffer_size,
162                           opticon_bulk_callback, priv);
163         result = usb_submit_urb(priv->bulk_read_urb, GFP_KERNEL);
164         if (result)
165                 dev_err(&port->dev,
166                         "%s - failed resubmitting read urb, error %d\n",
167                         __func__, result);
168         return result;
169 }
170
171 static void opticon_close(struct usb_serial_port *port)
172 {
173         struct opticon_private *priv = usb_get_serial_data(port->serial);
174
175         dbg("%s - port %d", __func__, port->number);
176
177         /* shutdown our urbs */
178         usb_kill_urb(priv->bulk_read_urb);
179 }
180
181 static void opticon_write_bulk_callback(struct urb *urb)
182 {
183         struct opticon_private *priv = urb->context;
184         int status = urb->status;
185         unsigned long flags;
186
187         /* free up the transfer buffer, as usb_free_urb() does not do this */
188         kfree(urb->transfer_buffer);
189
190         /* setup packet may be set if we're using it for writing */
191         kfree(urb->setup_packet);
192
193         if (status)
194                 dbg("%s - nonzero write bulk status received: %d",
195                     __func__, status);
196
197         spin_lock_irqsave(&priv->lock, flags);
198         --priv->outstanding_urbs;
199         spin_unlock_irqrestore(&priv->lock, flags);
200
201         usb_serial_port_softint(priv->port);
202 }
203
204 static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
205                          const unsigned char *buf, int count)
206 {
207         struct opticon_private *priv = usb_get_serial_data(port->serial);
208         struct usb_serial *serial = port->serial;
209         struct urb *urb;
210         unsigned char *buffer;
211         unsigned long flags;
212         int status;
213
214         dbg("%s - port %d", __func__, port->number);
215
216         spin_lock_irqsave(&priv->lock, flags);
217         if (priv->outstanding_urbs > URB_UPPER_LIMIT) {
218                 spin_unlock_irqrestore(&priv->lock, flags);
219                 dbg("%s - write limit hit", __func__);
220                 return 0;
221         }
222         priv->outstanding_urbs++;
223         spin_unlock_irqrestore(&priv->lock, flags);
224
225         buffer = kmalloc(count, GFP_ATOMIC);
226         if (!buffer) {
227                 dev_err(&port->dev, "out of memory\n");
228                 count = -ENOMEM;
229                 goto error_no_buffer;
230         }
231
232         urb = usb_alloc_urb(0, GFP_ATOMIC);
233         if (!urb) {
234                 dev_err(&port->dev, "no more free urbs\n");
235                 count = -ENOMEM;
236                 goto error_no_urb;
237         }
238
239         memcpy(buffer, buf, count);
240
241         usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
242
243         if (port->bulk_out_endpointAddress) {
244                 usb_fill_bulk_urb(urb, serial->dev,
245                                   usb_sndbulkpipe(serial->dev,
246                                                   port->bulk_out_endpointAddress),
247                                   buffer, count, opticon_write_bulk_callback, priv);
248         } else {
249                 struct usb_ctrlrequest *dr;
250
251                 dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
252                 if (!dr)
253                         return -ENOMEM;
254
255                 dr->bRequestType = USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT;
256                 dr->bRequest = 0x01;
257                 dr->wValue = 0;
258                 dr->wIndex = 0;
259                 dr->wLength = cpu_to_le16(count);
260
261                 usb_fill_control_urb(urb, serial->dev,
262                         usb_sndctrlpipe(serial->dev, 0),
263                         (unsigned char *)dr, buffer, count,
264                         opticon_write_bulk_callback, priv);
265         }
266
267         /* send it down the pipe */
268         status = usb_submit_urb(urb, GFP_ATOMIC);
269         if (status) {
270                 dev_err(&port->dev,
271                    "%s - usb_submit_urb(write bulk) failed with status = %d\n",
272                                                         __func__, status);
273                 count = status;
274                 goto error;
275         }
276
277         /* we are done with this urb, so let the host driver
278          * really free it when it is finished with it */
279         usb_free_urb(urb);
280
281         return count;
282 error:
283         usb_free_urb(urb);
284 error_no_urb:
285         kfree(buffer);
286 error_no_buffer:
287         spin_lock_irqsave(&priv->lock, flags);
288         --priv->outstanding_urbs;
289         spin_unlock_irqrestore(&priv->lock, flags);
290         return count;
291 }
292
293 static int opticon_write_room(struct tty_struct *tty)
294 {
295         struct usb_serial_port *port = tty->driver_data;
296         struct opticon_private *priv = usb_get_serial_data(port->serial);
297         unsigned long flags;
298
299         dbg("%s - port %d", __func__, port->number);
300
301         /*
302          * We really can take almost anything the user throws at us
303          * but let's pick a nice big number to tell the tty
304          * layer that we have lots of free space, unless we don't.
305          */
306         spin_lock_irqsave(&priv->lock, flags);
307         if (priv->outstanding_urbs > URB_UPPER_LIMIT * 2 / 3) {
308                 spin_unlock_irqrestore(&priv->lock, flags);
309                 dbg("%s - write limit hit", __func__);
310                 return 0;
311         }
312         spin_unlock_irqrestore(&priv->lock, flags);
313
314         return 2048;
315 }
316
317 static void opticon_throttle(struct tty_struct *tty)
318 {
319         struct usb_serial_port *port = tty->driver_data;
320         struct opticon_private *priv = usb_get_serial_data(port->serial);
321         unsigned long flags;
322
323         dbg("%s - port %d", __func__, port->number);
324         spin_lock_irqsave(&priv->lock, flags);
325         priv->throttled = true;
326         spin_unlock_irqrestore(&priv->lock, flags);
327 }
328
329
330 static void opticon_unthrottle(struct tty_struct *tty)
331 {
332         struct usb_serial_port *port = tty->driver_data;
333         struct opticon_private *priv = usb_get_serial_data(port->serial);
334         unsigned long flags;
335         int result, was_throttled;
336
337         dbg("%s - port %d", __func__, port->number);
338
339         spin_lock_irqsave(&priv->lock, flags);
340         priv->throttled = false;
341         was_throttled = priv->actually_throttled;
342         priv->actually_throttled = false;
343         spin_unlock_irqrestore(&priv->lock, flags);
344
345         priv->bulk_read_urb->dev = port->serial->dev;
346         if (was_throttled) {
347                 result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);
348                 if (result)
349                         dev_err(&port->dev,
350                                 "%s - failed submitting read urb, error %d\n",
351                                                         __func__, result);
352         }
353 }
354
355 static int opticon_tiocmget(struct tty_struct *tty, struct file *file)
356 {
357         struct usb_serial_port *port = tty->driver_data;
358         struct opticon_private *priv = usb_get_serial_data(port->serial);
359         unsigned long flags;
360         int result = 0;
361
362         dbg("%s - port %d", __func__, port->number);
363
364         spin_lock_irqsave(&priv->lock, flags);
365         if (priv->rts)
366                 result = TIOCM_RTS;
367         spin_unlock_irqrestore(&priv->lock, flags);
368
369         dbg("%s - %x", __func__, result);
370         return result;
371 }
372
373 static int get_serial_info(struct opticon_private *priv,
374                            struct serial_struct __user *serial)
375 {
376         struct serial_struct tmp;
377
378         if (!serial)
379                 return -EFAULT;
380
381         memset(&tmp, 0x00, sizeof(tmp));
382
383         /* fake emulate a 16550 uart to make userspace code happy */
384         tmp.type                = PORT_16550A;
385         tmp.line                = priv->serial->minor;
386         tmp.port                = 0;
387         tmp.irq                 = 0;
388         tmp.flags               = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
389         tmp.xmit_fifo_size      = 1024;
390         tmp.baud_base           = 9600;
391         tmp.close_delay         = 5*HZ;
392         tmp.closing_wait        = 30*HZ;
393
394         if (copy_to_user(serial, &tmp, sizeof(*serial)))
395                 return -EFAULT;
396         return 0;
397 }
398
399 static int opticon_ioctl(struct tty_struct *tty, struct file *file,
400                          unsigned int cmd, unsigned long arg)
401 {
402         struct usb_serial_port *port = tty->driver_data;
403         struct opticon_private *priv = usb_get_serial_data(port->serial);
404
405         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
406
407         switch (cmd) {
408         case TIOCGSERIAL:
409                 return get_serial_info(priv,
410                                        (struct serial_struct __user *)arg);
411         }
412
413         return -ENOIOCTLCMD;
414 }
415
416 static int opticon_startup(struct usb_serial *serial)
417 {
418         struct opticon_private *priv;
419         struct usb_host_interface *intf;
420         int i;
421         int retval = -ENOMEM;
422         bool bulk_in_found = false;
423
424         /* create our private serial structure */
425         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
426         if (priv == NULL) {
427                 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
428                 return -ENOMEM;
429         }
430         spin_lock_init(&priv->lock);
431         priv->serial = serial;
432         priv->port = serial->port[0];
433         priv->udev = serial->dev;
434
435         /* find our bulk endpoint */
436         intf = serial->interface->altsetting;
437         for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
438                 struct usb_endpoint_descriptor *endpoint;
439
440                 endpoint = &intf->endpoint[i].desc;
441                 if (!usb_endpoint_is_bulk_in(endpoint))
442                         continue;
443
444                 priv->bulk_read_urb = usb_alloc_urb(0, GFP_KERNEL);
445                 if (!priv->bulk_read_urb) {
446                         dev_err(&priv->udev->dev, "out of memory\n");
447                         goto error;
448                 }
449
450                 priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
451                 priv->bulk_in_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
452                 if (!priv->bulk_in_buffer) {
453                         dev_err(&priv->udev->dev, "out of memory\n");
454                         goto error;
455                 }
456
457                 priv->bulk_address = endpoint->bEndpointAddress;
458
459                 /* set up our bulk urb */
460                 usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
461                                   usb_rcvbulkpipe(priv->udev,
462                                                   endpoint->bEndpointAddress),
463                                   priv->bulk_in_buffer, priv->buffer_size,
464                                   opticon_bulk_callback, priv);
465
466                 bulk_in_found = true;
467                 break;
468                 }
469
470         if (!bulk_in_found) {
471                 dev_err(&priv->udev->dev,
472                         "Error - the proper endpoints were not found!\n");
473                 goto error;
474         }
475
476         usb_set_serial_data(serial, priv);
477         return 0;
478
479 error:
480         usb_free_urb(priv->bulk_read_urb);
481         kfree(priv->bulk_in_buffer);
482         kfree(priv);
483         return retval;
484 }
485
486 static void opticon_disconnect(struct usb_serial *serial)
487 {
488         struct opticon_private *priv = usb_get_serial_data(serial);
489
490         dbg("%s", __func__);
491
492         usb_kill_urb(priv->bulk_read_urb);
493         usb_free_urb(priv->bulk_read_urb);
494 }
495
496 static void opticon_release(struct usb_serial *serial)
497 {
498         struct opticon_private *priv = usb_get_serial_data(serial);
499
500         dbg("%s", __func__);
501
502         kfree(priv->bulk_in_buffer);
503         kfree(priv);
504 }
505
506 static int opticon_suspend(struct usb_interface *intf, pm_message_t message)
507 {
508         struct usb_serial *serial = usb_get_intfdata(intf);
509         struct opticon_private *priv = usb_get_serial_data(serial);
510
511         usb_kill_urb(priv->bulk_read_urb);
512         return 0;
513 }
514
515 static int opticon_resume(struct usb_interface *intf)
516 {
517         struct usb_serial *serial = usb_get_intfdata(intf);
518         struct opticon_private *priv = usb_get_serial_data(serial);
519         struct usb_serial_port *port = serial->port[0];
520         int result;
521
522         mutex_lock(&port->port.mutex);
523         /* This is protected by the port mutex against close/open */
524         if (test_bit(ASYNCB_INITIALIZED, &port->port.flags))
525                 result = usb_submit_urb(priv->bulk_read_urb, GFP_NOIO);
526         else
527                 result = 0;
528         mutex_unlock(&port->port.mutex);
529         return result;
530 }
531
532 static struct usb_driver opticon_driver = {
533         .name =         "opticon",
534         .probe =        usb_serial_probe,
535         .disconnect =   usb_serial_disconnect,
536         .suspend =      opticon_suspend,
537         .resume =       opticon_resume,
538         .id_table =     id_table,
539         .no_dynamic_id =        1,
540 };
541
542 static struct usb_serial_driver opticon_device = {
543         .driver = {
544                 .owner =        THIS_MODULE,
545                 .name =         "opticon",
546         },
547         .id_table =             id_table,
548         .usb_driver =           &opticon_driver,
549         .num_ports =            1,
550         .attach =               opticon_startup,
551         .open =                 opticon_open,
552         .close =                opticon_close,
553         .write =                opticon_write,
554         .write_room =           opticon_write_room,
555         .disconnect =           opticon_disconnect,
556         .release =              opticon_release,
557         .throttle =             opticon_throttle,
558         .unthrottle =           opticon_unthrottle,
559         .ioctl =                opticon_ioctl,
560         .tiocmget =             opticon_tiocmget,
561 };
562
563 static int __init opticon_init(void)
564 {
565         int retval;
566
567         retval = usb_serial_register(&opticon_device);
568         if (retval)
569                 return retval;
570         retval = usb_register(&opticon_driver);
571         if (retval)
572                 usb_serial_deregister(&opticon_device);
573         return retval;
574 }
575
576 static void __exit opticon_exit(void)
577 {
578         usb_deregister(&opticon_driver);
579         usb_serial_deregister(&opticon_device);
580 }
581
582 module_init(opticon_init);
583 module_exit(opticon_exit);
584 MODULE_LICENSE("GPL");
585
586 module_param(debug, bool, S_IRUGO | S_IWUSR);
587 MODULE_PARM_DESC(debug, "Debug enabled or not");