1 /* 2 * Digi AccelePort USB-4 and USB-2 Serial Converters 3 * 4 * Copyright 2000 by Digi International 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * Shamelessly based on Brian Warner's keyspan_pda.c and Greg Kroah-Hartman's 12 * usb-serial driver. 13 * 14 * Peter Berger (pberger@brimson.com) 15 * Al Borchers (borchers@steinerpoint.com) 16 * 17 * (12/03/2001) gkh 18 * switched to using port->open_count instead of private version. 19 * Removed port->active 20 * 21 * (04/08/2001) gb 22 * Identify version on module load. 23 * 24 * (11/01/2000) Adam J. Richter 25 * usb_device_id table support 26 * 27 * (11/01/2000) pberger and borchers 28 * -- Turned off the USB_DISABLE_SPD flag for write bulk urbs--it caused 29 * USB 4 ports to hang on startup. 30 * -- Serialized access to write urbs by adding the dp_write_urb_in_use 31 * flag; otherwise, the driver caused SMP system hangs. Watching the 32 * urb status is not sufficient. 33 * 34 * (10/05/2000) gkh 35 * -- Fixed bug with urb->dev not being set properly, now that the usb 36 * core needs it. 37 * 38 * (8/8/2000) pberger and borchers 39 * -- Fixed close so that 40 * - it can timeout while waiting for transmit idle, if needed; 41 * - it ignores interrupts when flushing the port, turning 42 * of modem signalling, and so on; 43 * - it waits for the flush to really complete before returning. 44 * -- Read_bulk_callback and write_bulk_callback check for a closed 45 * port before using the tty struct or writing to the port. 46 * -- The two changes above fix the oops caused by interrupted closes. 47 * -- Added interruptible args to write_oob_command and set_modem_signals 48 * and added a timeout arg to transmit_idle; needed for fixes to 49 * close. 50 * -- Added code for rx_throttle and rx_unthrottle so that input flow 51 * control works. 52 * -- Added code to set overrun, parity, framing, and break errors 53 * (untested). 54 * -- Set USB_DISABLE_SPD flag for write bulk urbs, so no 0 length 55 * bulk writes are done. These hung the Digi USB device. The 56 * 0 length bulk writes were a new feature of usb-uhci added in 57 * the 2.4.0-test6 kernels. 58 * -- Fixed mod inc race in open; do mod inc before sleeping to wait 59 * for a close to finish. 60 * 61 * (7/31/2000) pberger 62 * -- Fixed bugs with hardware handshaking: 63 * - Added code to set/clear tty->hw_stopped in digi_read_oob_callback() 64 * and digi_set_termios() 65 * -- Added code in digi_set_termios() to 66 * - add conditional in code handling transition from B0 to only 67 * set RTS if RTS/CTS flow control is either not in use or if 68 * the port is not currently throttled. 69 * - handle turning off CRTSCTS. 70 * 71 * (7/30/2000) borchers 72 * -- Added support for more than one Digi USB device by moving 73 * globals to a private structure in the pointed to from the 74 * usb_serial structure. 75 * -- Moved the modem change and transmit idle wait queues into 76 * the port private structure, so each port has its own queue 77 * rather than sharing global queues. 78 * -- Added support for break signals. 79 * 80 * (7/25/2000) pberger 81 * -- Added USB-2 support. Note: the USB-2 supports 3 devices: two 82 * serial and a parallel port. The parallel port is implemented 83 * as a serial-to-parallel converter. That is, the driver actually 84 * presents all three USB-2 interfaces as serial ports, but the third 85 * one physically connects to a parallel device. Thus, for example, 86 * one could plug a parallel printer into the USB-2's third port, 87 * but from the kernel's (and userland's) point of view what's 88 * actually out there is a serial device. 89 * 90 * (7/15/2000) borchers 91 * -- Fixed race in open when a close is in progress. 92 * -- Keep count of opens and dec the module use count for each 93 * outstanding open when shutdown is called (on disconnect). 94 * -- Fixed sanity checks in read_bulk_callback and write_bulk_callback 95 * so pointers are checked before use. 96 * -- Split read bulk callback into in band and out of band 97 * callbacks, and no longer restart read chains if there is 98 * a status error or a sanity error. This fixed the seg 99 * faults and other errors we used to get on disconnect. 100 * -- Port->active is once again a flag as usb-serial intended it 101 * to be, not a count. Since it was only a char it would 102 * have been limited to 256 simultaneous opens. Now the open 103 * count is kept in the port private structure in dp_open_count. 104 * -- Added code for modularization of the digi_acceleport driver. 105 * 106 * (6/27/2000) pberger and borchers 107 * -- Zeroed out sync field in the wakeup_task before first use; 108 * otherwise the uninitialized value might prevent the task from 109 * being scheduled. 110 * -- Initialized ret value to 0 in write_bulk_callback, otherwise 111 * the uninitialized value could cause a spurious debugging message. 112 * 113 * (6/22/2000) pberger and borchers 114 * -- Made cond_wait_... inline--apparently on SPARC the flags arg 115 * to spin_lock_irqsave cannot be passed to another function 116 * to call spin_unlock_irqrestore. Thanks to Pauline Middelink. 117 * -- In digi_set_modem_signals the inner nested spin locks use just 118 * spin_lock() rather than spin_lock_irqsave(). The old code 119 * mistakenly left interrupts off. Thanks to Pauline Middelink. 120 * -- copy_from_user (which can sleep) is no longer called while a 121 * spinlock is held. We copy to a local buffer before getting 122 * the spinlock--don't like the extra copy but the code is simpler. 123 * -- Printk and dbg are no longer called while a spin lock is held. 124 * 125 * (6/4/2000) pberger and borchers 126 * -- Replaced separate calls to spin_unlock_irqrestore and 127 * interruptible_sleep_on_timeout with a new function 128 * cond_wait_interruptible_timeout_irqrestore. This eliminates 129 * the race condition where the wake up could happen after 130 * the unlock and before the sleep. 131 * -- Close now waits for output to drain. 132 * -- Open waits until any close in progress is finished. 133 * -- All out of band responses are now processed, not just the 134 * first in a USB packet. 135 * -- Fixed a bug that prevented the driver from working when the 136 * first Digi port was not the first USB serial port--the driver 137 * was mistakenly using the external USB serial port number to 138 * try to index into its internal ports. 139 * -- Fixed an SMP bug -- write_bulk_callback is called directly from 140 * an interrupt, so spin_lock_irqsave/spin_unlock_irqrestore are 141 * needed for locks outside write_bulk_callback that are also 142 * acquired by write_bulk_callback to prevent deadlocks. 143 * -- Fixed support for select() by making digi_chars_in_buffer() 144 * return 256 when -EINPROGRESS is set, as the line discipline 145 * code in n_tty.c expects. 146 * -- Fixed an include file ordering problem that prevented debugging 147 * messages from working. 148 * -- Fixed an intermittent timeout problem that caused writes to 149 * sometimes get stuck on some machines on some kernels. It turns 150 * out in these circumstances write_chan() (in n_tty.c) was 151 * asleep waiting for our wakeup call. Even though we call 152 * wake_up_interruptible() in digi_write_bulk_callback(), there is 153 * a race condition that could cause the wakeup to fail: if our 154 * wake_up_interruptible() call occurs between the time that our 155 * driver write routine finishes and write_chan() sets current->state 156 * to TASK_INTERRUPTIBLE, the effect of our wakeup setting the state 157 * to TASK_RUNNING will be lost and write_chan's subsequent call to 158 * schedule() will never return (unless it catches a signal). 159 * This race condition occurs because write_bulk_callback() (and thus 160 * the wakeup) are called asynchronously from an interrupt, rather than 161 * from the scheduler. We can avoid the race by calling the wakeup 162 * from the scheduler queue and that's our fix: Now, at the end of 163 * write_bulk_callback() we queue up a wakeup call on the scheduler 164 * task queue. We still also invoke the wakeup directly since that 165 * squeezes a bit more performance out of the driver, and any lost 166 * race conditions will get cleaned up at the next scheduler run. 167 * 168 * NOTE: The problem also goes away if you comment out 169 * the two code lines in write_chan() where current->state 170 * is set to TASK_RUNNING just before calling driver.write() and to 171 * TASK_INTERRUPTIBLE immediately afterwards. This is why the 172 * problem did not show up with the 2.2 kernels -- they do not 173 * include that code. 174 * 175 * (5/16/2000) pberger and borchers 176 * -- Added timeouts to sleeps, to defend against lost wake ups. 177 * -- Handle transition to/from B0 baud rate in digi_set_termios. 178 * 179 * (5/13/2000) pberger and borchers 180 * -- All commands now sent on out of band port, using 181 * digi_write_oob_command. 182 * -- Get modem control signals whenever they change, support TIOCMGET/ 183 * SET/BIS/BIC ioctls. 184 * -- digi_set_termios now supports parity, word size, stop bits, and 185 * receive enable. 186 * -- Cleaned up open and close, use digi_set_termios and 187 * digi_write_oob_command to set port parameters. 188 * -- Added digi_startup_device to start read chains on all ports. 189 * -- Write buffer is only used when count==1, to be sure put_char can 190 * write a char (unless the buffer is full). 191 * 192 * (5/10/2000) pberger and borchers 193 * -- Added MOD_INC_USE_COUNT/MOD_DEC_USE_COUNT calls on open/close. 194 * -- Fixed problem where the first incoming character is lost on 195 * port opens after the first close on that port. Now we keep 196 * the read_urb chain open until shutdown. 197 * -- Added more port conditioning calls in digi_open and digi_close. 198 * -- Convert port->active to a use count so that we can deal with multiple 199 * opens and closes properly. 200 * -- Fixed some problems with the locking code. 201 * 202 * (5/3/2000) pberger and borchers 203 * -- First alpha version of the driver--many known limitations and bugs. 204 * 205 * 206 * Locking and SMP 207 * 208 * - Each port, including the out-of-band port, has a lock used to 209 * serialize all access to the port's private structure. 210 * - The port lock is also used to serialize all writes and access to 211 * the port's URB. 212 * - The port lock is also used for the port write_wait condition 213 * variable. Holding the port lock will prevent a wake up on the 214 * port's write_wait; this can be used with cond_wait_... to be sure 215 * the wake up is not lost in a race when dropping the lock and 216 * sleeping waiting for the wakeup. 217 * - digi_write() does not sleep, since it is sometimes called on 218 * interrupt time. 219 * - digi_write_bulk_callback() and digi_read_bulk_callback() are 220 * called directly from interrupts. Hence spin_lock_irqsave() 221 * and spin_unlock_irqrestore() are used in the rest of the code 222 * for any locks they acquire. 223 * - digi_write_bulk_callback() gets the port lock before waking up 224 * processes sleeping on the port write_wait. It also schedules 225 * wake ups so they happen from the scheduler, because the tty 226 * system can miss wake ups from interrupts. 227 * - All sleeps use a timeout of DIGI_RETRY_TIMEOUT before looping to 228 * recheck the condition they are sleeping on. This is defensive, 229 * in case a wake up is lost. 230 * - Following Documentation/DocBook/kernel-locking.pdf no spin locks 231 * are held when calling copy_to/from_user or printk. 232 * 233 * $Id: digi_acceleport.c,v 1.80.1.2 2000/11/02 05:45:08 root Exp $ 234 */ 235 236 #include <linux/kernel.h> 237 #include <linux/errno.h> 238 #include <linux/init.h> 239 #include <linux/slab.h> 240 #include <linux/tty.h> 241 #include <linux/tty_driver.h> 242 #include <linux/tty_flip.h> 243 #include <linux/module.h> 244 #include <linux/spinlock.h> 245 #include <linux/workqueue.h> 246 #include <asm/uaccess.h> 247 #include <linux/usb.h> 248 #include <linux/wait.h> 249 #include <linux/usb/serial.h> 250 251 /* Defines */ 252 253 /* 254 * Version Information 255 */ 256 #define DRIVER_VERSION "v1.80.1.2" 257 #define DRIVER_AUTHOR "Peter Berger <pberger@brimson.com>, Al Borchers <borchers@steinerpoint.com>" 258 #define DRIVER_DESC "Digi AccelePort USB-2/USB-4 Serial Converter driver" 259 260 /* port output buffer length -- must be <= transfer buffer length - 2 */ 261 /* so we can be sure to send the full buffer in one urb */ 262 #define DIGI_OUT_BUF_SIZE 8 263 264 /* port input buffer length -- must be >= transfer buffer length - 3 */ 265 /* so we can be sure to hold at least one full buffer from one urb */ 266 #define DIGI_IN_BUF_SIZE 64 267 268 /* retry timeout while sleeping */ 269 #define DIGI_RETRY_TIMEOUT (HZ/10) 270 271 /* timeout while waiting for tty output to drain in close */ 272 /* this delay is used twice in close, so the total delay could */ 273 /* be twice this value */ 274 #define DIGI_CLOSE_TIMEOUT (5*HZ) 275 276 277 /* AccelePort USB Defines */ 278 279 /* ids */ 280 #define DIGI_VENDOR_ID 0x05c5 281 #define DIGI_2_ID 0x0002 /* USB-2 */ 282 #define DIGI_4_ID 0x0004 /* USB-4 */ 283 284 /* commands 285 * "INB": can be used on the in-band endpoint 286 * "OOB": can be used on the out-of-band endpoint 287 */ 288 #define DIGI_CMD_SET_BAUD_RATE 0 /* INB, OOB */ 289 #define DIGI_CMD_SET_WORD_SIZE 1 /* INB, OOB */ 290 #define DIGI_CMD_SET_PARITY 2 /* INB, OOB */ 291 #define DIGI_CMD_SET_STOP_BITS 3 /* INB, OOB */ 292 #define DIGI_CMD_SET_INPUT_FLOW_CONTROL 4 /* INB, OOB */ 293 #define DIGI_CMD_SET_OUTPUT_FLOW_CONTROL 5 /* INB, OOB */ 294 #define DIGI_CMD_SET_DTR_SIGNAL 6 /* INB, OOB */ 295 #define DIGI_CMD_SET_RTS_SIGNAL 7 /* INB, OOB */ 296 #define DIGI_CMD_READ_INPUT_SIGNALS 8 /* OOB */ 297 #define DIGI_CMD_IFLUSH_FIFO 9 /* OOB */ 298 #define DIGI_CMD_RECEIVE_ENABLE 10 /* INB, OOB */ 299 #define DIGI_CMD_BREAK_CONTROL 11 /* INB, OOB */ 300 #define DIGI_CMD_LOCAL_LOOPBACK 12 /* INB, OOB */ 301 #define DIGI_CMD_TRANSMIT_IDLE 13 /* INB, OOB */ 302 #define DIGI_CMD_READ_UART_REGISTER 14 /* OOB */ 303 #define DIGI_CMD_WRITE_UART_REGISTER 15 /* INB, OOB */ 304 #define DIGI_CMD_AND_UART_REGISTER 16 /* INB, OOB */ 305 #define DIGI_CMD_OR_UART_REGISTER 17 /* INB, OOB */ 306 #define DIGI_CMD_SEND_DATA 18 /* INB */ 307 #define DIGI_CMD_RECEIVE_DATA 19 /* INB */ 308 #define DIGI_CMD_RECEIVE_DISABLE 20 /* INB */ 309 #define DIGI_CMD_GET_PORT_TYPE 21 /* OOB */ 310 311 /* baud rates */ 312 #define DIGI_BAUD_50 0 313 #define DIGI_BAUD_75 1 314 #define DIGI_BAUD_110 2 315 #define DIGI_BAUD_150 3 316 #define DIGI_BAUD_200 4 317 #define DIGI_BAUD_300 5 318 #define DIGI_BAUD_600 6 319 #define DIGI_BAUD_1200 7 320 #define DIGI_BAUD_1800 8 321 #define DIGI_BAUD_2400 9 322 #define DIGI_BAUD_4800 10 323 #define DIGI_BAUD_7200 11 324 #define DIGI_BAUD_9600 12 325 #define DIGI_BAUD_14400 13 326 #define DIGI_BAUD_19200 14 327 #define DIGI_BAUD_28800 15 328 #define DIGI_BAUD_38400 16 329 #define DIGI_BAUD_57600 17 330 #define DIGI_BAUD_76800 18 331 #define DIGI_BAUD_115200 19 332 #define DIGI_BAUD_153600 20 333 #define DIGI_BAUD_230400 21 334 #define DIGI_BAUD_460800 22 335 336 /* arguments */ 337 #define DIGI_WORD_SIZE_5 0 338 #define DIGI_WORD_SIZE_6 1 339 #define DIGI_WORD_SIZE_7 2 340 #define DIGI_WORD_SIZE_8 3 341 342 #define DIGI_PARITY_NONE 0 343 #define DIGI_PARITY_ODD 1 344 #define DIGI_PARITY_EVEN 2 345 #define DIGI_PARITY_MARK 3 346 #define DIGI_PARITY_SPACE 4 347 348 #define DIGI_STOP_BITS_1 0 349 #define DIGI_STOP_BITS_2 1 350 351 #define DIGI_INPUT_FLOW_CONTROL_XON_XOFF 1 352 #define DIGI_INPUT_FLOW_CONTROL_RTS 2 353 #define DIGI_INPUT_FLOW_CONTROL_DTR 4 354 355 #define DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF 1 356 #define DIGI_OUTPUT_FLOW_CONTROL_CTS 2 357 #define DIGI_OUTPUT_FLOW_CONTROL_DSR 4 358 359 #define DIGI_DTR_INACTIVE 0 360 #define DIGI_DTR_ACTIVE 1 361 #define DIGI_DTR_INPUT_FLOW_CONTROL 2 362 363 #define DIGI_RTS_INACTIVE 0 364 #define DIGI_RTS_ACTIVE 1 365 #define DIGI_RTS_INPUT_FLOW_CONTROL 2 366 #define DIGI_RTS_TOGGLE 3 367 368 #define DIGI_FLUSH_TX 1 369 #define DIGI_FLUSH_RX 2 370 #define DIGI_RESUME_TX 4 /* clears xoff condition */ 371 372 #define DIGI_TRANSMIT_NOT_IDLE 0 373 #define DIGI_TRANSMIT_IDLE 1 374 375 #define DIGI_DISABLE 0 376 #define DIGI_ENABLE 1 377 378 #define DIGI_DEASSERT 0 379 #define DIGI_ASSERT 1 380 381 /* in band status codes */ 382 #define DIGI_OVERRUN_ERROR 4 383 #define DIGI_PARITY_ERROR 8 384 #define DIGI_FRAMING_ERROR 16 385 #define DIGI_BREAK_ERROR 32 386 387 /* out of band status */ 388 #define DIGI_NO_ERROR 0 389 #define DIGI_BAD_FIRST_PARAMETER 1 390 #define DIGI_BAD_SECOND_PARAMETER 2 391 #define DIGI_INVALID_LINE 3 392 #define DIGI_INVALID_OPCODE 4 393 394 /* input signals */ 395 #define DIGI_READ_INPUT_SIGNALS_SLOT 1 396 #define DIGI_READ_INPUT_SIGNALS_ERR 2 397 #define DIGI_READ_INPUT_SIGNALS_BUSY 4 398 #define DIGI_READ_INPUT_SIGNALS_PE 8 399 #define DIGI_READ_INPUT_SIGNALS_CTS 16 400 #define DIGI_READ_INPUT_SIGNALS_DSR 32 401 #define DIGI_READ_INPUT_SIGNALS_RI 64 402 #define DIGI_READ_INPUT_SIGNALS_DCD 128 403 404 405 /* Structures */ 406 407 struct digi_serial { 408 spinlock_t ds_serial_lock; 409 struct usb_serial_port *ds_oob_port; /* out-of-band port */ 410 int ds_oob_port_num; /* index of out-of-band port */ 411 int ds_device_started; 412 }; 413 414 struct digi_port { 415 spinlock_t dp_port_lock; 416 int dp_port_num; 417 int dp_out_buf_len; 418 unsigned char dp_out_buf[DIGI_OUT_BUF_SIZE]; 419 int dp_write_urb_in_use; 420 unsigned int dp_modem_signals; 421 wait_queue_head_t dp_modem_change_wait; 422 int dp_transmit_idle; 423 wait_queue_head_t dp_transmit_idle_wait; 424 int dp_throttled; 425 int dp_throttle_restart; 426 wait_queue_head_t dp_flush_wait; 427 int dp_in_close; /* close in progress */ 428 wait_queue_head_t dp_close_wait; /* wait queue for close */ 429 struct work_struct dp_wakeup_work; 430 struct usb_serial_port *dp_port; 431 }; 432 433 434 /* Local Function Declarations */ 435 436 static void digi_wakeup_write(struct usb_serial_port *port); 437 static void digi_wakeup_write_lock(struct work_struct *work); 438 static int digi_write_oob_command(struct usb_serial_port *port, 439 unsigned char *buf, int count, int interruptible); 440 static int digi_write_inb_command(struct usb_serial_port *port, 441 unsigned char *buf, int count, unsigned long timeout); 442 static int digi_set_modem_signals(struct usb_serial_port *port, 443 unsigned int modem_signals, int interruptible); 444 static int digi_transmit_idle(struct usb_serial_port *port, 445 unsigned long timeout); 446 static void digi_rx_throttle (struct usb_serial_port *port); 447 static void digi_rx_unthrottle (struct usb_serial_port *port); 448 static void digi_set_termios(struct usb_serial_port *port, 449 struct ktermios *old_termios); 450 static void digi_break_ctl(struct usb_serial_port *port, int break_state); 451 static int digi_ioctl(struct usb_serial_port *port, struct file *file, 452 unsigned int cmd, unsigned long arg); 453 static int digi_tiocmget(struct usb_serial_port *port, struct file *file); 454 static int digi_tiocmset(struct usb_serial_port *port, struct file *file, 455 unsigned int set, unsigned int clear); 456 static int digi_write(struct usb_serial_port *port, const unsigned char *buf, int count); 457 static void digi_write_bulk_callback(struct urb *urb); 458 static int digi_write_room(struct usb_serial_port *port); 459 static int digi_chars_in_buffer(struct usb_serial_port *port); 460 static int digi_open(struct usb_serial_port *port, struct file *filp); 461 static void digi_close(struct usb_serial_port *port, struct file *filp); 462 static int digi_startup_device(struct usb_serial *serial); 463 static int digi_startup(struct usb_serial *serial); 464 static void digi_shutdown(struct usb_serial *serial); 465 static void digi_read_bulk_callback(struct urb *urb); 466 static int digi_read_inb_callback(struct urb *urb); 467 static int digi_read_oob_callback(struct urb *urb); 468 469 470 /* Statics */ 471 472 static int debug; 473 474 static struct usb_device_id id_table_combined [] = { 475 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) }, 476 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) }, 477 { } /* Terminating entry */ 478 }; 479 480 static struct usb_device_id id_table_2 [] = { 481 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) }, 482 { } /* Terminating entry */ 483 }; 484 485 static struct usb_device_id id_table_4 [] = { 486 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) }, 487 { } /* Terminating entry */ 488 }; 489 490 MODULE_DEVICE_TABLE (usb, id_table_combined); 491 492 static struct usb_driver digi_driver = { 493 .name = "digi_acceleport", 494 .probe = usb_serial_probe, 495 .disconnect = usb_serial_disconnect, 496 .id_table = id_table_combined, 497 .no_dynamic_id = 1, 498 }; 499 500 501 /* device info needed for the Digi serial converter */ 502 503 static struct usb_serial_driver digi_acceleport_2_device = { 504 .driver = { 505 .owner = THIS_MODULE, 506 .name = "digi_2", 507 }, 508 .description = "Digi 2 port USB adapter", 509 .usb_driver = &digi_driver, 510 .id_table = id_table_2, 511 .num_interrupt_in = 0, 512 .num_bulk_in = 4, 513 .num_bulk_out = 4, 514 .num_ports = 3, 515 .open = digi_open, 516 .close = digi_close, 517 .write = digi_write, 518 .write_room = digi_write_room, 519 .write_bulk_callback = digi_write_bulk_callback, 520 .read_bulk_callback = digi_read_bulk_callback, 521 .chars_in_buffer = digi_chars_in_buffer, 522 .throttle = digi_rx_throttle, 523 .unthrottle = digi_rx_unthrottle, 524 .ioctl = digi_ioctl, 525 .set_termios = digi_set_termios, 526 .break_ctl = digi_break_ctl, 527 .tiocmget = digi_tiocmget, 528 .tiocmset = digi_tiocmset, 529 .attach = digi_startup, 530 .shutdown = digi_shutdown, 531 }; 532 533 static struct usb_serial_driver digi_acceleport_4_device = { 534 .driver = { 535 .owner = THIS_MODULE, 536 .name = "digi_4", 537 }, 538 .description = "Digi 4 port USB adapter", 539 .usb_driver = &digi_driver, 540 .id_table = id_table_4, 541 .num_interrupt_in = 0, 542 .num_bulk_in = 5, 543 .num_bulk_out = 5, 544 .num_ports = 4, 545 .open = digi_open, 546 .close = digi_close, 547 .write = digi_write, 548 .write_room = digi_write_room, 549 .write_bulk_callback = digi_write_bulk_callback, 550 .read_bulk_callback = digi_read_bulk_callback, 551 .chars_in_buffer = digi_chars_in_buffer, 552 .throttle = digi_rx_throttle, 553 .unthrottle = digi_rx_unthrottle, 554 .ioctl = digi_ioctl, 555 .set_termios = digi_set_termios, 556 .break_ctl = digi_break_ctl, 557 .tiocmget = digi_tiocmget, 558 .tiocmset = digi_tiocmset, 559 .attach = digi_startup, 560 .shutdown = digi_shutdown, 561 }; 562 563 564 /* Functions */ 565 566 /* 567 * Cond Wait Interruptible Timeout Irqrestore 568 * 569 * Do spin_unlock_irqrestore and interruptible_sleep_on_timeout 570 * so that wake ups are not lost if they occur between the unlock 571 * and the sleep. In other words, spin_unlock_irqrestore and 572 * interruptible_sleep_on_timeout are "atomic" with respect to 573 * wake ups. This is used to implement condition variables. 574 * 575 * interruptible_sleep_on_timeout is deprecated and has been replaced 576 * with the equivalent code. 577 */ 578 579 static long cond_wait_interruptible_timeout_irqrestore( 580 wait_queue_head_t *q, long timeout, 581 spinlock_t *lock, unsigned long flags) 582 { 583 DEFINE_WAIT(wait); 584 585 prepare_to_wait(q, &wait, TASK_INTERRUPTIBLE); 586 spin_unlock_irqrestore(lock, flags); 587 timeout = schedule_timeout(timeout); 588 finish_wait(q, &wait); 589 590 return timeout; 591 } 592 593 594 /* 595 * Digi Wakeup Write 596 * 597 * Wake up port, line discipline, and tty processes sleeping 598 * on writes. 599 */ 600 601 static void digi_wakeup_write_lock(struct work_struct *work) 602 { 603 struct digi_port *priv = container_of(work, struct digi_port, dp_wakeup_work); 604 struct usb_serial_port *port = priv->dp_port; 605 unsigned long flags; 606 607 spin_lock_irqsave(&priv->dp_port_lock, flags); 608 digi_wakeup_write(port); 609 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 610 } 611 612 static void digi_wakeup_write(struct usb_serial_port *port) 613 { 614 tty_wakeup(port->tty); 615 } 616 617 618 /* 619 * Digi Write OOB Command 620 * 621 * Write commands on the out of band port. Commands are 4 622 * bytes each, multiple commands can be sent at once, and 623 * no command will be split across USB packets. Returns 0 624 * if successful, -EINTR if interrupted while sleeping and 625 * the interruptible flag is true, or a negative error 626 * returned by usb_submit_urb. 627 */ 628 629 static int digi_write_oob_command(struct usb_serial_port *port, 630 unsigned char *buf, int count, int interruptible) 631 { 632 633 int ret = 0; 634 int len; 635 struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port; 636 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port); 637 unsigned long flags = 0; 638 639 dbg("digi_write_oob_command: TOP: port=%d, count=%d", oob_priv->dp_port_num, count); 640 641 spin_lock_irqsave(&oob_priv->dp_port_lock, flags); 642 while(count > 0) { 643 while(oob_port->write_urb->status == -EINPROGRESS 644 || oob_priv->dp_write_urb_in_use) { 645 cond_wait_interruptible_timeout_irqrestore( 646 &oob_port->write_wait, DIGI_RETRY_TIMEOUT, 647 &oob_priv->dp_port_lock, flags); 648 if (interruptible && signal_pending(current)) 649 return -EINTR; 650 spin_lock_irqsave(&oob_priv->dp_port_lock, flags); 651 } 652 653 /* len must be a multiple of 4, so commands are not split */ 654 len = min(count, oob_port->bulk_out_size); 655 if (len > 4) 656 len &= ~3; 657 memcpy(oob_port->write_urb->transfer_buffer, buf, len); 658 oob_port->write_urb->transfer_buffer_length = len; 659 oob_port->write_urb->dev = port->serial->dev; 660 if ((ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC)) == 0) { 661 oob_priv->dp_write_urb_in_use = 1; 662 count -= len; 663 buf += len; 664 } 665 } 666 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags); 667 if (ret) 668 err("%s: usb_submit_urb failed, ret=%d", __FUNCTION__, ret); 669 return ret; 670 671 } 672 673 674 /* 675 * Digi Write In Band Command 676 * 677 * Write commands on the given port. Commands are 4 678 * bytes each, multiple commands can be sent at once, and 679 * no command will be split across USB packets. If timeout 680 * is non-zero, write in band command will return after 681 * waiting unsuccessfully for the URB status to clear for 682 * timeout ticks. Returns 0 if successful, or a negative 683 * error returned by digi_write. 684 */ 685 686 static int digi_write_inb_command(struct usb_serial_port *port, 687 unsigned char *buf, int count, unsigned long timeout) 688 { 689 int ret = 0; 690 int len; 691 struct digi_port *priv = usb_get_serial_port_data(port); 692 unsigned char *data = port->write_urb->transfer_buffer; 693 unsigned long flags = 0; 694 695 dbg("digi_write_inb_command: TOP: port=%d, count=%d", 696 priv->dp_port_num, count); 697 698 if (timeout) 699 timeout += jiffies; 700 else 701 timeout = ULONG_MAX; 702 703 spin_lock_irqsave(&priv->dp_port_lock, flags); 704 while(count > 0 && ret == 0) { 705 while((port->write_urb->status == -EINPROGRESS 706 || priv->dp_write_urb_in_use) && time_before(jiffies, timeout)) { 707 cond_wait_interruptible_timeout_irqrestore( 708 &port->write_wait, DIGI_RETRY_TIMEOUT, 709 &priv->dp_port_lock, flags); 710 if (signal_pending(current)) 711 return -EINTR; 712 spin_lock_irqsave(&priv->dp_port_lock, flags); 713 } 714 715 /* len must be a multiple of 4 and small enough to */ 716 /* guarantee the write will send buffered data first, */ 717 /* so commands are in order with data and not split */ 718 len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len); 719 if (len > 4) 720 len &= ~3; 721 722 /* write any buffered data first */ 723 if (priv->dp_out_buf_len > 0) { 724 data[0] = DIGI_CMD_SEND_DATA; 725 data[1] = priv->dp_out_buf_len; 726 memcpy(data + 2, priv->dp_out_buf, 727 priv->dp_out_buf_len); 728 memcpy(data + 2 + priv->dp_out_buf_len, buf, len); 729 port->write_urb->transfer_buffer_length 730 = priv->dp_out_buf_len + 2 + len; 731 } else { 732 memcpy(data, buf, len); 733 port->write_urb->transfer_buffer_length = len; 734 } 735 port->write_urb->dev = port->serial->dev; 736 737 if ((ret = usb_submit_urb(port->write_urb, GFP_ATOMIC)) == 0) { 738 priv->dp_write_urb_in_use = 1; 739 priv->dp_out_buf_len = 0; 740 count -= len; 741 buf += len; 742 } 743 744 } 745 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 746 747 if (ret) 748 err("%s: usb_submit_urb failed, ret=%d, port=%d", 749 __FUNCTION__, ret, priv->dp_port_num); 750 return ret; 751 } 752 753 754 /* 755 * Digi Set Modem Signals 756 * 757 * Sets or clears DTR and RTS on the port, according to the 758 * modem_signals argument. Use TIOCM_DTR and TIOCM_RTS flags 759 * for the modem_signals argument. Returns 0 if successful, 760 * -EINTR if interrupted while sleeping, or a non-zero error 761 * returned by usb_submit_urb. 762 */ 763 764 static int digi_set_modem_signals(struct usb_serial_port *port, 765 unsigned int modem_signals, int interruptible) 766 { 767 768 int ret; 769 struct digi_port *port_priv = usb_get_serial_port_data(port); 770 struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port; 771 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port); 772 unsigned char *data = oob_port->write_urb->transfer_buffer; 773 unsigned long flags = 0; 774 775 776 dbg("digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x", 777 port_priv->dp_port_num, modem_signals); 778 779 spin_lock_irqsave(&oob_priv->dp_port_lock, flags); 780 spin_lock(&port_priv->dp_port_lock); 781 782 while(oob_port->write_urb->status == -EINPROGRESS || oob_priv->dp_write_urb_in_use) { 783 spin_unlock(&port_priv->dp_port_lock); 784 cond_wait_interruptible_timeout_irqrestore( 785 &oob_port->write_wait, DIGI_RETRY_TIMEOUT, 786 &oob_priv->dp_port_lock, flags); 787 if (interruptible && signal_pending(current)) 788 return -EINTR; 789 spin_lock_irqsave(&oob_priv->dp_port_lock, flags); 790 spin_lock(&port_priv->dp_port_lock); 791 } 792 data[0] = DIGI_CMD_SET_DTR_SIGNAL; 793 data[1] = port_priv->dp_port_num; 794 data[2] = (modem_signals&TIOCM_DTR) ? DIGI_DTR_ACTIVE : DIGI_DTR_INACTIVE; 795 data[3] = 0; 796 data[4] = DIGI_CMD_SET_RTS_SIGNAL; 797 data[5] = port_priv->dp_port_num; 798 data[6] = (modem_signals&TIOCM_RTS) ? DIGI_RTS_ACTIVE : DIGI_RTS_INACTIVE; 799 data[7] = 0; 800 801 oob_port->write_urb->transfer_buffer_length = 8; 802 oob_port->write_urb->dev = port->serial->dev; 803 804 if ((ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC)) == 0) { 805 oob_priv->dp_write_urb_in_use = 1; 806 port_priv->dp_modem_signals = 807 (port_priv->dp_modem_signals&~(TIOCM_DTR|TIOCM_RTS)) 808 | (modem_signals&(TIOCM_DTR|TIOCM_RTS)); 809 } 810 spin_unlock(&port_priv->dp_port_lock); 811 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags); 812 if (ret) 813 err("%s: usb_submit_urb failed, ret=%d", __FUNCTION__, ret); 814 return ret; 815 } 816 817 /* 818 * Digi Transmit Idle 819 * 820 * Digi transmit idle waits, up to timeout ticks, for the transmitter 821 * to go idle. It returns 0 if successful or a negative error. 822 * 823 * There are race conditions here if more than one process is calling 824 * digi_transmit_idle on the same port at the same time. However, this 825 * is only called from close, and only one process can be in close on a 826 * port at a time, so its ok. 827 */ 828 829 static int digi_transmit_idle(struct usb_serial_port *port, 830 unsigned long timeout) 831 { 832 int ret; 833 unsigned char buf[2]; 834 struct digi_port *priv = usb_get_serial_port_data(port); 835 unsigned long flags = 0; 836 837 spin_lock_irqsave(&priv->dp_port_lock, flags); 838 priv->dp_transmit_idle = 0; 839 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 840 841 buf[0] = DIGI_CMD_TRANSMIT_IDLE; 842 buf[1] = 0; 843 844 timeout += jiffies; 845 846 if ((ret = digi_write_inb_command(port, buf, 2, timeout - jiffies)) != 0) 847 return ret; 848 849 spin_lock_irqsave(&priv->dp_port_lock, flags); 850 851 while(time_before(jiffies, timeout) && !priv->dp_transmit_idle) { 852 cond_wait_interruptible_timeout_irqrestore( 853 &priv->dp_transmit_idle_wait, DIGI_RETRY_TIMEOUT, 854 &priv->dp_port_lock, flags); 855 if (signal_pending(current)) 856 return -EINTR; 857 spin_lock_irqsave(&priv->dp_port_lock, flags); 858 } 859 priv->dp_transmit_idle = 0; 860 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 861 return 0; 862 863 } 864 865 866 static void digi_rx_throttle(struct usb_serial_port *port) 867 { 868 unsigned long flags; 869 struct digi_port *priv = usb_get_serial_port_data(port); 870 871 872 dbg("digi_rx_throttle: TOP: port=%d", priv->dp_port_num); 873 874 /* stop receiving characters by not resubmitting the read urb */ 875 spin_lock_irqsave(&priv->dp_port_lock, flags); 876 priv->dp_throttled = 1; 877 priv->dp_throttle_restart = 0; 878 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 879 } 880 881 882 static void digi_rx_unthrottle(struct usb_serial_port *port) 883 { 884 int ret = 0; 885 unsigned long flags; 886 struct digi_port *priv = usb_get_serial_port_data(port); 887 888 dbg("digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num); 889 890 spin_lock_irqsave(&priv->dp_port_lock, flags); 891 892 /* turn throttle off */ 893 priv->dp_throttled = 0; 894 priv->dp_throttle_restart = 0; 895 896 /* restart read chain */ 897 if (priv->dp_throttle_restart) { 898 port->read_urb->dev = port->serial->dev; 899 ret = usb_submit_urb(port->read_urb, GFP_ATOMIC); 900 } 901 902 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 903 904 if (ret) 905 err("%s: usb_submit_urb failed, ret=%d, port=%d", 906 __FUNCTION__, ret, priv->dp_port_num); 907 } 908 909 910 static void digi_set_termios(struct usb_serial_port *port, 911 struct ktermios *old_termios) 912 { 913 914 struct digi_port *priv = usb_get_serial_port_data(port); 915 struct tty_struct *tty = port->tty; 916 unsigned int iflag = tty->termios->c_iflag; 917 unsigned int cflag = tty->termios->c_cflag; 918 unsigned int old_iflag = old_termios->c_iflag; 919 unsigned int old_cflag = old_termios->c_cflag; 920 unsigned char buf[32]; 921 unsigned int modem_signals; 922 int arg,ret; 923 int i = 0; 924 speed_t baud; 925 926 dbg("digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x", priv->dp_port_num, iflag, old_iflag, cflag, old_cflag); 927 928 /* set baud rate */ 929 if ((baud = tty_get_baud_rate(tty)) != tty_termios_baud_rate(old_termios)) { 930 arg = -1; 931 932 /* reassert DTR and (maybe) RTS on transition from B0 */ 933 if ((old_cflag&CBAUD) == B0) { 934 /* don't set RTS if using hardware flow control */ 935 /* and throttling input */ 936 modem_signals = TIOCM_DTR; 937 if (!(tty->termios->c_cflag & CRTSCTS) || 938 !test_bit(TTY_THROTTLED, &tty->flags)) 939 modem_signals |= TIOCM_RTS; 940 digi_set_modem_signals(port, modem_signals, 1); 941 } 942 switch (baud) { 943 /* drop DTR and RTS on transition to B0 */ 944 case 0: digi_set_modem_signals(port, 0, 1); break; 945 case 50: arg = DIGI_BAUD_50; break; 946 case 75: arg = DIGI_BAUD_75; break; 947 case 110: arg = DIGI_BAUD_110; break; 948 case 150: arg = DIGI_BAUD_150; break; 949 case 200: arg = DIGI_BAUD_200; break; 950 case 300: arg = DIGI_BAUD_300; break; 951 case 600: arg = DIGI_BAUD_600; break; 952 case 1200: arg = DIGI_BAUD_1200; break; 953 case 1800: arg = DIGI_BAUD_1800; break; 954 case 2400: arg = DIGI_BAUD_2400; break; 955 case 4800: arg = DIGI_BAUD_4800; break; 956 case 9600: arg = DIGI_BAUD_9600; break; 957 case 19200: arg = DIGI_BAUD_19200; break; 958 case 38400: arg = DIGI_BAUD_38400; break; 959 case 57600: arg = DIGI_BAUD_57600; break; 960 case 115200: arg = DIGI_BAUD_115200; break; 961 case 230400: arg = DIGI_BAUD_230400; break; 962 case 460800: arg = DIGI_BAUD_460800; break; 963 default: 964 arg = DIGI_BAUD_9600; 965 baud = 9600; 966 break; 967 } 968 if (arg != -1) { 969 buf[i++] = DIGI_CMD_SET_BAUD_RATE; 970 buf[i++] = priv->dp_port_num; 971 buf[i++] = arg; 972 buf[i++] = 0; 973 } 974 } 975 /* set parity */ 976 if ((cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD))) { 977 if (cflag&PARENB) { 978 if (cflag&PARODD) 979 arg = DIGI_PARITY_ODD; 980 else 981 arg = DIGI_PARITY_EVEN; 982 } else { 983 arg = DIGI_PARITY_NONE; 984 } 985 buf[i++] = DIGI_CMD_SET_PARITY; 986 buf[i++] = priv->dp_port_num; 987 buf[i++] = arg; 988 buf[i++] = 0; 989 } 990 /* set word size */ 991 if ((cflag&CSIZE) != (old_cflag&CSIZE)) { 992 arg = -1; 993 switch (cflag&CSIZE) { 994 case CS5: arg = DIGI_WORD_SIZE_5; break; 995 case CS6: arg = DIGI_WORD_SIZE_6; break; 996 case CS7: arg = DIGI_WORD_SIZE_7; break; 997 case CS8: arg = DIGI_WORD_SIZE_8; break; 998 default: 999 dbg("digi_set_termios: can't handle word size %d", 1000 (cflag&CSIZE)); 1001 break; 1002 } 1003 1004 if (arg != -1) { 1005 buf[i++] = DIGI_CMD_SET_WORD_SIZE; 1006 buf[i++] = priv->dp_port_num; 1007 buf[i++] = arg; 1008 buf[i++] = 0; 1009 } 1010 1011 } 1012 1013 /* set stop bits */ 1014 if ((cflag&CSTOPB) != (old_cflag&CSTOPB)) { 1015 1016 if ((cflag&CSTOPB)) 1017 arg = DIGI_STOP_BITS_2; 1018 else 1019 arg = DIGI_STOP_BITS_1; 1020 1021 buf[i++] = DIGI_CMD_SET_STOP_BITS; 1022 buf[i++] = priv->dp_port_num; 1023 buf[i++] = arg; 1024 buf[i++] = 0; 1025 1026 } 1027 1028 /* set input flow control */ 1029 if ((iflag&IXOFF) != (old_iflag&IXOFF) 1030 || (cflag&CRTSCTS) != (old_cflag&CRTSCTS)) { 1031 arg = 0; 1032 if (iflag&IXOFF) 1033 arg |= DIGI_INPUT_FLOW_CONTROL_XON_XOFF; 1034 else 1035 arg &= ~DIGI_INPUT_FLOW_CONTROL_XON_XOFF; 1036 1037 if (cflag&CRTSCTS) { 1038 arg |= DIGI_INPUT_FLOW_CONTROL_RTS; 1039 1040 /* On USB-4 it is necessary to assert RTS prior */ 1041 /* to selecting RTS input flow control. */ 1042 buf[i++] = DIGI_CMD_SET_RTS_SIGNAL; 1043 buf[i++] = priv->dp_port_num; 1044 buf[i++] = DIGI_RTS_ACTIVE; 1045 buf[i++] = 0; 1046 1047 } else { 1048 arg &= ~DIGI_INPUT_FLOW_CONTROL_RTS; 1049 } 1050 buf[i++] = DIGI_CMD_SET_INPUT_FLOW_CONTROL; 1051 buf[i++] = priv->dp_port_num; 1052 buf[i++] = arg; 1053 buf[i++] = 0; 1054 } 1055 1056 /* set output flow control */ 1057 if ((iflag&IXON) != (old_iflag&IXON) 1058 || (cflag&CRTSCTS) != (old_cflag&CRTSCTS)) { 1059 arg = 0; 1060 if (iflag&IXON) 1061 arg |= DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF; 1062 else 1063 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF; 1064 1065 if (cflag&CRTSCTS) { 1066 arg |= DIGI_OUTPUT_FLOW_CONTROL_CTS; 1067 } else { 1068 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_CTS; 1069 tty->hw_stopped = 0; 1070 } 1071 1072 buf[i++] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL; 1073 buf[i++] = priv->dp_port_num; 1074 buf[i++] = arg; 1075 buf[i++] = 0; 1076 } 1077 1078 /* set receive enable/disable */ 1079 if ((cflag&CREAD) != (old_cflag&CREAD)) { 1080 if (cflag&CREAD) 1081 arg = DIGI_ENABLE; 1082 else 1083 arg = DIGI_DISABLE; 1084 1085 buf[i++] = DIGI_CMD_RECEIVE_ENABLE; 1086 buf[i++] = priv->dp_port_num; 1087 buf[i++] = arg; 1088 buf[i++] = 0; 1089 } 1090 if ((ret = digi_write_oob_command(port, buf, i, 1)) != 0) 1091 dbg("digi_set_termios: write oob failed, ret=%d", ret); 1092 1093 } 1094 1095 1096 static void digi_break_ctl(struct usb_serial_port *port, int break_state) 1097 { 1098 unsigned char buf[4]; 1099 1100 buf[0] = DIGI_CMD_BREAK_CONTROL; 1101 buf[1] = 2; /* length */ 1102 buf[2] = break_state ? 1 : 0; 1103 buf[3] = 0; /* pad */ 1104 digi_write_inb_command(port, buf, 4, 0); 1105 } 1106 1107 1108 static int digi_tiocmget(struct usb_serial_port *port, struct file *file) 1109 { 1110 struct digi_port *priv = usb_get_serial_port_data(port); 1111 unsigned int val; 1112 unsigned long flags; 1113 1114 dbg("%s: TOP: port=%d", __FUNCTION__, priv->dp_port_num); 1115 1116 spin_lock_irqsave(&priv->dp_port_lock, flags); 1117 val = priv->dp_modem_signals; 1118 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1119 return val; 1120 } 1121 1122 1123 static int digi_tiocmset(struct usb_serial_port *port, struct file *file, 1124 unsigned int set, unsigned int clear) 1125 { 1126 struct digi_port *priv = usb_get_serial_port_data(port); 1127 unsigned int val; 1128 unsigned long flags; 1129 1130 dbg("%s: TOP: port=%d", __FUNCTION__, priv->dp_port_num); 1131 1132 spin_lock_irqsave(&priv->dp_port_lock, flags); 1133 val = (priv->dp_modem_signals & ~clear) | set; 1134 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1135 return digi_set_modem_signals(port, val, 1); 1136 } 1137 1138 1139 static int digi_ioctl(struct usb_serial_port *port, struct file *file, 1140 unsigned int cmd, unsigned long arg) 1141 { 1142 struct digi_port *priv = usb_get_serial_port_data(port); 1143 dbg("digi_ioctl: TOP: port=%d, cmd=0x%x", priv->dp_port_num, cmd); 1144 1145 switch (cmd) { 1146 case TIOCMIWAIT: 1147 /* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/ 1148 /* TODO */ 1149 return 0; 1150 case TIOCGICOUNT: 1151 /* return count of modemline transitions */ 1152 /* TODO */ 1153 return 0; 1154 } 1155 return -ENOIOCTLCMD; 1156 1157 } 1158 1159 static int digi_write(struct usb_serial_port *port, const unsigned char *buf, int count) 1160 { 1161 1162 int ret,data_len,new_len; 1163 struct digi_port *priv = usb_get_serial_port_data(port); 1164 unsigned char *data = port->write_urb->transfer_buffer; 1165 unsigned long flags = 0; 1166 1167 dbg("digi_write: TOP: port=%d, count=%d, in_interrupt=%ld", 1168 priv->dp_port_num, count, in_interrupt()); 1169 1170 /* copy user data (which can sleep) before getting spin lock */ 1171 count = min(count, port->bulk_out_size-2); 1172 count = min(64, count); 1173 1174 /* be sure only one write proceeds at a time */ 1175 /* there are races on the port private buffer */ 1176 /* and races to check write_urb->status */ 1177 spin_lock_irqsave(&priv->dp_port_lock, flags); 1178 1179 /* wait for urb status clear to submit another urb */ 1180 if (port->write_urb->status == -EINPROGRESS || priv->dp_write_urb_in_use) { 1181 /* buffer data if count is 1 (probably put_char) if possible */ 1182 if (count == 1 && priv->dp_out_buf_len < DIGI_OUT_BUF_SIZE) { 1183 priv->dp_out_buf[priv->dp_out_buf_len++] = *buf; 1184 new_len = 1; 1185 } else { 1186 new_len = 0; 1187 } 1188 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1189 return new_len; 1190 } 1191 1192 /* allow space for any buffered data and for new data, up to */ 1193 /* transfer buffer size - 2 (for command and length bytes) */ 1194 new_len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len); 1195 data_len = new_len + priv->dp_out_buf_len; 1196 1197 if (data_len == 0) { 1198 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1199 return 0; 1200 } 1201 1202 port->write_urb->transfer_buffer_length = data_len+2; 1203 port->write_urb->dev = port->serial->dev; 1204 1205 *data++ = DIGI_CMD_SEND_DATA; 1206 *data++ = data_len; 1207 1208 /* copy in buffered data first */ 1209 memcpy(data, priv->dp_out_buf, priv->dp_out_buf_len); 1210 data += priv->dp_out_buf_len; 1211 1212 /* copy in new data */ 1213 memcpy(data, buf, new_len); 1214 1215 if ((ret = usb_submit_urb(port->write_urb, GFP_ATOMIC)) == 0) { 1216 priv->dp_write_urb_in_use = 1; 1217 ret = new_len; 1218 priv->dp_out_buf_len = 0; 1219 } 1220 1221 /* return length of new data written, or error */ 1222 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1223 if (ret < 0) 1224 err("%s: usb_submit_urb failed, ret=%d, port=%d", 1225 __FUNCTION__, ret, priv->dp_port_num); 1226 dbg("digi_write: returning %d", ret); 1227 return ret; 1228 1229 } 1230 1231 static void digi_write_bulk_callback(struct urb *urb) 1232 { 1233 1234 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 1235 struct usb_serial *serial; 1236 struct digi_port *priv; 1237 struct digi_serial *serial_priv; 1238 int ret = 0; 1239 int status = urb->status; 1240 1241 dbg("digi_write_bulk_callback: TOP, urb->status=%d", status); 1242 1243 /* port and serial sanity check */ 1244 if (port == NULL || (priv=usb_get_serial_port_data(port)) == NULL) { 1245 err("%s: port or port->private is NULL, status=%d", 1246 __FUNCTION__, status); 1247 return; 1248 } 1249 serial = port->serial; 1250 if (serial == NULL || (serial_priv=usb_get_serial_data(serial)) == NULL) { 1251 err("%s: serial or serial->private is NULL, status=%d", 1252 __FUNCTION__, status); 1253 return; 1254 } 1255 1256 /* handle oob callback */ 1257 if (priv->dp_port_num == serial_priv->ds_oob_port_num) { 1258 dbg("digi_write_bulk_callback: oob callback"); 1259 spin_lock(&priv->dp_port_lock); 1260 priv->dp_write_urb_in_use = 0; 1261 wake_up_interruptible(&port->write_wait); 1262 spin_unlock(&priv->dp_port_lock); 1263 return; 1264 } 1265 1266 /* try to send any buffered data on this port, if it is open */ 1267 spin_lock(&priv->dp_port_lock); 1268 priv->dp_write_urb_in_use = 0; 1269 if (port->open_count && port->write_urb->status != -EINPROGRESS 1270 && priv->dp_out_buf_len > 0) { 1271 *((unsigned char *)(port->write_urb->transfer_buffer)) 1272 = (unsigned char)DIGI_CMD_SEND_DATA; 1273 *((unsigned char *)(port->write_urb->transfer_buffer)+1) 1274 = (unsigned char)priv->dp_out_buf_len; 1275 port->write_urb->transfer_buffer_length = priv->dp_out_buf_len+2; 1276 port->write_urb->dev = serial->dev; 1277 memcpy(port->write_urb->transfer_buffer+2, priv->dp_out_buf, 1278 priv->dp_out_buf_len); 1279 if ((ret = usb_submit_urb(port->write_urb, GFP_ATOMIC)) == 0) { 1280 priv->dp_write_urb_in_use = 1; 1281 priv->dp_out_buf_len = 0; 1282 } 1283 } 1284 /* wake up processes sleeping on writes immediately */ 1285 digi_wakeup_write(port); 1286 /* also queue up a wakeup at scheduler time, in case we */ 1287 /* lost the race in write_chan(). */ 1288 schedule_work(&priv->dp_wakeup_work); 1289 1290 spin_unlock(&priv->dp_port_lock); 1291 if (ret) 1292 err("%s: usb_submit_urb failed, ret=%d, port=%d", 1293 __FUNCTION__, ret, priv->dp_port_num); 1294 } 1295 1296 static int digi_write_room(struct usb_serial_port *port) 1297 { 1298 1299 int room; 1300 struct digi_port *priv = usb_get_serial_port_data(port); 1301 unsigned long flags = 0; 1302 1303 spin_lock_irqsave(&priv->dp_port_lock, flags); 1304 1305 if (port->write_urb->status == -EINPROGRESS || priv->dp_write_urb_in_use) 1306 room = 0; 1307 else 1308 room = port->bulk_out_size - 2 - priv->dp_out_buf_len; 1309 1310 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1311 dbg("digi_write_room: port=%d, room=%d", priv->dp_port_num, room); 1312 return room; 1313 1314 } 1315 1316 static int digi_chars_in_buffer(struct usb_serial_port *port) 1317 { 1318 1319 struct digi_port *priv = usb_get_serial_port_data(port); 1320 1321 1322 if (port->write_urb->status == -EINPROGRESS 1323 || priv->dp_write_urb_in_use) { 1324 dbg("digi_chars_in_buffer: port=%d, chars=%d", 1325 priv->dp_port_num, port->bulk_out_size - 2); 1326 /* return(port->bulk_out_size - 2); */ 1327 return 256; 1328 } else { 1329 dbg("digi_chars_in_buffer: port=%d, chars=%d", 1330 priv->dp_port_num, priv->dp_out_buf_len); 1331 return priv->dp_out_buf_len; 1332 } 1333 1334 } 1335 1336 1337 static int digi_open(struct usb_serial_port *port, struct file *filp) 1338 { 1339 int ret; 1340 unsigned char buf[32]; 1341 struct digi_port *priv = usb_get_serial_port_data(port); 1342 struct ktermios not_termios; 1343 unsigned long flags = 0; 1344 1345 dbg("digi_open: TOP: port=%d, open_count=%d", 1346 priv->dp_port_num, port->open_count); 1347 1348 /* be sure the device is started up */ 1349 if (digi_startup_device(port->serial) != 0) 1350 return -ENXIO; 1351 1352 spin_lock_irqsave(&priv->dp_port_lock, flags); 1353 1354 /* don't wait on a close in progress for non-blocking opens */ 1355 if (priv->dp_in_close && (filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0) { 1356 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1357 return -EAGAIN; 1358 } 1359 1360 /* wait for a close in progress to finish */ 1361 while(priv->dp_in_close) { 1362 cond_wait_interruptible_timeout_irqrestore( 1363 &priv->dp_close_wait, DIGI_RETRY_TIMEOUT, 1364 &priv->dp_port_lock, flags); 1365 if (signal_pending(current)) 1366 return -EINTR; 1367 spin_lock_irqsave(&priv->dp_port_lock, flags); 1368 } 1369 1370 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1371 1372 /* read modem signals automatically whenever they change */ 1373 buf[0] = DIGI_CMD_READ_INPUT_SIGNALS; 1374 buf[1] = priv->dp_port_num; 1375 buf[2] = DIGI_ENABLE; 1376 buf[3] = 0; 1377 1378 /* flush fifos */ 1379 buf[4] = DIGI_CMD_IFLUSH_FIFO; 1380 buf[5] = priv->dp_port_num; 1381 buf[6] = DIGI_FLUSH_TX | DIGI_FLUSH_RX; 1382 buf[7] = 0; 1383 1384 if ((ret = digi_write_oob_command(port, buf, 8, 1)) != 0) 1385 dbg("digi_open: write oob failed, ret=%d", ret); 1386 1387 /* set termios settings */ 1388 not_termios.c_cflag = ~port->tty->termios->c_cflag; 1389 not_termios.c_iflag = ~port->tty->termios->c_iflag; 1390 digi_set_termios(port, ¬_termios); 1391 1392 /* set DTR and RTS */ 1393 digi_set_modem_signals(port, TIOCM_DTR|TIOCM_RTS, 1); 1394 1395 return 0; 1396 } 1397 1398 1399 static void digi_close(struct usb_serial_port *port, struct file *filp) 1400 { 1401 DEFINE_WAIT(wait); 1402 int ret; 1403 unsigned char buf[32]; 1404 struct tty_struct *tty = port->tty; 1405 struct digi_port *priv = usb_get_serial_port_data(port); 1406 unsigned long flags = 0; 1407 1408 dbg("digi_close: TOP: port=%d, open_count=%d", 1409 priv->dp_port_num, port->open_count); 1410 1411 /* if disconnected, just clear flags */ 1412 if (!usb_get_intfdata(port->serial->interface)) 1413 goto exit; 1414 1415 /* do cleanup only after final close on this port */ 1416 spin_lock_irqsave(&priv->dp_port_lock, flags); 1417 priv->dp_in_close = 1; 1418 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1419 1420 /* tell line discipline to process only XON/XOFF */ 1421 tty->closing = 1; 1422 1423 /* wait for output to drain */ 1424 if ((filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0) 1425 tty_wait_until_sent(tty, DIGI_CLOSE_TIMEOUT); 1426 1427 /* flush driver and line discipline buffers */ 1428 if (tty->driver->flush_buffer) 1429 tty->driver->flush_buffer(tty); 1430 tty_ldisc_flush(tty); 1431 1432 if (port->serial->dev) { 1433 /* wait for transmit idle */ 1434 if ((filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0) { 1435 digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT); 1436 } 1437 /* drop DTR and RTS */ 1438 digi_set_modem_signals(port, 0, 0); 1439 1440 /* disable input flow control */ 1441 buf[0] = DIGI_CMD_SET_INPUT_FLOW_CONTROL; 1442 buf[1] = priv->dp_port_num; 1443 buf[2] = DIGI_DISABLE; 1444 buf[3] = 0; 1445 1446 /* disable output flow control */ 1447 buf[4] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL; 1448 buf[5] = priv->dp_port_num; 1449 buf[6] = DIGI_DISABLE; 1450 buf[7] = 0; 1451 1452 /* disable reading modem signals automatically */ 1453 buf[8] = DIGI_CMD_READ_INPUT_SIGNALS; 1454 buf[9] = priv->dp_port_num; 1455 buf[10] = DIGI_DISABLE; 1456 buf[11] = 0; 1457 1458 /* disable receive */ 1459 buf[12] = DIGI_CMD_RECEIVE_ENABLE; 1460 buf[13] = priv->dp_port_num; 1461 buf[14] = DIGI_DISABLE; 1462 buf[15] = 0; 1463 1464 /* flush fifos */ 1465 buf[16] = DIGI_CMD_IFLUSH_FIFO; 1466 buf[17] = priv->dp_port_num; 1467 buf[18] = DIGI_FLUSH_TX | DIGI_FLUSH_RX; 1468 buf[19] = 0; 1469 1470 if ((ret = digi_write_oob_command(port, buf, 20, 0)) != 0) 1471 dbg("digi_close: write oob failed, ret=%d", ret); 1472 1473 /* wait for final commands on oob port to complete */ 1474 prepare_to_wait(&priv->dp_flush_wait, &wait, TASK_INTERRUPTIBLE); 1475 schedule_timeout(DIGI_CLOSE_TIMEOUT); 1476 finish_wait(&priv->dp_flush_wait, &wait); 1477 1478 /* shutdown any outstanding bulk writes */ 1479 usb_kill_urb(port->write_urb); 1480 } 1481 tty->closing = 0; 1482 exit: 1483 spin_lock_irqsave(&priv->dp_port_lock, flags); 1484 priv->dp_write_urb_in_use = 0; 1485 priv->dp_in_close = 0; 1486 wake_up_interruptible(&priv->dp_close_wait); 1487 spin_unlock_irqrestore(&priv->dp_port_lock, flags); 1488 dbg("digi_close: done"); 1489 } 1490 1491 1492 /* 1493 * Digi Startup Device 1494 * 1495 * Starts reads on all ports. Must be called AFTER startup, with 1496 * urbs initialized. Returns 0 if successful, non-zero error otherwise. 1497 */ 1498 1499 static int digi_startup_device(struct usb_serial *serial) 1500 { 1501 int i,ret = 0; 1502 struct digi_serial *serial_priv = usb_get_serial_data(serial); 1503 struct usb_serial_port *port; 1504 1505 /* be sure this happens exactly once */ 1506 spin_lock(&serial_priv->ds_serial_lock); 1507 if (serial_priv->ds_device_started) { 1508 spin_unlock(&serial_priv->ds_serial_lock); 1509 return 0; 1510 } 1511 serial_priv->ds_device_started = 1; 1512 spin_unlock(&serial_priv->ds_serial_lock); 1513 1514 /* start reading from each bulk in endpoint for the device */ 1515 /* set USB_DISABLE_SPD flag for write bulk urbs */ 1516 for (i = 0; i < serial->type->num_ports + 1; i++) { 1517 port = serial->port[i]; 1518 port->write_urb->dev = port->serial->dev; 1519 if ((ret = usb_submit_urb(port->read_urb, GFP_KERNEL)) != 0) { 1520 err("%s: usb_submit_urb failed, ret=%d, port=%d", 1521 __FUNCTION__, ret, i); 1522 break; 1523 } 1524 } 1525 return ret; 1526 } 1527 1528 1529 static int digi_startup(struct usb_serial *serial) 1530 { 1531 1532 int i; 1533 struct digi_port *priv; 1534 struct digi_serial *serial_priv; 1535 1536 dbg("digi_startup: TOP"); 1537 1538 /* allocate the private data structures for all ports */ 1539 /* number of regular ports + 1 for the out-of-band port */ 1540 for(i = 0; i < serial->type->num_ports + 1; i++) { 1541 /* allocate port private structure */ 1542 priv = kmalloc(sizeof(struct digi_port), GFP_KERNEL); 1543 if (priv == NULL) { 1544 while (--i >= 0) 1545 kfree(usb_get_serial_port_data(serial->port[i])); 1546 return 1; /* error */ 1547 } 1548 1549 /* initialize port private structure */ 1550 spin_lock_init(&priv->dp_port_lock); 1551 priv->dp_port_num = i; 1552 priv->dp_out_buf_len = 0; 1553 priv->dp_write_urb_in_use = 0; 1554 priv->dp_modem_signals = 0; 1555 init_waitqueue_head(&priv->dp_modem_change_wait); 1556 priv->dp_transmit_idle = 0; 1557 init_waitqueue_head(&priv->dp_transmit_idle_wait); 1558 priv->dp_throttled = 0; 1559 priv->dp_throttle_restart = 0; 1560 init_waitqueue_head(&priv->dp_flush_wait); 1561 priv->dp_in_close = 0; 1562 init_waitqueue_head(&priv->dp_close_wait); 1563 INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock); 1564 priv->dp_port = serial->port[i]; 1565 /* initialize write wait queue for this port */ 1566 init_waitqueue_head(&serial->port[i]->write_wait); 1567 1568 usb_set_serial_port_data(serial->port[i], priv); 1569 } 1570 1571 /* allocate serial private structure */ 1572 serial_priv = kmalloc(sizeof(struct digi_serial), GFP_KERNEL); 1573 if (serial_priv == NULL) { 1574 for (i = 0; i < serial->type->num_ports + 1; i++) 1575 kfree(usb_get_serial_port_data(serial->port[i])); 1576 return 1; /* error */ 1577 } 1578 1579 /* initialize serial private structure */ 1580 spin_lock_init(&serial_priv->ds_serial_lock); 1581 serial_priv->ds_oob_port_num = serial->type->num_ports; 1582 serial_priv->ds_oob_port = serial->port[serial_priv->ds_oob_port_num]; 1583 serial_priv->ds_device_started = 0; 1584 usb_set_serial_data(serial, serial_priv); 1585 1586 return 0; 1587 } 1588 1589 1590 static void digi_shutdown(struct usb_serial *serial) 1591 { 1592 int i; 1593 dbg("digi_shutdown: TOP, in_interrupt()=%ld", in_interrupt()); 1594 1595 /* stop reads and writes on all ports */ 1596 for (i = 0; i < serial->type->num_ports + 1; i++) { 1597 usb_kill_urb(serial->port[i]->read_urb); 1598 usb_kill_urb(serial->port[i]->write_urb); 1599 } 1600 1601 /* free the private data structures for all ports */ 1602 /* number of regular ports + 1 for the out-of-band port */ 1603 for(i = 0; i < serial->type->num_ports + 1; i++) 1604 kfree(usb_get_serial_port_data(serial->port[i])); 1605 kfree(usb_get_serial_data(serial)); 1606 } 1607 1608 1609 static void digi_read_bulk_callback(struct urb *urb) 1610 { 1611 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 1612 struct digi_port *priv; 1613 struct digi_serial *serial_priv; 1614 int ret; 1615 int status = urb->status; 1616 1617 dbg("digi_read_bulk_callback: TOP"); 1618 1619 /* port sanity check, do not resubmit if port is not valid */ 1620 if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) { 1621 err("%s: port or port->private is NULL, status=%d", 1622 __FUNCTION__, status); 1623 return; 1624 } 1625 if (port->serial == NULL || 1626 (serial_priv=usb_get_serial_data(port->serial)) == NULL) { 1627 err("%s: serial is bad or serial->private is NULL, status=%d", 1628 __FUNCTION__, status); 1629 return; 1630 } 1631 1632 /* do not resubmit urb if it has any status error */ 1633 if (status) { 1634 err("%s: nonzero read bulk status: status=%d, port=%d", 1635 __FUNCTION__, status, priv->dp_port_num); 1636 return; 1637 } 1638 1639 /* handle oob or inb callback, do not resubmit if error */ 1640 if (priv->dp_port_num == serial_priv->ds_oob_port_num) { 1641 if (digi_read_oob_callback(urb) != 0) 1642 return; 1643 } else { 1644 if (digi_read_inb_callback(urb) != 0) 1645 return; 1646 } 1647 1648 /* continue read */ 1649 urb->dev = port->serial->dev; 1650 if ((ret = usb_submit_urb(urb, GFP_ATOMIC)) != 0) { 1651 err("%s: failed resubmitting urb, ret=%d, port=%d", 1652 __FUNCTION__, ret, priv->dp_port_num); 1653 } 1654 1655 } 1656 1657 /* 1658 * Digi Read INB Callback 1659 * 1660 * Digi Read INB Callback handles reads on the in band ports, sending 1661 * the data on to the tty subsystem. When called we know port and 1662 * port->private are not NULL and port->serial has been validated. 1663 * It returns 0 if successful, 1 if successful but the port is 1664 * throttled, and -1 if the sanity checks failed. 1665 */ 1666 1667 static int digi_read_inb_callback(struct urb *urb) 1668 { 1669 1670 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 1671 struct tty_struct *tty = port->tty; 1672 struct digi_port *priv = usb_get_serial_port_data(port); 1673 int opcode = ((unsigned char *)urb->transfer_buffer)[0]; 1674 int len = ((unsigned char *)urb->transfer_buffer)[1]; 1675 int port_status = ((unsigned char *)urb->transfer_buffer)[2]; 1676 unsigned char *data = ((unsigned char *)urb->transfer_buffer)+3; 1677 int flag,throttled; 1678 int i; 1679 int status = urb->status; 1680 1681 /* do not process callbacks on closed ports */ 1682 /* but do continue the read chain */ 1683 if (port->open_count == 0) 1684 return 0; 1685 1686 /* short/multiple packet check */ 1687 if (urb->actual_length != len + 2) { 1688 err("%s: INCOMPLETE OR MULTIPLE PACKET, urb->status=%d, " 1689 "port=%d, opcode=%d, len=%d, actual_length=%d, " 1690 "status=%d", __FUNCTION__, status, priv->dp_port_num, 1691 opcode, len, urb->actual_length, port_status); 1692 return -1; 1693 } 1694 1695 spin_lock(&priv->dp_port_lock); 1696 1697 /* check for throttle; if set, do not resubmit read urb */ 1698 /* indicate the read chain needs to be restarted on unthrottle */ 1699 throttled = priv->dp_throttled; 1700 if (throttled) 1701 priv->dp_throttle_restart = 1; 1702 1703 /* receive data */ 1704 if (opcode == DIGI_CMD_RECEIVE_DATA) { 1705 /* get flag from port_status */ 1706 flag = 0; 1707 1708 /* overrun is special, not associated with a char */ 1709 if (port_status & DIGI_OVERRUN_ERROR) 1710 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 1711 1712 /* break takes precedence over parity, */ 1713 /* which takes precedence over framing errors */ 1714 if (port_status & DIGI_BREAK_ERROR) 1715 flag = TTY_BREAK; 1716 else if (port_status & DIGI_PARITY_ERROR) 1717 flag = TTY_PARITY; 1718 else if (port_status & DIGI_FRAMING_ERROR) 1719 flag = TTY_FRAME; 1720 1721 /* data length is len-1 (one byte of len is port_status) */ 1722 --len; 1723 1724 len = tty_buffer_request_room(tty, len); 1725 if (len > 0) { 1726 /* Hot path */ 1727 if (flag == TTY_NORMAL) 1728 tty_insert_flip_string(tty, data, len); 1729 else { 1730 for(i = 0; i < len; i++) 1731 tty_insert_flip_char(tty, data[i], flag); 1732 } 1733 tty_flip_buffer_push(tty); 1734 } 1735 } 1736 spin_unlock(&priv->dp_port_lock); 1737 1738 if (opcode == DIGI_CMD_RECEIVE_DISABLE) 1739 dbg("%s: got RECEIVE_DISABLE", __FUNCTION__); 1740 else if (opcode != DIGI_CMD_RECEIVE_DATA) 1741 dbg("%s: unknown opcode: %d", __FUNCTION__, opcode); 1742 1743 return(throttled ? 1 : 0); 1744 1745 } 1746 1747 1748 /* 1749 * Digi Read OOB Callback 1750 * 1751 * Digi Read OOB Callback handles reads on the out of band port. 1752 * When called we know port and port->private are not NULL and 1753 * the port->serial is valid. It returns 0 if successful, and 1754 * -1 if the sanity checks failed. 1755 */ 1756 1757 static int digi_read_oob_callback(struct urb *urb) 1758 { 1759 1760 struct usb_serial_port *port = (struct usb_serial_port *)urb->context; 1761 struct usb_serial *serial = port->serial; 1762 struct digi_port *priv = usb_get_serial_port_data(port); 1763 int opcode, line, status, val; 1764 int i; 1765 1766 dbg("digi_read_oob_callback: port=%d, len=%d", 1767 priv->dp_port_num, urb->actual_length); 1768 1769 /* handle each oob command */ 1770 for(i = 0; i < urb->actual_length - 3;) { 1771 opcode = ((unsigned char *)urb->transfer_buffer)[i++]; 1772 line = ((unsigned char *)urb->transfer_buffer)[i++]; 1773 status = ((unsigned char *)urb->transfer_buffer)[i++]; 1774 val = ((unsigned char *)urb->transfer_buffer)[i++]; 1775 1776 dbg("digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d", 1777 opcode, line, status, val); 1778 1779 if (status != 0 || line >= serial->type->num_ports) 1780 continue; 1781 1782 port = serial->port[line]; 1783 1784 if ((priv=usb_get_serial_port_data(port)) == NULL) 1785 return -1; 1786 1787 if (opcode == DIGI_CMD_READ_INPUT_SIGNALS) { 1788 spin_lock(&priv->dp_port_lock); 1789 /* convert from digi flags to termiox flags */ 1790 if (val & DIGI_READ_INPUT_SIGNALS_CTS) { 1791 priv->dp_modem_signals |= TIOCM_CTS; 1792 /* port must be open to use tty struct */ 1793 if (port->open_count 1794 && port->tty->termios->c_cflag & CRTSCTS) { 1795 port->tty->hw_stopped = 0; 1796 digi_wakeup_write(port); 1797 } 1798 } else { 1799 priv->dp_modem_signals &= ~TIOCM_CTS; 1800 /* port must be open to use tty struct */ 1801 if (port->open_count 1802 && port->tty->termios->c_cflag & CRTSCTS) { 1803 port->tty->hw_stopped = 1; 1804 } 1805 } 1806 if (val & DIGI_READ_INPUT_SIGNALS_DSR) 1807 priv->dp_modem_signals |= TIOCM_DSR; 1808 else 1809 priv->dp_modem_signals &= ~TIOCM_DSR; 1810 if (val & DIGI_READ_INPUT_SIGNALS_RI) 1811 priv->dp_modem_signals |= TIOCM_RI; 1812 else 1813 priv->dp_modem_signals &= ~TIOCM_RI; 1814 if (val & DIGI_READ_INPUT_SIGNALS_DCD) 1815 priv->dp_modem_signals |= TIOCM_CD; 1816 else 1817 priv->dp_modem_signals &= ~TIOCM_CD; 1818 1819 wake_up_interruptible(&priv->dp_modem_change_wait); 1820 spin_unlock(&priv->dp_port_lock); 1821 } else if (opcode == DIGI_CMD_TRANSMIT_IDLE) { 1822 spin_lock(&priv->dp_port_lock); 1823 priv->dp_transmit_idle = 1; 1824 wake_up_interruptible(&priv->dp_transmit_idle_wait); 1825 spin_unlock(&priv->dp_port_lock); 1826 } else if (opcode == DIGI_CMD_IFLUSH_FIFO) { 1827 wake_up_interruptible(&priv->dp_flush_wait); 1828 } 1829 } 1830 return 0; 1831 1832 } 1833 1834 static int __init digi_init(void) 1835 { 1836 int retval; 1837 retval = usb_serial_register(&digi_acceleport_2_device); 1838 if (retval) 1839 goto failed_acceleport_2_device; 1840 retval = usb_serial_register(&digi_acceleport_4_device); 1841 if (retval) 1842 goto failed_acceleport_4_device; 1843 retval = usb_register(&digi_driver); 1844 if (retval) 1845 goto failed_usb_register; 1846 info(DRIVER_VERSION ":" DRIVER_DESC); 1847 return 0; 1848 failed_usb_register: 1849 usb_serial_deregister(&digi_acceleport_4_device); 1850 failed_acceleport_4_device: 1851 usb_serial_deregister(&digi_acceleport_2_device); 1852 failed_acceleport_2_device: 1853 return retval; 1854 } 1855 1856 static void __exit digi_exit (void) 1857 { 1858 usb_deregister(&digi_driver); 1859 usb_serial_deregister(&digi_acceleport_2_device); 1860 usb_serial_deregister(&digi_acceleport_4_device); 1861 } 1862 1863 1864 module_init(digi_init); 1865 module_exit(digi_exit); 1866 1867 1868 MODULE_AUTHOR(DRIVER_AUTHOR); 1869 MODULE_DESCRIPTION(DRIVER_DESC); 1870 MODULE_LICENSE("GPL"); 1871 1872 module_param(debug, bool, S_IRUGO | S_IWUSR); 1873 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1874