1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * USB Keyspan PDA / Xircom / Entrega Converter driver
4 *
5 * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <greg@kroah.com>
6 * Copyright (C) 1999, 2000 Brian Warner <warner@lothar.com>
7 * Copyright (C) 2000 Al Borchers <borchers@steinerpoint.com>
8 *
9 * See Documentation/usb/usb-serial.rst for more information on using this
10 * driver
11 */
12
13
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/tty.h>
18 #include <linux/tty_driver.h>
19 #include <linux/tty_flip.h>
20 #include <linux/module.h>
21 #include <linux/spinlock.h>
22 #include <linux/workqueue.h>
23 #include <linux/uaccess.h>
24 #include <linux/usb.h>
25 #include <linux/usb/serial.h>
26 #include <linux/usb/ezusb.h>
27
28 /* make a simple define to handle if we are compiling keyspan_pda or xircom support */
29 #if IS_ENABLED(CONFIG_USB_SERIAL_KEYSPAN_PDA)
30 #define KEYSPAN
31 #else
32 #undef KEYSPAN
33 #endif
34 #if IS_ENABLED(CONFIG_USB_SERIAL_XIRCOM)
35 #define XIRCOM
36 #else
37 #undef XIRCOM
38 #endif
39
40 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
41 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
42
43 struct keyspan_pda_private {
44 int tx_room;
45 int tx_throttled;
46 struct work_struct wakeup_work;
47 struct work_struct unthrottle_work;
48 struct usb_serial *serial;
49 struct usb_serial_port *port;
50 };
51
52
53 #define KEYSPAN_VENDOR_ID 0x06cd
54 #define KEYSPAN_PDA_FAKE_ID 0x0103
55 #define KEYSPAN_PDA_ID 0x0104 /* no clue */
56
57 /* For Xircom PGSDB9 and older Entrega version of the same device */
58 #define XIRCOM_VENDOR_ID 0x085a
59 #define XIRCOM_FAKE_ID 0x8027
60 #define XIRCOM_FAKE_ID_2 0x8025 /* "PGMFHUB" serial */
61 #define ENTREGA_VENDOR_ID 0x1645
62 #define ENTREGA_FAKE_ID 0x8093
63
64 static const struct usb_device_id id_table_combined[] = {
65 #ifdef KEYSPAN
66 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
67 #endif
68 #ifdef XIRCOM
69 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
70 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
71 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
72 #endif
73 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
74 { } /* Terminating entry */
75 };
76
77 MODULE_DEVICE_TABLE(usb, id_table_combined);
78
79 static const struct usb_device_id id_table_std[] = {
80 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
81 { } /* Terminating entry */
82 };
83
84 #ifdef KEYSPAN
85 static const struct usb_device_id id_table_fake[] = {
86 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
87 { } /* Terminating entry */
88 };
89 #endif
90
91 #ifdef XIRCOM
92 static const struct usb_device_id id_table_fake_xircom[] = {
93 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
94 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
95 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
96 { }
97 };
98 #endif
99
keyspan_pda_wakeup_write(struct work_struct * work)100 static void keyspan_pda_wakeup_write(struct work_struct *work)
101 {
102 struct keyspan_pda_private *priv =
103 container_of(work, struct keyspan_pda_private, wakeup_work);
104 struct usb_serial_port *port = priv->port;
105
106 tty_port_tty_wakeup(&port->port);
107 }
108
keyspan_pda_request_unthrottle(struct work_struct * work)109 static void keyspan_pda_request_unthrottle(struct work_struct *work)
110 {
111 struct keyspan_pda_private *priv =
112 container_of(work, struct keyspan_pda_private, unthrottle_work);
113 struct usb_serial *serial = priv->serial;
114 int result;
115
116 /* ask the device to tell us when the tx buffer becomes
117 sufficiently empty */
118 result = usb_control_msg(serial->dev,
119 usb_sndctrlpipe(serial->dev, 0),
120 7, /* request_unthrottle */
121 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
122 | USB_DIR_OUT,
123 16, /* value: threshold */
124 0, /* index */
125 NULL,
126 0,
127 2000);
128 if (result < 0)
129 dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
130 __func__, result);
131 }
132
133
keyspan_pda_rx_interrupt(struct urb * urb)134 static void keyspan_pda_rx_interrupt(struct urb *urb)
135 {
136 struct usb_serial_port *port = urb->context;
137 unsigned char *data = urb->transfer_buffer;
138 unsigned int len = urb->actual_length;
139 int retval;
140 int status = urb->status;
141 struct keyspan_pda_private *priv;
142 priv = usb_get_serial_port_data(port);
143
144 switch (status) {
145 case 0:
146 /* success */
147 break;
148 case -ECONNRESET:
149 case -ENOENT:
150 case -ESHUTDOWN:
151 /* this urb is terminated, clean up */
152 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
153 return;
154 default:
155 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
156 goto exit;
157 }
158
159 if (len < 1) {
160 dev_warn(&port->dev, "short message received\n");
161 goto exit;
162 }
163
164 /* see if the message is data or a status interrupt */
165 switch (data[0]) {
166 case 0:
167 /* rest of message is rx data */
168 if (len < 2)
169 break;
170 tty_insert_flip_string(&port->port, data + 1, len - 1);
171 tty_flip_buffer_push(&port->port);
172 break;
173 case 1:
174 /* status interrupt */
175 if (len < 3) {
176 dev_warn(&port->dev, "short interrupt message received\n");
177 break;
178 }
179 dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]);
180 switch (data[1]) {
181 case 1: /* modemline change */
182 break;
183 case 2: /* tx unthrottle interrupt */
184 priv->tx_throttled = 0;
185 /* queue up a wakeup at scheduler time */
186 schedule_work(&priv->wakeup_work);
187 break;
188 default:
189 break;
190 }
191 break;
192 default:
193 break;
194 }
195
196 exit:
197 retval = usb_submit_urb(urb, GFP_ATOMIC);
198 if (retval)
199 dev_err(&port->dev,
200 "%s - usb_submit_urb failed with result %d\n",
201 __func__, retval);
202 }
203
204
keyspan_pda_rx_throttle(struct tty_struct * tty)205 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
206 {
207 /* stop receiving characters. We just turn off the URB request, and
208 let chars pile up in the device. If we're doing hardware
209 flowcontrol, the device will signal the other end when its buffer
210 fills up. If we're doing XON/XOFF, this would be a good time to
211 send an XOFF, although it might make sense to foist that off
212 upon the device too. */
213 struct usb_serial_port *port = tty->driver_data;
214
215 usb_kill_urb(port->interrupt_in_urb);
216 }
217
218
keyspan_pda_rx_unthrottle(struct tty_struct * tty)219 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
220 {
221 struct usb_serial_port *port = tty->driver_data;
222 /* just restart the receive interrupt URB */
223
224 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
225 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
226 }
227
228
keyspan_pda_setbaud(struct usb_serial * serial,speed_t baud)229 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
230 {
231 int rc;
232 int bindex;
233
234 switch (baud) {
235 case 110:
236 bindex = 0;
237 break;
238 case 300:
239 bindex = 1;
240 break;
241 case 1200:
242 bindex = 2;
243 break;
244 case 2400:
245 bindex = 3;
246 break;
247 case 4800:
248 bindex = 4;
249 break;
250 case 9600:
251 bindex = 5;
252 break;
253 case 19200:
254 bindex = 6;
255 break;
256 case 38400:
257 bindex = 7;
258 break;
259 case 57600:
260 bindex = 8;
261 break;
262 case 115200:
263 bindex = 9;
264 break;
265 default:
266 bindex = 5; /* Default to 9600 */
267 baud = 9600;
268 }
269
270 /* rather than figure out how to sleep while waiting for this
271 to complete, I just use the "legacy" API. */
272 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
273 0, /* set baud */
274 USB_TYPE_VENDOR
275 | USB_RECIP_INTERFACE
276 | USB_DIR_OUT, /* type */
277 bindex, /* value */
278 0, /* index */
279 NULL, /* &data */
280 0, /* size */
281 2000); /* timeout */
282 if (rc < 0)
283 return 0;
284 return baud;
285 }
286
287
keyspan_pda_break_ctl(struct tty_struct * tty,int break_state)288 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
289 {
290 struct usb_serial_port *port = tty->driver_data;
291 struct usb_serial *serial = port->serial;
292 int value;
293 int result;
294
295 if (break_state == -1)
296 value = 1; /* start break */
297 else
298 value = 0; /* clear break */
299 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
300 4, /* set break */
301 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
302 value, 0, NULL, 0, 2000);
303 if (result < 0)
304 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
305 __func__, result);
306 /* there is something funky about this.. the TCSBRK that 'cu' performs
307 ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
308 seconds apart, but it feels like the break sent isn't as long as it
309 is on /dev/ttyS0 */
310 }
311
312
keyspan_pda_set_termios(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)313 static void keyspan_pda_set_termios(struct tty_struct *tty,
314 struct usb_serial_port *port, struct ktermios *old_termios)
315 {
316 struct usb_serial *serial = port->serial;
317 speed_t speed;
318
319 /* cflag specifies lots of stuff: number of stop bits, parity, number
320 of data bits, baud. What can the device actually handle?:
321 CSTOPB (1 stop bit or 2)
322 PARENB (parity)
323 CSIZE (5bit .. 8bit)
324 There is minimal hw support for parity (a PSW bit seems to hold the
325 parity of whatever is in the accumulator). The UART either deals
326 with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
327 1 special, stop). So, with firmware changes, we could do:
328 8N1: 10 bit
329 8N2: 11 bit, extra bit always (mark?)
330 8[EOMS]1: 11 bit, extra bit is parity
331 7[EOMS]1: 10 bit, b0/b7 is parity
332 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
333
334 HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
335 bit.
336
337 For now, just do baud. */
338
339 speed = tty_get_baud_rate(tty);
340 speed = keyspan_pda_setbaud(serial, speed);
341
342 if (speed == 0) {
343 dev_dbg(&port->dev, "can't handle requested baud rate\n");
344 /* It hasn't changed so.. */
345 speed = tty_termios_baud_rate(old_termios);
346 }
347 /* Only speed can change so copy the old h/w parameters
348 then encode the new speed */
349 tty_termios_copy_hw(&tty->termios, old_termios);
350 tty_encode_baud_rate(tty, speed, speed);
351 }
352
353
354 /* modem control pins: DTR and RTS are outputs and can be controlled.
355 DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
356 read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
357
keyspan_pda_get_modem_info(struct usb_serial * serial,unsigned char * value)358 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
359 unsigned char *value)
360 {
361 int rc;
362 u8 *data;
363
364 data = kmalloc(1, GFP_KERNEL);
365 if (!data)
366 return -ENOMEM;
367
368 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
369 3, /* get pins */
370 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
371 0, 0, data, 1, 2000);
372 if (rc == 1)
373 *value = *data;
374 else if (rc >= 0)
375 rc = -EIO;
376
377 kfree(data);
378 return rc;
379 }
380
381
keyspan_pda_set_modem_info(struct usb_serial * serial,unsigned char value)382 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
383 unsigned char value)
384 {
385 int rc;
386 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
387 3, /* set pins */
388 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
389 value, 0, NULL, 0, 2000);
390 return rc;
391 }
392
keyspan_pda_tiocmget(struct tty_struct * tty)393 static int keyspan_pda_tiocmget(struct tty_struct *tty)
394 {
395 struct usb_serial_port *port = tty->driver_data;
396 struct usb_serial *serial = port->serial;
397 int rc;
398 unsigned char status;
399 int value;
400
401 rc = keyspan_pda_get_modem_info(serial, &status);
402 if (rc < 0)
403 return rc;
404 value =
405 ((status & (1<<7)) ? TIOCM_DTR : 0) |
406 ((status & (1<<6)) ? TIOCM_CAR : 0) |
407 ((status & (1<<5)) ? TIOCM_RNG : 0) |
408 ((status & (1<<4)) ? TIOCM_DSR : 0) |
409 ((status & (1<<3)) ? TIOCM_CTS : 0) |
410 ((status & (1<<2)) ? TIOCM_RTS : 0);
411 return value;
412 }
413
keyspan_pda_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)414 static int keyspan_pda_tiocmset(struct tty_struct *tty,
415 unsigned int set, unsigned int clear)
416 {
417 struct usb_serial_port *port = tty->driver_data;
418 struct usb_serial *serial = port->serial;
419 int rc;
420 unsigned char status;
421
422 rc = keyspan_pda_get_modem_info(serial, &status);
423 if (rc < 0)
424 return rc;
425
426 if (set & TIOCM_RTS)
427 status |= (1<<2);
428 if (set & TIOCM_DTR)
429 status |= (1<<7);
430
431 if (clear & TIOCM_RTS)
432 status &= ~(1<<2);
433 if (clear & TIOCM_DTR)
434 status &= ~(1<<7);
435 rc = keyspan_pda_set_modem_info(serial, status);
436 return rc;
437 }
438
keyspan_pda_write(struct tty_struct * tty,struct usb_serial_port * port,const unsigned char * buf,int count)439 static int keyspan_pda_write(struct tty_struct *tty,
440 struct usb_serial_port *port, const unsigned char *buf, int count)
441 {
442 struct usb_serial *serial = port->serial;
443 int request_unthrottle = 0;
444 int rc = 0;
445 struct keyspan_pda_private *priv;
446
447 priv = usb_get_serial_port_data(port);
448 /* guess how much room is left in the device's ring buffer, and if we
449 want to send more than that, check first, updating our notion of
450 what is left. If our write will result in no room left, ask the
451 device to give us an interrupt when the room available rises above
452 a threshold, and hold off all writers (eventually, those using
453 select() or poll() too) until we receive that unthrottle interrupt.
454 Block if we can't write anything at all, otherwise write as much as
455 we can. */
456 if (count == 0) {
457 dev_dbg(&port->dev, "write request of 0 bytes\n");
458 return 0;
459 }
460
461 /* we might block because of:
462 the TX urb is in-flight (wait until it completes)
463 the device is full (wait until it says there is room)
464 */
465 spin_lock_bh(&port->lock);
466 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
467 spin_unlock_bh(&port->lock);
468 return 0;
469 }
470 clear_bit(0, &port->write_urbs_free);
471 spin_unlock_bh(&port->lock);
472
473 /* At this point the URB is in our control, nobody else can submit it
474 again (the only sudden transition was the one from EINPROGRESS to
475 finished). Also, the tx process is not throttled. So we are
476 ready to write. */
477
478 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
479
480 /* Check if we might overrun the Tx buffer. If so, ask the
481 device how much room it really has. This is done only on
482 scheduler time, since usb_control_msg() sleeps. */
483 if (count > priv->tx_room && !in_interrupt()) {
484 u8 *room;
485
486 room = kmalloc(1, GFP_KERNEL);
487 if (!room) {
488 rc = -ENOMEM;
489 goto exit;
490 }
491
492 rc = usb_control_msg(serial->dev,
493 usb_rcvctrlpipe(serial->dev, 0),
494 6, /* write_room */
495 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
496 | USB_DIR_IN,
497 0, /* value: 0 means "remaining room" */
498 0, /* index */
499 room,
500 1,
501 2000);
502 if (rc > 0) {
503 dev_dbg(&port->dev, "roomquery says %d\n", *room);
504 priv->tx_room = *room;
505 }
506 kfree(room);
507 if (rc < 0) {
508 dev_dbg(&port->dev, "roomquery failed\n");
509 goto exit;
510 }
511 if (rc == 0) {
512 dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
513 rc = -EIO; /* device didn't return any data */
514 goto exit;
515 }
516 }
517 if (count > priv->tx_room) {
518 /* we're about to completely fill the Tx buffer, so
519 we'll be throttled afterwards. */
520 count = priv->tx_room;
521 request_unthrottle = 1;
522 }
523
524 if (count) {
525 /* now transfer data */
526 memcpy(port->write_urb->transfer_buffer, buf, count);
527 /* send the data out the bulk port */
528 port->write_urb->transfer_buffer_length = count;
529
530 priv->tx_room -= count;
531
532 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
533 if (rc) {
534 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
535 goto exit;
536 }
537 } else {
538 /* There wasn't any room left, so we are throttled until
539 the buffer empties a bit */
540 request_unthrottle = 1;
541 }
542
543 if (request_unthrottle) {
544 priv->tx_throttled = 1; /* block writers */
545 schedule_work(&priv->unthrottle_work);
546 }
547
548 rc = count;
549 exit:
550 if (rc < 0)
551 set_bit(0, &port->write_urbs_free);
552 return rc;
553 }
554
555
keyspan_pda_write_bulk_callback(struct urb * urb)556 static void keyspan_pda_write_bulk_callback(struct urb *urb)
557 {
558 struct usb_serial_port *port = urb->context;
559 struct keyspan_pda_private *priv;
560
561 set_bit(0, &port->write_urbs_free);
562 priv = usb_get_serial_port_data(port);
563
564 /* queue up a wakeup at scheduler time */
565 schedule_work(&priv->wakeup_work);
566 }
567
568
keyspan_pda_write_room(struct tty_struct * tty)569 static int keyspan_pda_write_room(struct tty_struct *tty)
570 {
571 struct usb_serial_port *port = tty->driver_data;
572 struct keyspan_pda_private *priv;
573 priv = usb_get_serial_port_data(port);
574 /* used by n_tty.c for processing of tabs and such. Giving it our
575 conservative guess is probably good enough, but needs testing by
576 running a console through the device. */
577 return priv->tx_room;
578 }
579
580
keyspan_pda_chars_in_buffer(struct tty_struct * tty)581 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
582 {
583 struct usb_serial_port *port = tty->driver_data;
584 struct keyspan_pda_private *priv;
585 unsigned long flags;
586 int ret = 0;
587
588 priv = usb_get_serial_port_data(port);
589
590 /* when throttled, return at least WAKEUP_CHARS to tell select() (via
591 n_tty.c:normal_poll() ) that we're not writeable. */
592
593 spin_lock_irqsave(&port->lock, flags);
594 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
595 ret = 256;
596 spin_unlock_irqrestore(&port->lock, flags);
597 return ret;
598 }
599
600
keyspan_pda_dtr_rts(struct usb_serial_port * port,int on)601 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
602 {
603 struct usb_serial *serial = port->serial;
604
605 if (on)
606 keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2));
607 else
608 keyspan_pda_set_modem_info(serial, 0);
609 }
610
611
keyspan_pda_open(struct tty_struct * tty,struct usb_serial_port * port)612 static int keyspan_pda_open(struct tty_struct *tty,
613 struct usb_serial_port *port)
614 {
615 struct usb_serial *serial = port->serial;
616 u8 *room;
617 int rc = 0;
618 struct keyspan_pda_private *priv;
619
620 /* find out how much room is in the Tx ring */
621 room = kmalloc(1, GFP_KERNEL);
622 if (!room)
623 return -ENOMEM;
624
625 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
626 6, /* write_room */
627 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
628 | USB_DIR_IN,
629 0, /* value */
630 0, /* index */
631 room,
632 1,
633 2000);
634 if (rc < 0) {
635 dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
636 goto error;
637 }
638 if (rc == 0) {
639 dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
640 rc = -EIO;
641 goto error;
642 }
643 priv = usb_get_serial_port_data(port);
644 priv->tx_room = *room;
645 priv->tx_throttled = *room ? 0 : 1;
646
647 /*Start reading from the device*/
648 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
649 if (rc) {
650 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
651 goto error;
652 }
653 error:
654 kfree(room);
655 return rc;
656 }
keyspan_pda_close(struct usb_serial_port * port)657 static void keyspan_pda_close(struct usb_serial_port *port)
658 {
659 usb_kill_urb(port->write_urb);
660 usb_kill_urb(port->interrupt_in_urb);
661 }
662
663
664 /* download the firmware to a "fake" device (pre-renumeration) */
keyspan_pda_fake_startup(struct usb_serial * serial)665 static int keyspan_pda_fake_startup(struct usb_serial *serial)
666 {
667 const char *fw_name;
668
669 /* download the firmware here ... */
670 ezusb_fx1_set_reset(serial->dev, 1);
671
672 if (0) { ; }
673 #ifdef KEYSPAN
674 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
675 fw_name = "keyspan_pda/keyspan_pda.fw";
676 #endif
677 #ifdef XIRCOM
678 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
679 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID))
680 fw_name = "keyspan_pda/xircom_pgs.fw";
681 #endif
682 else {
683 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
684 __func__);
685 return -ENODEV;
686 }
687
688 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
689 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
690 fw_name);
691 return -ENOENT;
692 }
693
694 /* after downloading firmware Renumeration will occur in a
695 moment and the new device will bind to the real driver */
696
697 /* we want this device to fail to have a driver assigned to it. */
698 return 1;
699 }
700
701 #ifdef KEYSPAN
702 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
703 #endif
704 #ifdef XIRCOM
705 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
706 #endif
707
keyspan_pda_port_probe(struct usb_serial_port * port)708 static int keyspan_pda_port_probe(struct usb_serial_port *port)
709 {
710
711 struct keyspan_pda_private *priv;
712
713 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
714 if (!priv)
715 return -ENOMEM;
716
717 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
718 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
719 priv->serial = port->serial;
720 priv->port = port;
721
722 usb_set_serial_port_data(port, priv);
723
724 return 0;
725 }
726
keyspan_pda_port_remove(struct usb_serial_port * port)727 static int keyspan_pda_port_remove(struct usb_serial_port *port)
728 {
729 struct keyspan_pda_private *priv;
730
731 priv = usb_get_serial_port_data(port);
732 kfree(priv);
733
734 return 0;
735 }
736
737 #ifdef KEYSPAN
738 static struct usb_serial_driver keyspan_pda_fake_device = {
739 .driver = {
740 .owner = THIS_MODULE,
741 .name = "keyspan_pda_pre",
742 },
743 .description = "Keyspan PDA - (prerenumeration)",
744 .id_table = id_table_fake,
745 .num_ports = 1,
746 .attach = keyspan_pda_fake_startup,
747 };
748 #endif
749
750 #ifdef XIRCOM
751 static struct usb_serial_driver xircom_pgs_fake_device = {
752 .driver = {
753 .owner = THIS_MODULE,
754 .name = "xircom_no_firm",
755 },
756 .description = "Xircom / Entrega PGS - (prerenumeration)",
757 .id_table = id_table_fake_xircom,
758 .num_ports = 1,
759 .attach = keyspan_pda_fake_startup,
760 };
761 #endif
762
763 static struct usb_serial_driver keyspan_pda_device = {
764 .driver = {
765 .owner = THIS_MODULE,
766 .name = "keyspan_pda",
767 },
768 .description = "Keyspan PDA",
769 .id_table = id_table_std,
770 .num_ports = 1,
771 .num_bulk_out = 1,
772 .num_interrupt_in = 1,
773 .dtr_rts = keyspan_pda_dtr_rts,
774 .open = keyspan_pda_open,
775 .close = keyspan_pda_close,
776 .write = keyspan_pda_write,
777 .write_room = keyspan_pda_write_room,
778 .write_bulk_callback = keyspan_pda_write_bulk_callback,
779 .read_int_callback = keyspan_pda_rx_interrupt,
780 .chars_in_buffer = keyspan_pda_chars_in_buffer,
781 .throttle = keyspan_pda_rx_throttle,
782 .unthrottle = keyspan_pda_rx_unthrottle,
783 .set_termios = keyspan_pda_set_termios,
784 .break_ctl = keyspan_pda_break_ctl,
785 .tiocmget = keyspan_pda_tiocmget,
786 .tiocmset = keyspan_pda_tiocmset,
787 .port_probe = keyspan_pda_port_probe,
788 .port_remove = keyspan_pda_port_remove,
789 };
790
791 static struct usb_serial_driver * const serial_drivers[] = {
792 &keyspan_pda_device,
793 #ifdef KEYSPAN
794 &keyspan_pda_fake_device,
795 #endif
796 #ifdef XIRCOM
797 &xircom_pgs_fake_device,
798 #endif
799 NULL
800 };
801
802 module_usb_serial_driver(serial_drivers, id_table_combined);
803
804 MODULE_AUTHOR(DRIVER_AUTHOR);
805 MODULE_DESCRIPTION(DRIVER_DESC);
806 MODULE_LICENSE("GPL");
807
