1 /* 2 * Opticon USB barcode to serial driver 3 * 4 * Copyright (C) 2011 - 2012 Johan Hovold <jhovold@gmail.com> 5 * Copyright (C) 2011 Martin Jansen <martin.jansen@opticon.com> 6 * Copyright (C) 2008 - 2009 Greg Kroah-Hartman <gregkh@suse.de> 7 * Copyright (C) 2008 - 2009 Novell Inc. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License version 11 * 2 as published by the Free Software Foundation. 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/init.h> 16 #include <linux/tty.h> 17 #include <linux/tty_driver.h> 18 #include <linux/slab.h> 19 #include <linux/tty_flip.h> 20 #include <linux/serial.h> 21 #include <linux/module.h> 22 #include <linux/usb.h> 23 #include <linux/usb/serial.h> 24 #include <linux/uaccess.h> 25 26 #define CONTROL_RTS 0x02 27 #define RESEND_CTS_STATE 0x03 28 29 /* max number of write urbs in flight */ 30 #define URB_UPPER_LIMIT 8 31 32 /* This driver works for the Opticon 1D barcode reader 33 * an examples of 1D barcode types are EAN, UPC, Code39, IATA etc.. */ 34 #define DRIVER_DESC "Opticon USB barcode to serial driver (1D)" 35 36 static const struct usb_device_id id_table[] = { 37 { USB_DEVICE(0x065a, 0x0009) }, 38 { }, 39 }; 40 MODULE_DEVICE_TABLE(usb, id_table); 41 42 /* This structure holds all of the individual device information */ 43 struct opticon_private { 44 spinlock_t lock; /* protects the following flags */ 45 bool rts; 46 bool cts; 47 int outstanding_urbs; 48 }; 49 50 51 static void opticon_process_data_packet(struct usb_serial_port *port, 52 const unsigned char *buf, size_t len) 53 { 54 struct tty_struct *tty; 55 56 tty = tty_port_tty_get(&port->port); 57 if (!tty) 58 return; 59 60 tty_insert_flip_string(tty, buf, len); 61 tty_flip_buffer_push(tty); 62 tty_kref_put(tty); 63 } 64 65 static void opticon_process_status_packet(struct usb_serial_port *port, 66 const unsigned char *buf, size_t len) 67 { 68 struct opticon_private *priv = usb_get_serial_port_data(port); 69 unsigned long flags; 70 71 spin_lock_irqsave(&priv->lock, flags); 72 if (buf[0] == 0x00) 73 priv->cts = false; 74 else 75 priv->cts = true; 76 spin_unlock_irqrestore(&priv->lock, flags); 77 } 78 79 static void opticon_process_read_urb(struct urb *urb) 80 { 81 struct usb_serial_port *port = urb->context; 82 const unsigned char *hdr = urb->transfer_buffer; 83 const unsigned char *data = hdr + 2; 84 size_t data_len = urb->actual_length - 2; 85 86 if (urb->actual_length <= 2) { 87 dev_dbg(&port->dev, "malformed packet received: %d bytes\n", 88 urb->actual_length); 89 return; 90 } 91 /* 92 * Data from the device comes with a 2 byte header: 93 * 94 * <0x00><0x00>data... 95 * This is real data to be sent to the tty layer 96 * <0x00><0x01>level 97 * This is a CTS level change, the third byte is the CTS 98 * value (0 for low, 1 for high). 99 */ 100 if ((hdr[0] == 0x00) && (hdr[1] == 0x00)) { 101 opticon_process_data_packet(port, data, data_len); 102 } else if ((hdr[0] == 0x00) && (hdr[1] == 0x01)) { 103 opticon_process_status_packet(port, data, data_len); 104 } else { 105 dev_dbg(&port->dev, "unknown packet received: %02x %02x\n", 106 hdr[0], hdr[1]); 107 } 108 } 109 110 static int send_control_msg(struct usb_serial_port *port, u8 requesttype, 111 u8 val) 112 { 113 struct usb_serial *serial = port->serial; 114 int retval; 115 u8 *buffer; 116 117 buffer = kzalloc(1, GFP_KERNEL); 118 if (!buffer) 119 return -ENOMEM; 120 121 buffer[0] = val; 122 /* Send the message to the vendor control endpoint 123 * of the connected device */ 124 retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 125 requesttype, 126 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE, 127 0, 0, buffer, 1, 0); 128 kfree(buffer); 129 130 return retval; 131 } 132 133 static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port) 134 { 135 struct opticon_private *priv = usb_get_serial_port_data(port); 136 unsigned long flags; 137 int res; 138 139 spin_lock_irqsave(&priv->lock, flags); 140 priv->rts = false; 141 spin_unlock_irqrestore(&priv->lock, flags); 142 143 /* Clear RTS line */ 144 send_control_msg(port, CONTROL_RTS, 0); 145 146 /* clear the halt status of the enpoint */ 147 usb_clear_halt(port->serial->dev, port->read_urb->pipe); 148 149 res = usb_serial_generic_open(tty, port); 150 if (!res) 151 return res; 152 153 /* Request CTS line state, sometimes during opening the current 154 * CTS state can be missed. */ 155 send_control_msg(port, RESEND_CTS_STATE, 1); 156 157 return res; 158 } 159 160 static void opticon_write_control_callback(struct urb *urb) 161 { 162 struct usb_serial_port *port = urb->context; 163 struct opticon_private *priv = usb_get_serial_port_data(port); 164 int status = urb->status; 165 unsigned long flags; 166 167 /* free up the transfer buffer, as usb_free_urb() does not do this */ 168 kfree(urb->transfer_buffer); 169 170 /* setup packet may be set if we're using it for writing */ 171 kfree(urb->setup_packet); 172 173 if (status) 174 dev_dbg(&port->dev, 175 "%s - non-zero urb status received: %d\n", 176 __func__, status); 177 178 spin_lock_irqsave(&priv->lock, flags); 179 --priv->outstanding_urbs; 180 spin_unlock_irqrestore(&priv->lock, flags); 181 182 usb_serial_port_softint(port); 183 } 184 185 static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port, 186 const unsigned char *buf, int count) 187 { 188 struct opticon_private *priv = usb_get_serial_port_data(port); 189 struct usb_serial *serial = port->serial; 190 struct urb *urb; 191 unsigned char *buffer; 192 unsigned long flags; 193 int status; 194 struct usb_ctrlrequest *dr; 195 196 spin_lock_irqsave(&priv->lock, flags); 197 if (priv->outstanding_urbs > URB_UPPER_LIMIT) { 198 spin_unlock_irqrestore(&priv->lock, flags); 199 dev_dbg(&port->dev, "%s - write limit hit\n", __func__); 200 return 0; 201 } 202 priv->outstanding_urbs++; 203 spin_unlock_irqrestore(&priv->lock, flags); 204 205 buffer = kmalloc(count, GFP_ATOMIC); 206 if (!buffer) { 207 dev_err(&port->dev, "out of memory\n"); 208 count = -ENOMEM; 209 210 goto error_no_buffer; 211 } 212 213 urb = usb_alloc_urb(0, GFP_ATOMIC); 214 if (!urb) { 215 dev_err(&port->dev, "no more free urbs\n"); 216 count = -ENOMEM; 217 goto error_no_urb; 218 } 219 220 memcpy(buffer, buf, count); 221 222 usb_serial_debug_data(&port->dev, __func__, count, buffer); 223 224 /* The conncected devices do not have a bulk write endpoint, 225 * to transmit data to de barcode device the control endpoint is used */ 226 dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO); 227 if (!dr) { 228 dev_err(&port->dev, "out of memory\n"); 229 count = -ENOMEM; 230 goto error_no_dr; 231 } 232 233 dr->bRequestType = USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT; 234 dr->bRequest = 0x01; 235 dr->wValue = 0; 236 dr->wIndex = 0; 237 dr->wLength = cpu_to_le16(count); 238 239 usb_fill_control_urb(urb, serial->dev, 240 usb_sndctrlpipe(serial->dev, 0), 241 (unsigned char *)dr, buffer, count, 242 opticon_write_control_callback, port); 243 244 /* send it down the pipe */ 245 status = usb_submit_urb(urb, GFP_ATOMIC); 246 if (status) { 247 dev_err(&port->dev, 248 "%s - usb_submit_urb(write endpoint) failed status = %d\n", 249 __func__, status); 250 count = status; 251 goto error; 252 } 253 254 /* we are done with this urb, so let the host driver 255 * really free it when it is finished with it */ 256 usb_free_urb(urb); 257 258 return count; 259 error: 260 kfree(dr); 261 error_no_dr: 262 usb_free_urb(urb); 263 error_no_urb: 264 kfree(buffer); 265 error_no_buffer: 266 spin_lock_irqsave(&priv->lock, flags); 267 --priv->outstanding_urbs; 268 spin_unlock_irqrestore(&priv->lock, flags); 269 return count; 270 } 271 272 static int opticon_write_room(struct tty_struct *tty) 273 { 274 struct usb_serial_port *port = tty->driver_data; 275 struct opticon_private *priv = usb_get_serial_port_data(port); 276 unsigned long flags; 277 278 /* 279 * We really can take almost anything the user throws at us 280 * but let's pick a nice big number to tell the tty 281 * layer that we have lots of free space, unless we don't. 282 */ 283 spin_lock_irqsave(&priv->lock, flags); 284 if (priv->outstanding_urbs > URB_UPPER_LIMIT * 2 / 3) { 285 spin_unlock_irqrestore(&priv->lock, flags); 286 dev_dbg(&port->dev, "%s - write limit hit\n", __func__); 287 return 0; 288 } 289 spin_unlock_irqrestore(&priv->lock, flags); 290 291 return 2048; 292 } 293 294 static int opticon_tiocmget(struct tty_struct *tty) 295 { 296 struct usb_serial_port *port = tty->driver_data; 297 struct opticon_private *priv = usb_get_serial_port_data(port); 298 unsigned long flags; 299 int result = 0; 300 301 spin_lock_irqsave(&priv->lock, flags); 302 if (priv->rts) 303 result |= TIOCM_RTS; 304 if (priv->cts) 305 result |= TIOCM_CTS; 306 spin_unlock_irqrestore(&priv->lock, flags); 307 308 dev_dbg(&port->dev, "%s - %x\n", __func__, result); 309 return result; 310 } 311 312 static int opticon_tiocmset(struct tty_struct *tty, 313 unsigned int set, unsigned int clear) 314 { 315 struct usb_serial_port *port = tty->driver_data; 316 struct usb_serial *serial = port->serial; 317 struct opticon_private *priv = usb_get_serial_port_data(port); 318 unsigned long flags; 319 bool rts; 320 bool changed = false; 321 int ret; 322 323 /* We only support RTS so we only handle that */ 324 spin_lock_irqsave(&priv->lock, flags); 325 326 rts = priv->rts; 327 if (set & TIOCM_RTS) 328 priv->rts = true; 329 if (clear & TIOCM_RTS) 330 priv->rts = false; 331 changed = rts ^ priv->rts; 332 spin_unlock_irqrestore(&priv->lock, flags); 333 334 if (!changed) 335 return 0; 336 337 /* Send the new RTS state to the connected device */ 338 mutex_lock(&serial->disc_mutex); 339 if (!serial->disconnected) 340 ret = send_control_msg(port, CONTROL_RTS, !rts); 341 else 342 ret = -ENODEV; 343 mutex_unlock(&serial->disc_mutex); 344 345 return ret; 346 } 347 348 static int get_serial_info(struct usb_serial_port *port, 349 struct serial_struct __user *serial) 350 { 351 struct serial_struct tmp; 352 353 if (!serial) 354 return -EFAULT; 355 356 memset(&tmp, 0x00, sizeof(tmp)); 357 358 /* fake emulate a 16550 uart to make userspace code happy */ 359 tmp.type = PORT_16550A; 360 tmp.line = port->serial->minor; 361 tmp.port = 0; 362 tmp.irq = 0; 363 tmp.flags = ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ; 364 tmp.xmit_fifo_size = 1024; 365 tmp.baud_base = 9600; 366 tmp.close_delay = 5*HZ; 367 tmp.closing_wait = 30*HZ; 368 369 if (copy_to_user(serial, &tmp, sizeof(*serial))) 370 return -EFAULT; 371 return 0; 372 } 373 374 static int opticon_ioctl(struct tty_struct *tty, 375 unsigned int cmd, unsigned long arg) 376 { 377 struct usb_serial_port *port = tty->driver_data; 378 379 dev_dbg(&port->dev, "%s - port %d, cmd = 0x%x\n", __func__, port->number, cmd); 380 381 switch (cmd) { 382 case TIOCGSERIAL: 383 return get_serial_info(port, 384 (struct serial_struct __user *)arg); 385 } 386 387 return -ENOIOCTLCMD; 388 } 389 390 static int opticon_startup(struct usb_serial *serial) 391 { 392 if (!serial->num_bulk_in) { 393 dev_err(&serial->dev->dev, "no bulk in endpoint\n"); 394 return -ENODEV; 395 } 396 397 return 0; 398 } 399 400 static int opticon_port_probe(struct usb_serial_port *port) 401 { 402 struct opticon_private *priv; 403 404 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 405 if (!priv) 406 return -ENOMEM; 407 408 spin_lock_init(&priv->lock); 409 410 usb_set_serial_port_data(port, priv); 411 412 return 0; 413 } 414 415 static int opticon_port_remove(struct usb_serial_port *port) 416 { 417 struct opticon_private *priv = usb_get_serial_port_data(port); 418 419 kfree(priv); 420 421 return 0; 422 } 423 424 static struct usb_serial_driver opticon_device = { 425 .driver = { 426 .owner = THIS_MODULE, 427 .name = "opticon", 428 }, 429 .id_table = id_table, 430 .num_ports = 1, 431 .bulk_in_size = 256, 432 .attach = opticon_startup, 433 .port_probe = opticon_port_probe, 434 .port_remove = opticon_port_remove, 435 .open = opticon_open, 436 .write = opticon_write, 437 .write_room = opticon_write_room, 438 .throttle = usb_serial_generic_throttle, 439 .unthrottle = usb_serial_generic_unthrottle, 440 .ioctl = opticon_ioctl, 441 .tiocmget = opticon_tiocmget, 442 .tiocmset = opticon_tiocmset, 443 .process_read_urb = opticon_process_read_urb, 444 }; 445 446 static struct usb_serial_driver * const serial_drivers[] = { 447 &opticon_device, NULL 448 }; 449 450 module_usb_serial_driver(serial_drivers, id_table); 451 452 MODULE_DESCRIPTION(DRIVER_DESC); 453 MODULE_LICENSE("GPL"); 454