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