1 /* 2 * Symbol USB barcode to serial driver 3 * 4 * Copyright (C) 2013 Johan Hovold <jhovold@gmail.com> 5 * Copyright (C) 2009 Greg Kroah-Hartman <gregkh@suse.de> 6 * Copyright (C) 2009 Novell Inc. 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License version 10 * 2 as published by the Free Software Foundation. 11 */ 12 13 #include <linux/kernel.h> 14 #include <linux/init.h> 15 #include <linux/tty.h> 16 #include <linux/slab.h> 17 #include <linux/tty_driver.h> 18 #include <linux/tty_flip.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 const struct usb_device_id id_table[] = { 25 { USB_DEVICE(0x05e0, 0x0600) }, 26 { }, 27 }; 28 MODULE_DEVICE_TABLE(usb, id_table); 29 30 struct symbol_private { 31 spinlock_t lock; /* protects the following flags */ 32 bool throttled; 33 bool actually_throttled; 34 }; 35 36 static void symbol_int_callback(struct urb *urb) 37 { 38 struct usb_serial_port *port = urb->context; 39 struct symbol_private *priv = usb_get_serial_port_data(port); 40 unsigned char *data = urb->transfer_buffer; 41 int status = urb->status; 42 int result; 43 int data_length; 44 45 switch (status) { 46 case 0: 47 /* success */ 48 break; 49 case -ECONNRESET: 50 case -ENOENT: 51 case -ESHUTDOWN: 52 /* this urb is terminated, clean up */ 53 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n", 54 __func__, status); 55 return; 56 default: 57 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n", 58 __func__, status); 59 goto exit; 60 } 61 62 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data); 63 64 if (urb->actual_length > 1) { 65 data_length = urb->actual_length - 1; 66 67 /* 68 * Data from the device comes with a 1 byte header: 69 * 70 * <size of data>data... 71 * This is real data to be sent to the tty layer 72 * we pretty much just ignore the size and send everything 73 * else to the tty layer. 74 */ 75 tty_insert_flip_string(&port->port, &data[1], data_length); 76 tty_flip_buffer_push(&port->port); 77 } else { 78 dev_dbg(&port->dev, 79 "Improper amount of data received from the device, " 80 "%d bytes", urb->actual_length); 81 } 82 83 exit: 84 spin_lock(&priv->lock); 85 86 /* Continue trying to always read if we should */ 87 if (!priv->throttled) { 88 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 89 if (result) 90 dev_err(&port->dev, 91 "%s - failed resubmitting read urb, error %d\n", 92 __func__, result); 93 } else 94 priv->actually_throttled = true; 95 spin_unlock(&priv->lock); 96 } 97 98 static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port) 99 { 100 struct symbol_private *priv = usb_get_serial_data(port->serial); 101 unsigned long flags; 102 int result = 0; 103 104 spin_lock_irqsave(&priv->lock, flags); 105 priv->throttled = false; 106 priv->actually_throttled = false; 107 spin_unlock_irqrestore(&priv->lock, flags); 108 109 /* Start reading from the device */ 110 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 111 if (result) 112 dev_err(&port->dev, 113 "%s - failed resubmitting read urb, error %d\n", 114 __func__, result); 115 return result; 116 } 117 118 static void symbol_close(struct usb_serial_port *port) 119 { 120 usb_kill_urb(port->interrupt_in_urb); 121 } 122 123 static void symbol_throttle(struct tty_struct *tty) 124 { 125 struct usb_serial_port *port = tty->driver_data; 126 struct symbol_private *priv = usb_get_serial_data(port->serial); 127 128 spin_lock_irq(&priv->lock); 129 priv->throttled = true; 130 spin_unlock_irq(&priv->lock); 131 } 132 133 static void symbol_unthrottle(struct tty_struct *tty) 134 { 135 struct usb_serial_port *port = tty->driver_data; 136 struct symbol_private *priv = usb_get_serial_data(port->serial); 137 int result; 138 bool was_throttled; 139 140 spin_lock_irq(&priv->lock); 141 priv->throttled = false; 142 was_throttled = priv->actually_throttled; 143 priv->actually_throttled = false; 144 spin_unlock_irq(&priv->lock); 145 146 if (was_throttled) { 147 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 148 if (result) 149 dev_err(&port->dev, 150 "%s - failed submitting read urb, error %d\n", 151 __func__, result); 152 } 153 } 154 155 static int symbol_startup(struct usb_serial *serial) 156 { 157 if (!serial->num_interrupt_in) { 158 dev_err(&serial->dev->dev, "no interrupt-in endpoint\n"); 159 return -ENODEV; 160 } 161 162 return 0; 163 } 164 165 static int symbol_port_probe(struct usb_serial_port *port) 166 { 167 struct symbol_private *priv; 168 169 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 170 if (!priv) 171 return -ENOMEM; 172 173 spin_lock_init(&priv->lock); 174 175 usb_set_serial_port_data(port, priv); 176 177 return 0; 178 } 179 180 static int symbol_port_remove(struct usb_serial_port *port) 181 { 182 struct symbol_private *priv = usb_get_serial_port_data(port); 183 184 kfree(priv); 185 186 return 0; 187 } 188 189 static struct usb_serial_driver symbol_device = { 190 .driver = { 191 .owner = THIS_MODULE, 192 .name = "symbol", 193 }, 194 .id_table = id_table, 195 .num_ports = 1, 196 .attach = symbol_startup, 197 .port_probe = symbol_port_probe, 198 .port_remove = symbol_port_remove, 199 .open = symbol_open, 200 .close = symbol_close, 201 .throttle = symbol_throttle, 202 .unthrottle = symbol_unthrottle, 203 .read_int_callback = symbol_int_callback, 204 }; 205 206 static struct usb_serial_driver * const serial_drivers[] = { 207 &symbol_device, NULL 208 }; 209 210 module_usb_serial_driver(serial_drivers, id_table); 211 212 MODULE_LICENSE("GPL"); 213