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