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/tty_driver.h> 16 #include <linux/tty_flip.h> 17 #include <linux/module.h> 18 #include <linux/usb.h> 19 #include <linux/usb/serial.h> 20 #include <linux/uaccess.h> 21 22 static int debug; 23 24 static struct usb_device_id id_table[] = { 25 { USB_DEVICE(0x05e0, 0x0600) }, 26 { }, 27 }; 28 MODULE_DEVICE_TABLE(usb, id_table); 29 30 /* This structure holds all of the individual device information */ 31 struct symbol_private { 32 struct usb_device *udev; 33 struct usb_serial *serial; 34 struct usb_serial_port *port; 35 unsigned char *int_buffer; 36 struct urb *int_urb; 37 int buffer_size; 38 u8 bInterval; 39 u8 int_address; 40 spinlock_t lock; /* protects the following flags */ 41 bool throttled; 42 bool actually_throttled; 43 bool rts; 44 }; 45 46 static void symbol_int_callback(struct urb *urb) 47 { 48 struct symbol_private *priv = urb->context; 49 unsigned char *data = urb->transfer_buffer; 50 struct usb_serial_port *port = priv->port; 51 int status = urb->status; 52 struct tty_struct *tty; 53 int result; 54 int available_room = 0; 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 available_room = tty_buffer_request_room(tty, 93 data_length); 94 if (available_room) { 95 tty_insert_flip_string(tty, &data[1], 96 available_room); 97 tty_flip_buffer_push(tty); 98 } 99 tty_kref_put(tty); 100 } 101 } else { 102 dev_dbg(&priv->udev->dev, 103 "Improper ammount of data received from the device, " 104 "%d bytes", urb->actual_length); 105 } 106 107 exit: 108 spin_lock(&priv->lock); 109 110 /* Continue trying to always read if we should */ 111 if (!priv->throttled) { 112 usb_fill_int_urb(priv->int_urb, priv->udev, 113 usb_rcvintpipe(priv->udev, 114 priv->int_address), 115 priv->int_buffer, priv->buffer_size, 116 symbol_int_callback, priv, priv->bInterval); 117 result = usb_submit_urb(priv->int_urb, GFP_ATOMIC); 118 if (result) 119 dev_err(&port->dev, 120 "%s - failed resubmitting read urb, error %d\n", 121 __func__, result); 122 } else 123 priv->actually_throttled = true; 124 spin_unlock(&priv->lock); 125 } 126 127 static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port, 128 struct file *filp) 129 { 130 struct symbol_private *priv = usb_get_serial_data(port->serial); 131 unsigned long flags; 132 int result = 0; 133 134 dbg("%s - port %d", __func__, port->number); 135 136 spin_lock_irqsave(&priv->lock, flags); 137 priv->throttled = false; 138 priv->actually_throttled = false; 139 priv->port = port; 140 spin_unlock_irqrestore(&priv->lock, flags); 141 142 /* 143 * Force low_latency on so that our tty_push actually forces the data 144 * through, otherwise it is scheduled, and with high data rates (like 145 * with OHCI) data can get lost. 146 */ 147 if (tty) 148 tty->low_latency = 1; 149 150 /* Start reading from the device */ 151 usb_fill_int_urb(priv->int_urb, priv->udev, 152 usb_rcvintpipe(priv->udev, priv->int_address), 153 priv->int_buffer, priv->buffer_size, 154 symbol_int_callback, priv, priv->bInterval); 155 result = usb_submit_urb(priv->int_urb, GFP_KERNEL); 156 if (result) 157 dev_err(&port->dev, 158 "%s - failed resubmitting read urb, error %d\n", 159 __func__, result); 160 return result; 161 } 162 163 static void symbol_close(struct tty_struct *tty, struct usb_serial_port *port, 164 struct file *filp) 165 { 166 struct symbol_private *priv = usb_get_serial_data(port->serial); 167 168 dbg("%s - port %d", __func__, port->number); 169 170 /* shutdown our urbs */ 171 usb_kill_urb(priv->int_urb); 172 } 173 174 static void symbol_throttle(struct tty_struct *tty) 175 { 176 struct usb_serial_port *port = tty->driver_data; 177 struct symbol_private *priv = usb_get_serial_data(port->serial); 178 unsigned long flags; 179 180 dbg("%s - port %d", __func__, port->number); 181 spin_lock_irqsave(&priv->lock, flags); 182 priv->throttled = true; 183 spin_unlock_irqrestore(&priv->lock, flags); 184 } 185 186 static void symbol_unthrottle(struct tty_struct *tty) 187 { 188 struct usb_serial_port *port = tty->driver_data; 189 struct symbol_private *priv = usb_get_serial_data(port->serial); 190 unsigned long flags; 191 int result; 192 193 dbg("%s - port %d", __func__, port->number); 194 195 spin_lock_irqsave(&priv->lock, flags); 196 priv->throttled = false; 197 priv->actually_throttled = false; 198 spin_unlock_irqrestore(&priv->lock, flags); 199 200 priv->int_urb->dev = port->serial->dev; 201 result = usb_submit_urb(priv->int_urb, GFP_ATOMIC); 202 if (result) 203 dev_err(&port->dev, 204 "%s - failed submitting read urb, error %d\n", 205 __func__, result); 206 } 207 208 static int symbol_ioctl(struct tty_struct *tty, struct file *file, 209 unsigned int cmd, unsigned long arg) 210 { 211 struct usb_serial_port *port = tty->driver_data; 212 struct device *dev = &port->dev; 213 214 /* 215 * Right now we need to figure out what commands 216 * most userspace tools want to see for this driver, 217 * so just log the things. 218 */ 219 switch (cmd) { 220 case TIOCSERGETLSR: 221 dev_info(dev, "%s: TIOCSERGETLSR\n", __func__); 222 break; 223 224 case TIOCGSERIAL: 225 dev_info(dev, "%s: TIOCGSERIAL\n", __func__); 226 break; 227 228 case TIOCMIWAIT: 229 dev_info(dev, "%s: TIOCMIWAIT\n", __func__); 230 break; 231 232 case TIOCGICOUNT: 233 dev_info(dev, "%s: TIOCGICOUNT\n", __func__); 234 break; 235 default: 236 dev_info(dev, "%s: unknown (%d)\n", __func__, cmd); 237 } 238 return -ENOIOCTLCMD; 239 } 240 241 static int symbol_tiocmget(struct tty_struct *tty, struct file *file) 242 { 243 struct usb_serial_port *port = tty->driver_data; 244 struct device *dev = &port->dev; 245 246 /* TODO */ 247 /* probably just need to shadow whatever was sent to us here */ 248 dev_info(dev, "%s\n", __func__); 249 return 0; 250 } 251 252 static int symbol_tiocmset(struct tty_struct *tty, struct file *file, 253 unsigned int set, unsigned int clear) 254 { 255 struct usb_serial_port *port = tty->driver_data; 256 struct device *dev = &port->dev; 257 258 /* TODO */ 259 /* probably just need to shadow whatever was sent to us here */ 260 dev_info(dev, "%s\n", __func__); 261 return 0; 262 } 263 264 static int symbol_startup(struct usb_serial *serial) 265 { 266 struct symbol_private *priv; 267 struct usb_host_interface *intf; 268 int i; 269 int retval = -ENOMEM; 270 bool int_in_found = false; 271 272 /* create our private serial structure */ 273 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 274 if (priv == NULL) { 275 dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__); 276 return -ENOMEM; 277 } 278 spin_lock_init(&priv->lock); 279 priv->serial = serial; 280 priv->port = serial->port[0]; 281 priv->udev = serial->dev; 282 283 /* find our interrupt endpoint */ 284 intf = serial->interface->altsetting; 285 for (i = 0; i < intf->desc.bNumEndpoints; ++i) { 286 struct usb_endpoint_descriptor *endpoint; 287 288 endpoint = &intf->endpoint[i].desc; 289 if (!usb_endpoint_is_int_in(endpoint)) 290 continue; 291 292 priv->int_urb = usb_alloc_urb(0, GFP_KERNEL); 293 if (!priv->int_urb) { 294 dev_err(&priv->udev->dev, "out of memory\n"); 295 goto error; 296 } 297 298 priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2; 299 priv->int_buffer = kmalloc(priv->buffer_size, GFP_KERNEL); 300 if (!priv->int_buffer) { 301 dev_err(&priv->udev->dev, "out of memory\n"); 302 goto error; 303 } 304 305 priv->int_address = endpoint->bEndpointAddress; 306 priv->bInterval = endpoint->bInterval; 307 308 /* set up our int urb */ 309 usb_fill_int_urb(priv->int_urb, priv->udev, 310 usb_rcvintpipe(priv->udev, 311 endpoint->bEndpointAddress), 312 priv->int_buffer, priv->buffer_size, 313 symbol_int_callback, priv, priv->bInterval); 314 315 int_in_found = true; 316 break; 317 } 318 319 if (!int_in_found) { 320 dev_err(&priv->udev->dev, 321 "Error - the proper endpoints were not found!\n"); 322 goto error; 323 } 324 325 usb_set_serial_data(serial, priv); 326 return 0; 327 328 error: 329 usb_free_urb(priv->int_urb); 330 kfree(priv->int_buffer); 331 kfree(priv); 332 return retval; 333 } 334 335 static void symbol_shutdown(struct usb_serial *serial) 336 { 337 struct symbol_private *priv = usb_get_serial_data(serial); 338 339 dbg("%s", __func__); 340 341 usb_kill_urb(priv->int_urb); 342 usb_free_urb(priv->int_urb); 343 kfree(priv->int_buffer); 344 kfree(priv); 345 usb_set_serial_data(serial, NULL); 346 } 347 348 static struct usb_driver symbol_driver = { 349 .name = "symbol", 350 .probe = usb_serial_probe, 351 .disconnect = usb_serial_disconnect, 352 .id_table = id_table, 353 .no_dynamic_id = 1, 354 }; 355 356 static struct usb_serial_driver symbol_device = { 357 .driver = { 358 .owner = THIS_MODULE, 359 .name = "symbol", 360 }, 361 .id_table = id_table, 362 .usb_driver = &symbol_driver, 363 .num_ports = 1, 364 .attach = symbol_startup, 365 .open = symbol_open, 366 .close = symbol_close, 367 .shutdown = symbol_shutdown, 368 .throttle = symbol_throttle, 369 .unthrottle = symbol_unthrottle, 370 .ioctl = symbol_ioctl, 371 .tiocmget = symbol_tiocmget, 372 .tiocmset = symbol_tiocmset, 373 }; 374 375 static int __init symbol_init(void) 376 { 377 int retval; 378 379 retval = usb_serial_register(&symbol_device); 380 if (retval) 381 return retval; 382 retval = usb_register(&symbol_driver); 383 if (retval) 384 usb_serial_deregister(&symbol_device); 385 return retval; 386 } 387 388 static void __exit symbol_exit(void) 389 { 390 usb_deregister(&symbol_driver); 391 usb_serial_deregister(&symbol_device); 392 } 393 394 module_init(symbol_init); 395 module_exit(symbol_exit); 396 MODULE_LICENSE("GPL"); 397 398 module_param(debug, bool, S_IRUGO | S_IWUSR); 399 MODULE_PARM_DESC(debug, "Debug enabled or not"); 400