1 /* 2 * USB Empeg empeg-car player driver 3 * 4 * Copyright (C) 2000, 2001 5 * Gary Brubaker (xavyer@ix.netcom.com) 6 * 7 * Copyright (C) 1999 - 2001 8 * Greg Kroah-Hartman (greg@kroah.com) 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License, as published by 12 * the Free Software Foundation, version 2. 13 * 14 * See Documentation/usb/usb-serial.txt for more information on using this 15 * driver 16 * 17 * (07/16/2001) gb 18 * remove unused code in empeg_close() (thanks to Oliver Neukum for 19 * pointing this out) and rewrote empeg_set_termios(). 20 * 21 * (05/30/2001) gkh 22 * switched from using spinlock to a semaphore, which fixes lots of 23 * problems. 24 * 25 * (04/08/2001) gb 26 * Identify version on module load. 27 * 28 * (01/22/2001) gb 29 * Added write_room() and chars_in_buffer() support. 30 * 31 * (12/21/2000) gb 32 * Moved termio stuff inside the port->active check. 33 * Moved MOD_DEC_USE_COUNT to end of empeg_close(). 34 * 35 * (12/03/2000) gb 36 * Added port->port.tty->ldisc.set_termios(port->port.tty, NULL) to 37 * empeg_open(). This notifies the tty driver that the termios have 38 * changed. 39 * 40 * (11/13/2000) gb 41 * Moved tty->low_latency = 1 from empeg_read_bulk_callback() to 42 * empeg_open() (It only needs to be set once - Doh!) 43 * 44 * (11/11/2000) gb 45 * Updated to work with id_table structure. 46 * 47 * (11/04/2000) gb 48 * Forked this from visor.c, and hacked it up to work with an 49 * Empeg ltd. empeg-car player. Constructive criticism welcomed. 50 * I would like to say, 'Thank You' to Greg Kroah-Hartman for the 51 * use of his code, and for his guidance, advice and patience. :) 52 * A 'Thank You' is in order for John Ripley of Empeg ltd for his 53 * advice, and patience too. 54 * 55 */ 56 57 #include <linux/kernel.h> 58 #include <linux/errno.h> 59 #include <linux/init.h> 60 #include <linux/slab.h> 61 #include <linux/tty.h> 62 #include <linux/tty_driver.h> 63 #include <linux/tty_flip.h> 64 #include <linux/module.h> 65 #include <linux/spinlock.h> 66 #include <linux/uaccess.h> 67 #include <linux/usb.h> 68 #include <linux/usb/serial.h> 69 70 static int debug; 71 72 /* 73 * Version Information 74 */ 75 #define DRIVER_VERSION "v1.2" 76 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Gary Brubaker <xavyer@ix.netcom.com>" 77 #define DRIVER_DESC "USB Empeg Mark I/II Driver" 78 79 #define EMPEG_VENDOR_ID 0x084f 80 #define EMPEG_PRODUCT_ID 0x0001 81 82 /* function prototypes for an empeg-car player */ 83 static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port, 84 struct file *filp); 85 static void empeg_close(struct tty_struct *tty, struct usb_serial_port *port, 86 struct file *filp); 87 static int empeg_write(struct tty_struct *tty, struct usb_serial_port *port, 88 const unsigned char *buf, 89 int count); 90 static int empeg_write_room(struct tty_struct *tty); 91 static int empeg_chars_in_buffer(struct tty_struct *tty); 92 static void empeg_throttle(struct tty_struct *tty); 93 static void empeg_unthrottle(struct tty_struct *tty); 94 static int empeg_startup(struct usb_serial *serial); 95 static void empeg_shutdown(struct usb_serial *serial); 96 static void empeg_set_termios(struct tty_struct *tty, 97 struct usb_serial_port *port, struct ktermios *old_termios); 98 static void empeg_write_bulk_callback(struct urb *urb); 99 static void empeg_read_bulk_callback(struct urb *urb); 100 101 static struct usb_device_id id_table [] = { 102 { USB_DEVICE(EMPEG_VENDOR_ID, EMPEG_PRODUCT_ID) }, 103 { } /* Terminating entry */ 104 }; 105 106 MODULE_DEVICE_TABLE(usb, id_table); 107 108 static struct usb_driver empeg_driver = { 109 .name = "empeg", 110 .probe = usb_serial_probe, 111 .disconnect = usb_serial_disconnect, 112 .id_table = id_table, 113 .no_dynamic_id = 1, 114 }; 115 116 static struct usb_serial_driver empeg_device = { 117 .driver = { 118 .owner = THIS_MODULE, 119 .name = "empeg", 120 }, 121 .id_table = id_table, 122 .usb_driver = &empeg_driver, 123 .num_ports = 1, 124 .open = empeg_open, 125 .close = empeg_close, 126 .throttle = empeg_throttle, 127 .unthrottle = empeg_unthrottle, 128 .attach = empeg_startup, 129 .shutdown = empeg_shutdown, 130 .set_termios = empeg_set_termios, 131 .write = empeg_write, 132 .write_room = empeg_write_room, 133 .chars_in_buffer = empeg_chars_in_buffer, 134 .write_bulk_callback = empeg_write_bulk_callback, 135 .read_bulk_callback = empeg_read_bulk_callback, 136 }; 137 138 #define NUM_URBS 16 139 #define URB_TRANSFER_BUFFER_SIZE 4096 140 141 static struct urb *write_urb_pool[NUM_URBS]; 142 static spinlock_t write_urb_pool_lock; 143 static int bytes_in; 144 static int bytes_out; 145 146 /****************************************************************************** 147 * Empeg specific driver functions 148 ******************************************************************************/ 149 static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port, 150 struct file *filp) 151 { 152 struct usb_serial *serial = port->serial; 153 int result = 0; 154 155 dbg("%s - port %d", __func__, port->number); 156 157 /* Force default termio settings */ 158 empeg_set_termios(tty, port, NULL) ; 159 160 bytes_in = 0; 161 bytes_out = 0; 162 163 /* Start reading from the device */ 164 usb_fill_bulk_urb( 165 port->read_urb, 166 serial->dev, 167 usb_rcvbulkpipe(serial->dev, 168 port->bulk_in_endpointAddress), 169 port->read_urb->transfer_buffer, 170 port->read_urb->transfer_buffer_length, 171 empeg_read_bulk_callback, 172 port); 173 174 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 175 176 if (result) 177 dev_err(&port->dev, 178 "%s - failed submitting read urb, error %d\n", 179 __func__, result); 180 181 return result; 182 } 183 184 185 static void empeg_close(struct tty_struct *tty, struct usb_serial_port *port, 186 struct file *filp) 187 { 188 dbg("%s - port %d", __func__, port->number); 189 190 /* shutdown our bulk read */ 191 usb_kill_urb(port->read_urb); 192 /* Uncomment the following line if you want to see some statistics in your syslog */ 193 /* dev_info (&port->dev, "Bytes In = %d Bytes Out = %d\n", bytes_in, bytes_out); */ 194 } 195 196 197 static int empeg_write(struct tty_struct *tty, struct usb_serial_port *port, 198 const unsigned char *buf, int count) 199 { 200 struct usb_serial *serial = port->serial; 201 struct urb *urb; 202 const unsigned char *current_position = buf; 203 unsigned long flags; 204 int status; 205 int i; 206 int bytes_sent = 0; 207 int transfer_size; 208 209 dbg("%s - port %d", __func__, port->number); 210 211 while (count > 0) { 212 /* try to find a free urb in our list of them */ 213 urb = NULL; 214 215 spin_lock_irqsave(&write_urb_pool_lock, flags); 216 217 for (i = 0; i < NUM_URBS; ++i) { 218 if (write_urb_pool[i]->status != -EINPROGRESS) { 219 urb = write_urb_pool[i]; 220 break; 221 } 222 } 223 224 spin_unlock_irqrestore(&write_urb_pool_lock, flags); 225 226 if (urb == NULL) { 227 dbg("%s - no more free urbs", __func__); 228 goto exit; 229 } 230 231 if (urb->transfer_buffer == NULL) { 232 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_ATOMIC); 233 if (urb->transfer_buffer == NULL) { 234 dev_err(&port->dev, 235 "%s no more kernel memory...\n", 236 __func__); 237 goto exit; 238 } 239 } 240 241 transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE); 242 243 memcpy(urb->transfer_buffer, current_position, transfer_size); 244 245 usb_serial_debug_data(debug, &port->dev, __func__, transfer_size, urb->transfer_buffer); 246 247 /* build up our urb */ 248 usb_fill_bulk_urb( 249 urb, 250 serial->dev, 251 usb_sndbulkpipe(serial->dev, 252 port->bulk_out_endpointAddress), 253 urb->transfer_buffer, 254 transfer_size, 255 empeg_write_bulk_callback, 256 port); 257 258 /* send it down the pipe */ 259 status = usb_submit_urb(urb, GFP_ATOMIC); 260 if (status) { 261 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed with status = %d\n", __func__, status); 262 bytes_sent = status; 263 break; 264 } 265 266 current_position += transfer_size; 267 bytes_sent += transfer_size; 268 count -= transfer_size; 269 bytes_out += transfer_size; 270 271 } 272 exit: 273 return bytes_sent; 274 } 275 276 277 static int empeg_write_room(struct tty_struct *tty) 278 { 279 struct usb_serial_port *port = tty->driver_data; 280 unsigned long flags; 281 int i; 282 int room = 0; 283 284 dbg("%s - port %d", __func__, port->number); 285 286 spin_lock_irqsave(&write_urb_pool_lock, flags); 287 /* tally up the number of bytes available */ 288 for (i = 0; i < NUM_URBS; ++i) { 289 if (write_urb_pool[i]->status != -EINPROGRESS) 290 room += URB_TRANSFER_BUFFER_SIZE; 291 } 292 spin_unlock_irqrestore(&write_urb_pool_lock, flags); 293 dbg("%s - returns %d", __func__, room); 294 return room; 295 296 } 297 298 299 static int empeg_chars_in_buffer(struct tty_struct *tty) 300 { 301 struct usb_serial_port *port = tty->driver_data; 302 unsigned long flags; 303 int i; 304 int chars = 0; 305 306 dbg("%s - port %d", __func__, port->number); 307 308 spin_lock_irqsave(&write_urb_pool_lock, flags); 309 310 /* tally up the number of bytes waiting */ 311 for (i = 0; i < NUM_URBS; ++i) { 312 if (write_urb_pool[i]->status == -EINPROGRESS) 313 chars += URB_TRANSFER_BUFFER_SIZE; 314 } 315 316 spin_unlock_irqrestore(&write_urb_pool_lock, flags); 317 dbg("%s - returns %d", __func__, chars); 318 return chars; 319 } 320 321 322 static void empeg_write_bulk_callback(struct urb *urb) 323 { 324 struct usb_serial_port *port = urb->context; 325 int status = urb->status; 326 327 dbg("%s - port %d", __func__, port->number); 328 329 if (status) { 330 dbg("%s - nonzero write bulk status received: %d", 331 __func__, status); 332 return; 333 } 334 335 usb_serial_port_softint(port); 336 } 337 338 339 static void empeg_read_bulk_callback(struct urb *urb) 340 { 341 struct usb_serial_port *port = urb->context; 342 struct tty_struct *tty; 343 unsigned char *data = urb->transfer_buffer; 344 int result; 345 int status = urb->status; 346 347 dbg("%s - port %d", __func__, port->number); 348 349 if (status) { 350 dbg("%s - nonzero read bulk status received: %d", 351 __func__, status); 352 return; 353 } 354 355 usb_serial_debug_data(debug, &port->dev, __func__, 356 urb->actual_length, data); 357 tty = port->port.tty; 358 359 if (urb->actual_length) { 360 tty_buffer_request_room(tty, urb->actual_length); 361 tty_insert_flip_string(tty, data, urb->actual_length); 362 tty_flip_buffer_push(tty); 363 bytes_in += urb->actual_length; 364 } 365 366 /* Continue trying to always read */ 367 usb_fill_bulk_urb( 368 port->read_urb, 369 port->serial->dev, 370 usb_rcvbulkpipe(port->serial->dev, 371 port->bulk_in_endpointAddress), 372 port->read_urb->transfer_buffer, 373 port->read_urb->transfer_buffer_length, 374 empeg_read_bulk_callback, 375 port); 376 377 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 378 379 if (result) 380 dev_err(&urb->dev->dev, 381 "%s - failed resubmitting read urb, error %d\n", 382 __func__, result); 383 384 return; 385 386 } 387 388 389 static void empeg_throttle(struct tty_struct *tty) 390 { 391 struct usb_serial_port *port = tty->driver_data; 392 dbg("%s - port %d", __func__, port->number); 393 usb_kill_urb(port->read_urb); 394 } 395 396 397 static void empeg_unthrottle(struct tty_struct *tty) 398 { 399 struct usb_serial_port *port = tty->driver_data; 400 int result; 401 dbg("%s - port %d", __func__, port->number); 402 403 port->read_urb->dev = port->serial->dev; 404 result = usb_submit_urb(port->read_urb, GFP_ATOMIC); 405 if (result) 406 dev_err(&port->dev, 407 "%s - failed submitting read urb, error %d\n", 408 __func__, result); 409 } 410 411 412 static int empeg_startup(struct usb_serial *serial) 413 { 414 int r; 415 416 dbg("%s", __func__); 417 418 if (serial->dev->actconfig->desc.bConfigurationValue != 1) { 419 err("active config #%d != 1 ??", 420 serial->dev->actconfig->desc.bConfigurationValue); 421 return -ENODEV; 422 } 423 dbg("%s - reset config", __func__); 424 r = usb_reset_configuration(serial->dev); 425 426 /* continue on with initialization */ 427 return r; 428 429 } 430 431 432 static void empeg_shutdown(struct usb_serial *serial) 433 { 434 dbg("%s", __func__); 435 } 436 437 438 static void empeg_set_termios(struct tty_struct *tty, 439 struct usb_serial_port *port, struct ktermios *old_termios) 440 { 441 struct ktermios *termios = tty->termios; 442 dbg("%s - port %d", __func__, port->number); 443 444 /* 445 * The empeg-car player wants these particular tty settings. 446 * You could, for example, change the baud rate, however the 447 * player only supports 115200 (currently), so there is really 448 * no point in support for changes to the tty settings. 449 * (at least for now) 450 * 451 * The default requirements for this device are: 452 */ 453 termios->c_iflag 454 &= ~(IGNBRK /* disable ignore break */ 455 | BRKINT /* disable break causes interrupt */ 456 | PARMRK /* disable mark parity errors */ 457 | ISTRIP /* disable clear high bit of input characters */ 458 | INLCR /* disable translate NL to CR */ 459 | IGNCR /* disable ignore CR */ 460 | ICRNL /* disable translate CR to NL */ 461 | IXON); /* disable enable XON/XOFF flow control */ 462 463 termios->c_oflag 464 &= ~OPOST; /* disable postprocess output characters */ 465 466 termios->c_lflag 467 &= ~(ECHO /* disable echo input characters */ 468 | ECHONL /* disable echo new line */ 469 | ICANON /* disable erase, kill, werase, and rprnt special characters */ 470 | ISIG /* disable interrupt, quit, and suspend special characters */ 471 | IEXTEN); /* disable non-POSIX special characters */ 472 473 termios->c_cflag 474 &= ~(CSIZE /* no size */ 475 | PARENB /* disable parity bit */ 476 | CBAUD); /* clear current baud rate */ 477 478 termios->c_cflag 479 |= CS8; /* character size 8 bits */ 480 481 /* 482 * Force low_latency on; otherwise the pushes are scheduled; 483 * this is bad as it opens up the possibility of dropping bytes 484 * on the floor. We don't want to drop bytes on the floor. :) 485 */ 486 tty->low_latency = 1; 487 tty_encode_baud_rate(tty, 115200, 115200); 488 } 489 490 491 static int __init empeg_init(void) 492 { 493 struct urb *urb; 494 int i, retval; 495 496 /* create our write urb pool and transfer buffers */ 497 spin_lock_init(&write_urb_pool_lock); 498 for (i = 0; i < NUM_URBS; ++i) { 499 urb = usb_alloc_urb(0, GFP_KERNEL); 500 write_urb_pool[i] = urb; 501 if (urb == NULL) { 502 err("No more urbs???"); 503 continue; 504 } 505 506 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE, 507 GFP_KERNEL); 508 if (!urb->transfer_buffer) { 509 err("%s - out of memory for urb buffers.", 510 __func__); 511 continue; 512 } 513 } 514 515 retval = usb_serial_register(&empeg_device); 516 if (retval) 517 goto failed_usb_serial_register; 518 retval = usb_register(&empeg_driver); 519 if (retval) 520 goto failed_usb_register; 521 522 info(DRIVER_VERSION ":" DRIVER_DESC); 523 524 return 0; 525 failed_usb_register: 526 usb_serial_deregister(&empeg_device); 527 failed_usb_serial_register: 528 for (i = 0; i < NUM_URBS; ++i) { 529 if (write_urb_pool[i]) { 530 kfree(write_urb_pool[i]->transfer_buffer); 531 usb_free_urb(write_urb_pool[i]); 532 } 533 } 534 return retval; 535 } 536 537 538 static void __exit empeg_exit(void) 539 { 540 int i; 541 unsigned long flags; 542 543 usb_deregister(&empeg_driver); 544 usb_serial_deregister(&empeg_device); 545 546 spin_lock_irqsave(&write_urb_pool_lock, flags); 547 548 for (i = 0; i < NUM_URBS; ++i) { 549 if (write_urb_pool[i]) { 550 /* FIXME - uncomment the following usb_kill_urb call 551 * when the host controllers get fixed to set urb->dev 552 * = NULL after the urb is finished. Otherwise this 553 * call oopses. */ 554 /* usb_kill_urb(write_urb_pool[i]); */ 555 kfree(write_urb_pool[i]->transfer_buffer); 556 usb_free_urb(write_urb_pool[i]); 557 } 558 } 559 spin_unlock_irqrestore(&write_urb_pool_lock, flags); 560 } 561 562 563 module_init(empeg_init); 564 module_exit(empeg_exit); 565 566 MODULE_AUTHOR(DRIVER_AUTHOR); 567 MODULE_DESCRIPTION(DRIVER_DESC); 568 MODULE_LICENSE("GPL"); 569 570 module_param(debug, bool, S_IRUGO | S_IWUSR); 571 MODULE_PARM_DESC(debug, "Debug enabled or not"); 572