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