1 /* 2 * Symbol USB barcode to serial driver 3 * 4 * Copyright (C) 2009 Greg Kroah-Hartman <gregkh@suse.de> 5 * Copyright (C) 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/slab.h> 16 #include <linux/tty_driver.h> 17 #include <linux/tty_flip.h> 18 #include <linux/module.h> 19 #include <linux/usb.h> 20 #include <linux/usb/serial.h> 21 #include <linux/uaccess.h> 22 23 static bool debug; 24 25 static const struct usb_device_id id_table[] = { 26 { USB_DEVICE(0x05e0, 0x0600) }, 27 { }, 28 }; 29 MODULE_DEVICE_TABLE(usb, id_table); 30 31 /* This structure holds all of the individual device information */ 32 struct symbol_private { 33 struct usb_device *udev; 34 struct usb_serial *serial; 35 struct usb_serial_port *port; 36 unsigned char *int_buffer; 37 struct urb *int_urb; 38 int buffer_size; 39 u8 bInterval; 40 u8 int_address; 41 spinlock_t lock; /* protects the following flags */ 42 bool throttled; 43 bool actually_throttled; 44 bool rts; 45 }; 46 47 static void symbol_int_callback(struct urb *urb) 48 { 49 struct symbol_private *priv = urb->context; 50 unsigned char *data = urb->transfer_buffer; 51 struct usb_serial_port *port = priv->port; 52 int status = urb->status; 53 struct tty_struct *tty; 54 int result; 55 int data_length; 56 57 dbg("%s - port %d", __func__, port->number); 58 59 switch (status) { 60 case 0: 61 /* success */ 62 break; 63 case -ECONNRESET: 64 case -ENOENT: 65 case -ESHUTDOWN: 66 /* this urb is terminated, clean up */ 67 dbg("%s - urb shutting down with status: %d", 68 __func__, status); 69 return; 70 default: 71 dbg("%s - nonzero urb status received: %d", 72 __func__, status); 73 goto exit; 74 } 75 76 usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, 77 data); 78 79 if (urb->actual_length > 1) { 80 data_length = urb->actual_length - 1; 81 82 /* 83 * Data from the device comes with a 1 byte header: 84 * 85 * <size of data>data... 86 * This is real data to be sent to the tty layer 87 * we pretty much just ignore the size and send everything 88 * else to the tty layer. 89 */ 90 tty = tty_port_tty_get(&port->port); 91 if (tty) { 92 tty_insert_flip_string(tty, &data[1], data_length); 93 tty_flip_buffer_push(tty); 94 tty_kref_put(tty); 95 } 96 } else { 97 dev_dbg(&priv->udev->dev, 98 "Improper amount of data received from the device, " 99 "%d bytes", urb->actual_length); 100 } 101 102 exit: 103 spin_lock(&priv->lock); 104 105 /* Continue trying to always read if we should */ 106 if (!priv->throttled) { 107 usb_fill_int_urb(priv->int_urb, priv->udev, 108 usb_rcvintpipe(priv->udev, 109 priv->int_address), 110 priv->int_buffer, priv->buffer_size, 111 symbol_int_callback, priv, priv->bInterval); 112 result = usb_submit_urb(priv->int_urb, GFP_ATOMIC); 113 if (result) 114 dev_err(&port->dev, 115 "%s - failed resubmitting read urb, error %d\n", 116 __func__, result); 117 } else 118 priv->actually_throttled = true; 119 spin_unlock(&priv->lock); 120 } 121 122 static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port) 123 { 124 struct symbol_private *priv = usb_get_serial_data(port->serial); 125 unsigned long flags; 126 int result = 0; 127 128 dbg("%s - port %d", __func__, port->number); 129 130 spin_lock_irqsave(&priv->lock, flags); 131 priv->throttled = false; 132 priv->actually_throttled = false; 133 priv->port = port; 134 spin_unlock_irqrestore(&priv->lock, flags); 135 136 /* Start reading from the device */ 137 usb_fill_int_urb(priv->int_urb, priv->udev, 138 usb_rcvintpipe(priv->udev, priv->int_address), 139 priv->int_buffer, priv->buffer_size, 140 symbol_int_callback, priv, priv->bInterval); 141 result = usb_submit_urb(priv->int_urb, GFP_KERNEL); 142 if (result) 143 dev_err(&port->dev, 144 "%s - failed resubmitting read urb, error %d\n", 145 __func__, result); 146 return result; 147 } 148 149 static void symbol_close(struct usb_serial_port *port) 150 { 151 struct symbol_private *priv = usb_get_serial_data(port->serial); 152 153 dbg("%s - port %d", __func__, port->number); 154 155 /* shutdown our urbs */ 156 usb_kill_urb(priv->int_urb); 157 } 158 159 static void symbol_throttle(struct tty_struct *tty) 160 { 161 struct usb_serial_port *port = tty->driver_data; 162 struct symbol_private *priv = usb_get_serial_data(port->serial); 163 164 dbg("%s - port %d", __func__, port->number); 165 spin_lock_irq(&priv->lock); 166 priv->throttled = true; 167 spin_unlock_irq(&priv->lock); 168 } 169 170 static void symbol_unthrottle(struct tty_struct *tty) 171 { 172 struct usb_serial_port *port = tty->driver_data; 173 struct symbol_private *priv = usb_get_serial_data(port->serial); 174 int result; 175 bool was_throttled; 176 177 dbg("%s - port %d", __func__, port->number); 178 179 spin_lock_irq(&priv->lock); 180 priv->throttled = false; 181 was_throttled = priv->actually_throttled; 182 priv->actually_throttled = false; 183 spin_unlock_irq(&priv->lock); 184 185 if (was_throttled) { 186 result = usb_submit_urb(priv->int_urb, GFP_KERNEL); 187 if (result) 188 dev_err(&port->dev, 189 "%s - failed submitting read urb, error %d\n", 190 __func__, result); 191 } 192 } 193 194 static int symbol_startup(struct usb_serial *serial) 195 { 196 struct symbol_private *priv; 197 struct usb_host_interface *intf; 198 int i; 199 int retval = -ENOMEM; 200 bool int_in_found = false; 201 202 /* create our private serial structure */ 203 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 204 if (priv == NULL) { 205 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__); 206 return -ENOMEM; 207 } 208 spin_lock_init(&priv->lock); 209 priv->serial = serial; 210 priv->port = serial->port[0]; 211 priv->udev = serial->dev; 212 213 /* find our interrupt endpoint */ 214 intf = serial->interface->altsetting; 215 for (i = 0; i < intf->desc.bNumEndpoints; ++i) { 216 struct usb_endpoint_descriptor *endpoint; 217 218 endpoint = &intf->endpoint[i].desc; 219 if (!usb_endpoint_is_int_in(endpoint)) 220 continue; 221 222 priv->int_urb = usb_alloc_urb(0, GFP_KERNEL); 223 if (!priv->int_urb) { 224 dev_err(&priv->udev->dev, "out of memory\n"); 225 goto error; 226 } 227 228 priv->buffer_size = usb_endpoint_maxp(endpoint) * 2; 229 priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL); 230 if (!priv->int_buffer) { 231 dev_err(&priv->udev->dev, "out of memory\n"); 232 goto error; 233 } 234 235 priv->int_address = endpoint->bEndpointAddress; 236 priv->bInterval = endpoint->bInterval; 237 238 /* set up our int urb */ 239 usb_fill_int_urb(priv->int_urb, priv->udev, 240 usb_rcvintpipe(priv->udev, 241 endpoint->bEndpointAddress), 242 priv->int_buffer, priv->buffer_size, 243 symbol_int_callback, priv, priv->bInterval); 244 245 int_in_found = true; 246 break; 247 } 248 249 if (!int_in_found) { 250 dev_err(&priv->udev->dev, 251 "Error - the proper endpoints were not found!\n"); 252 goto error; 253 } 254 255 usb_set_serial_data(serial, priv); 256 return 0; 257 258 error: 259 usb_free_urb(priv->int_urb); 260 kfree(priv->int_buffer); 261 kfree(priv); 262 return retval; 263 } 264 265 static void symbol_disconnect(struct usb_serial *serial) 266 { 267 struct symbol_private *priv = usb_get_serial_data(serial); 268 269 dbg("%s", __func__); 270 271 usb_kill_urb(priv->int_urb); 272 usb_free_urb(priv->int_urb); 273 } 274 275 static void symbol_release(struct usb_serial *serial) 276 { 277 struct symbol_private *priv = usb_get_serial_data(serial); 278 279 dbg("%s", __func__); 280 281 kfree(priv->int_buffer); 282 kfree(priv); 283 } 284 285 static struct usb_driver symbol_driver = { 286 .name = "symbol", 287 .probe = usb_serial_probe, 288 .disconnect = usb_serial_disconnect, 289 .id_table = id_table, 290 }; 291 292 static struct usb_serial_driver symbol_device = { 293 .driver = { 294 .owner = THIS_MODULE, 295 .name = "symbol", 296 }, 297 .id_table = id_table, 298 .num_ports = 1, 299 .attach = symbol_startup, 300 .open = symbol_open, 301 .close = symbol_close, 302 .disconnect = symbol_disconnect, 303 .release = symbol_release, 304 .throttle = symbol_throttle, 305 .unthrottle = symbol_unthrottle, 306 }; 307 308 static struct usb_serial_driver * const serial_drivers[] = { 309 &symbol_device, NULL 310 }; 311 312 module_usb_serial_driver(symbol_driver, serial_drivers); 313 314 MODULE_LICENSE("GPL"); 315 316 module_param(debug, bool, S_IRUGO | S_IWUSR); 317 MODULE_PARM_DESC(debug, "Debug enabled or not"); 318