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