1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71#include <linux/kernel.h>
72#include <linux/errno.h>
73#include <linux/init.h>
74#include <linux/slab.h>
75#include <linux/tty.h>
76#include <linux/tty_driver.h>
77#include <linux/tty_flip.h>
78#include <linux/module.h>
79#include <linux/spinlock.h>
80#include <linux/workqueue.h>
81#include <linux/firmware.h>
82#include <linux/ihex.h>
83#include <linux/uaccess.h>
84#include <linux/usb.h>
85#include <linux/usb/serial.h>
86
87static int debug;
88
89
90#if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
91 #define KEYSPAN
92#else
93 #undef KEYSPAN
94#endif
95#if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
96 #define XIRCOM
97#else
98 #undef XIRCOM
99#endif
100
101
102
103
104#define DRIVER_VERSION "v1.1"
105#define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
106#define DRIVER_DESC "USB Keyspan PDA Converter driver"
107
108struct keyspan_pda_private {
109 int tx_room;
110 int tx_throttled;
111 struct work_struct wakeup_work;
112 struct work_struct unthrottle_work;
113 struct usb_serial *serial;
114 struct usb_serial_port *port;
115};
116
117
118#define KEYSPAN_VENDOR_ID 0x06cd
119#define KEYSPAN_PDA_FAKE_ID 0x0103
120#define KEYSPAN_PDA_ID 0x0104
121
122
123#define XIRCOM_VENDOR_ID 0x085a
124#define XIRCOM_FAKE_ID 0x8027
125#define ENTREGRA_VENDOR_ID 0x1645
126#define ENTREGRA_FAKE_ID 0x8093
127
128static const struct usb_device_id id_table_combined[] = {
129#ifdef KEYSPAN
130 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
131#endif
132#ifdef XIRCOM
133 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
134 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
135#endif
136 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
137 { }
138};
139
140MODULE_DEVICE_TABLE(usb, id_table_combined);
141
142static struct usb_driver keyspan_pda_driver = {
143 .name = "keyspan_pda",
144 .probe = usb_serial_probe,
145 .disconnect = usb_serial_disconnect,
146 .id_table = id_table_combined,
147 .no_dynamic_id = 1,
148};
149
150static const struct usb_device_id id_table_std[] = {
151 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
152 { }
153};
154
155#ifdef KEYSPAN
156static const struct usb_device_id id_table_fake[] = {
157 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
158 { }
159};
160#endif
161
162#ifdef XIRCOM
163static const struct usb_device_id id_table_fake_xircom[] = {
164 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
165 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
166 { }
167};
168#endif
169
170static void keyspan_pda_wakeup_write(struct work_struct *work)
171{
172 struct keyspan_pda_private *priv =
173 container_of(work, struct keyspan_pda_private, wakeup_work);
174 struct usb_serial_port *port = priv->port;
175 struct tty_struct *tty = tty_port_tty_get(&port->port);
176 tty_wakeup(tty);
177 tty_kref_put(tty);
178}
179
180static void keyspan_pda_request_unthrottle(struct work_struct *work)
181{
182 struct keyspan_pda_private *priv =
183 container_of(work, struct keyspan_pda_private, unthrottle_work);
184 struct usb_serial *serial = priv->serial;
185 int result;
186
187 dbg(" request_unthrottle");
188
189
190 result = usb_control_msg(serial->dev,
191 usb_sndctrlpipe(serial->dev, 0),
192 7,
193 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
194 | USB_DIR_OUT,
195 16,
196 0,
197 NULL,
198 0,
199 2000);
200 if (result < 0)
201 dbg("%s - error %d from usb_control_msg",
202 __func__, result);
203}
204
205
206static void keyspan_pda_rx_interrupt(struct urb *urb)
207{
208 struct usb_serial_port *port = urb->context;
209 struct tty_struct *tty = tty_port_tty_get(&port->port);
210 unsigned char *data = urb->transfer_buffer;
211 int retval;
212 int status = urb->status;
213 struct keyspan_pda_private *priv;
214 priv = usb_get_serial_port_data(port);
215
216 switch (status) {
217 case 0:
218
219 break;
220 case -ECONNRESET:
221 case -ENOENT:
222 case -ESHUTDOWN:
223
224 dbg("%s - urb shutting down with status: %d",
225 __func__, status);
226 goto out;
227 default:
228 dbg("%s - nonzero urb status received: %d",
229 __func__, status);
230 goto exit;
231 }
232
233
234 switch (data[0]) {
235 case 0:
236
237 if (urb->actual_length) {
238 tty_insert_flip_string(tty, data + 1,
239 urb->actual_length - 1);
240 tty_flip_buffer_push(tty);
241 }
242 break;
243 case 1:
244
245 dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
246 switch (data[1]) {
247 case 1:
248 break;
249 case 2:
250 priv->tx_throttled = 0;
251
252 schedule_work(&priv->wakeup_work);
253 break;
254 default:
255 break;
256 }
257 break;
258 default:
259 break;
260 }
261
262exit:
263 retval = usb_submit_urb(urb, GFP_ATOMIC);
264 if (retval)
265 dev_err(&port->dev,
266 "%s - usb_submit_urb failed with result %d",
267 __func__, retval);
268out:
269 tty_kref_put(tty);
270}
271
272
273static void keyspan_pda_rx_throttle(struct tty_struct *tty)
274{
275
276
277
278
279
280
281 struct usb_serial_port *port = tty->driver_data;
282 dbg("keyspan_pda_rx_throttle port %d", port->number);
283 usb_kill_urb(port->interrupt_in_urb);
284}
285
286
287static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
288{
289 struct usb_serial_port *port = tty->driver_data;
290
291 dbg("keyspan_pda_rx_unthrottle port %d", port->number);
292 port->interrupt_in_urb->dev = port->serial->dev;
293 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
294 dbg(" usb_submit_urb(read urb) failed");
295}
296
297
298static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
299{
300 int rc;
301 int bindex;
302
303 switch (baud) {
304 case 110:
305 bindex = 0;
306 break;
307 case 300:
308 bindex = 1;
309 break;
310 case 1200:
311 bindex = 2;
312 break;
313 case 2400:
314 bindex = 3;
315 break;
316 case 4800:
317 bindex = 4;
318 break;
319 case 9600:
320 bindex = 5;
321 break;
322 case 19200:
323 bindex = 6;
324 break;
325 case 38400:
326 bindex = 7;
327 break;
328 case 57600:
329 bindex = 8;
330 break;
331 case 115200:
332 bindex = 9;
333 break;
334 default:
335 bindex = 5;
336 baud = 9600;
337 }
338
339
340
341 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
342 0,
343 USB_TYPE_VENDOR
344 | USB_RECIP_INTERFACE
345 | USB_DIR_OUT,
346 bindex,
347 0,
348 NULL,
349 0,
350 2000);
351 if (rc < 0)
352 return 0;
353 return baud;
354}
355
356
357static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
358{
359 struct usb_serial_port *port = tty->driver_data;
360 struct usb_serial *serial = port->serial;
361 int value;
362 int result;
363
364 if (break_state == -1)
365 value = 1;
366 else
367 value = 0;
368 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
369 4,
370 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
371 value, 0, NULL, 0, 2000);
372 if (result < 0)
373 dbg("%s - error %d from usb_control_msg",
374 __func__, result);
375
376
377
378
379}
380
381
382static void keyspan_pda_set_termios(struct tty_struct *tty,
383 struct usb_serial_port *port, struct ktermios *old_termios)
384{
385 struct usb_serial *serial = port->serial;
386 speed_t speed;
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408 speed = tty_get_baud_rate(tty);
409 speed = keyspan_pda_setbaud(serial, speed);
410
411 if (speed == 0) {
412 dbg("can't handle requested baud rate");
413
414 speed = tty_termios_baud_rate(old_termios);
415 }
416
417
418 tty_termios_copy_hw(tty->termios, old_termios);
419 tty_encode_baud_rate(tty, speed, speed);
420}
421
422
423
424
425
426
427static int keyspan_pda_get_modem_info(struct usb_serial *serial,
428 unsigned char *value)
429{
430 int rc;
431 u8 *data;
432
433 data = kmalloc(1, GFP_KERNEL);
434 if (!data)
435 return -ENOMEM;
436
437 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
438 3,
439 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
440 0, 0, data, 1, 2000);
441 if (rc >= 0)
442 *value = *data;
443
444 kfree(data);
445 return rc;
446}
447
448
449static int keyspan_pda_set_modem_info(struct usb_serial *serial,
450 unsigned char value)
451{
452 int rc;
453 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
454 3,
455 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
456 value, 0, NULL, 0, 2000);
457 return rc;
458}
459
460static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
461{
462 struct usb_serial_port *port = tty->driver_data;
463 struct usb_serial *serial = port->serial;
464 int rc;
465 unsigned char status;
466 int value;
467
468 rc = keyspan_pda_get_modem_info(serial, &status);
469 if (rc < 0)
470 return rc;
471 value =
472 ((status & (1<<7)) ? TIOCM_DTR : 0) |
473 ((status & (1<<6)) ? TIOCM_CAR : 0) |
474 ((status & (1<<5)) ? TIOCM_RNG : 0) |
475 ((status & (1<<4)) ? TIOCM_DSR : 0) |
476 ((status & (1<<3)) ? TIOCM_CTS : 0) |
477 ((status & (1<<2)) ? TIOCM_RTS : 0);
478 return value;
479}
480
481static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
482 unsigned int set, unsigned int clear)
483{
484 struct usb_serial_port *port = tty->driver_data;
485 struct usb_serial *serial = port->serial;
486 int rc;
487 unsigned char status;
488
489 rc = keyspan_pda_get_modem_info(serial, &status);
490 if (rc < 0)
491 return rc;
492
493 if (set & TIOCM_RTS)
494 status |= (1<<2);
495 if (set & TIOCM_DTR)
496 status |= (1<<7);
497
498 if (clear & TIOCM_RTS)
499 status &= ~(1<<2);
500 if (clear & TIOCM_DTR)
501 status &= ~(1<<7);
502 rc = keyspan_pda_set_modem_info(serial, status);
503 return rc;
504}
505
506static int keyspan_pda_write(struct tty_struct *tty,
507 struct usb_serial_port *port, const unsigned char *buf, int count)
508{
509 struct usb_serial *serial = port->serial;
510 int request_unthrottle = 0;
511 int rc = 0;
512 struct keyspan_pda_private *priv;
513
514 priv = usb_get_serial_port_data(port);
515
516
517
518
519
520
521
522
523 dbg("keyspan_pda_write(%d)", count);
524 if (count == 0) {
525 dbg(" write request of 0 bytes");
526 return 0;
527 }
528
529
530
531
532
533 spin_lock_bh(&port->lock);
534 if (port->write_urb_busy || priv->tx_throttled) {
535 spin_unlock_bh(&port->lock);
536 return 0;
537 }
538 port->write_urb_busy = 1;
539 spin_unlock_bh(&port->lock);
540
541
542
543
544
545
546 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
547
548
549
550
551 if (count > priv->tx_room && !in_interrupt()) {
552 u8 *room;
553
554 room = kmalloc(1, GFP_KERNEL);
555 if (!room) {
556 rc = -ENOMEM;
557 goto exit;
558 }
559
560 rc = usb_control_msg(serial->dev,
561 usb_rcvctrlpipe(serial->dev, 0),
562 6,
563 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
564 | USB_DIR_IN,
565 0,
566 0,
567 room,
568 1,
569 2000);
570 if (rc > 0) {
571 dbg(" roomquery says %d", *room);
572 priv->tx_room = *room;
573 }
574 kfree(room);
575 if (rc < 0) {
576 dbg(" roomquery failed");
577 goto exit;
578 }
579 if (rc == 0) {
580 dbg(" roomquery returned 0 bytes");
581 rc = -EIO;
582 goto exit;
583 }
584 }
585 if (count > priv->tx_room) {
586
587
588 count = priv->tx_room;
589 request_unthrottle = 1;
590 }
591
592 if (count) {
593
594 memcpy(port->write_urb->transfer_buffer, buf, count);
595
596 port->write_urb->transfer_buffer_length = count;
597
598 priv->tx_room -= count;
599
600 port->write_urb->dev = port->serial->dev;
601 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
602 if (rc) {
603 dbg(" usb_submit_urb(write bulk) failed");
604 goto exit;
605 }
606 } else {
607
608
609 request_unthrottle = 1;
610 }
611
612 if (request_unthrottle) {
613 priv->tx_throttled = 1;
614 schedule_work(&priv->unthrottle_work);
615 }
616
617 rc = count;
618exit:
619 if (rc < 0)
620 port->write_urb_busy = 0;
621 return rc;
622}
623
624
625static void keyspan_pda_write_bulk_callback(struct urb *urb)
626{
627 struct usb_serial_port *port = urb->context;
628 struct keyspan_pda_private *priv;
629
630 port->write_urb_busy = 0;
631 priv = usb_get_serial_port_data(port);
632
633
634 schedule_work(&priv->wakeup_work);
635}
636
637
638static int keyspan_pda_write_room(struct tty_struct *tty)
639{
640 struct usb_serial_port *port = tty->driver_data;
641 struct keyspan_pda_private *priv;
642 priv = usb_get_serial_port_data(port);
643
644
645
646 return priv->tx_room;
647}
648
649
650static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
651{
652 struct usb_serial_port *port = tty->driver_data;
653 struct keyspan_pda_private *priv;
654 unsigned long flags;
655 int ret = 0;
656
657 priv = usb_get_serial_port_data(port);
658
659
660
661
662 spin_lock_irqsave(&port->lock, flags);
663 if (port->write_urb_busy || priv->tx_throttled)
664 ret = 256;
665 spin_unlock_irqrestore(&port->lock, flags);
666 return ret;
667}
668
669
670static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
671{
672 struct usb_serial *serial = port->serial;
673
674 if (serial->dev) {
675 if (on)
676 keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
677 else
678 keyspan_pda_set_modem_info(serial, 0);
679 }
680}
681
682
683static int keyspan_pda_open(struct tty_struct *tty,
684 struct usb_serial_port *port)
685{
686 struct usb_serial *serial = port->serial;
687 u8 *room;
688 int rc = 0;
689 struct keyspan_pda_private *priv;
690
691
692 room = kmalloc(1, GFP_KERNEL);
693 if (!room)
694 return -ENOMEM;
695
696 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
697 6,
698 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
699 | USB_DIR_IN,
700 0,
701 0,
702 room,
703 1,
704 2000);
705 if (rc < 0) {
706 dbg("%s - roomquery failed", __func__);
707 goto error;
708 }
709 if (rc == 0) {
710 dbg("%s - roomquery returned 0 bytes", __func__);
711 rc = -EIO;
712 goto error;
713 }
714 priv = usb_get_serial_port_data(port);
715 priv->tx_room = *room;
716 priv->tx_throttled = *room ? 0 : 1;
717
718
719 port->interrupt_in_urb->dev = serial->dev;
720 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
721 if (rc) {
722 dbg("%s - usb_submit_urb(read int) failed", __func__);
723 goto error;
724 }
725error:
726 kfree(room);
727 return rc;
728}
729static void keyspan_pda_close(struct usb_serial_port *port)
730{
731 struct usb_serial *serial = port->serial;
732
733 if (serial->dev) {
734
735 usb_kill_urb(port->write_urb);
736 usb_kill_urb(port->interrupt_in_urb);
737 }
738}
739
740
741
742static int keyspan_pda_fake_startup(struct usb_serial *serial)
743{
744 int response;
745 const char *fw_name;
746 const struct ihex_binrec *record;
747 const struct firmware *fw;
748
749
750 response = ezusb_set_reset(serial, 1);
751
752 if (0) { ; }
753#ifdef KEYSPAN
754 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
755 fw_name = "keyspan_pda/keyspan_pda.fw";
756#endif
757#ifdef XIRCOM
758 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
759 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
760 fw_name = "keyspan_pda/xircom_pgs.fw";
761#endif
762 else {
763 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
764 __func__);
765 return -ENODEV;
766 }
767 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
768 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
769 fw_name);
770 return -ENOENT;
771 }
772 record = (const struct ihex_binrec *)fw->data;
773
774 while (record) {
775 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
776 (unsigned char *)record->data,
777 be16_to_cpu(record->len), 0xa0);
778 if (response < 0) {
779 dev_err(&serial->dev->dev, "ezusb_writememory failed "
780 "for Keyspan PDA firmware (%d %04X %p %d)\n",
781 response, be32_to_cpu(record->addr),
782 record->data, be16_to_cpu(record->len));
783 break;
784 }
785 record = ihex_next_binrec(record);
786 }
787 release_firmware(fw);
788
789
790 response = ezusb_set_reset(serial, 0);
791
792
793 return 1;
794}
795
796#ifdef KEYSPAN
797MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
798#endif
799#ifdef XIRCOM
800MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
801#endif
802
803static int keyspan_pda_startup(struct usb_serial *serial)
804{
805
806 struct keyspan_pda_private *priv;
807
808
809
810
811 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
812 if (!priv)
813 return 1;
814 usb_set_serial_port_data(serial->port[0], priv);
815 init_waitqueue_head(&serial->port[0]->write_wait);
816 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
817 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
818 priv->serial = serial;
819 priv->port = serial->port[0];
820 return 0;
821}
822
823static void keyspan_pda_release(struct usb_serial *serial)
824{
825 dbg("%s", __func__);
826
827 kfree(usb_get_serial_port_data(serial->port[0]));
828}
829
830#ifdef KEYSPAN
831static struct usb_serial_driver keyspan_pda_fake_device = {
832 .driver = {
833 .owner = THIS_MODULE,
834 .name = "keyspan_pda_pre",
835 },
836 .description = "Keyspan PDA - (prerenumeration)",
837 .usb_driver = &keyspan_pda_driver,
838 .id_table = id_table_fake,
839 .num_ports = 1,
840 .attach = keyspan_pda_fake_startup,
841};
842#endif
843
844#ifdef XIRCOM
845static struct usb_serial_driver xircom_pgs_fake_device = {
846 .driver = {
847 .owner = THIS_MODULE,
848 .name = "xircom_no_firm",
849 },
850 .description = "Xircom / Entregra PGS - (prerenumeration)",
851 .usb_driver = &keyspan_pda_driver,
852 .id_table = id_table_fake_xircom,
853 .num_ports = 1,
854 .attach = keyspan_pda_fake_startup,
855};
856#endif
857
858static struct usb_serial_driver keyspan_pda_device = {
859 .driver = {
860 .owner = THIS_MODULE,
861 .name = "keyspan_pda",
862 },
863 .description = "Keyspan PDA",
864 .usb_driver = &keyspan_pda_driver,
865 .id_table = id_table_std,
866 .num_ports = 1,
867 .dtr_rts = keyspan_pda_dtr_rts,
868 .open = keyspan_pda_open,
869 .close = keyspan_pda_close,
870 .write = keyspan_pda_write,
871 .write_room = keyspan_pda_write_room,
872 .write_bulk_callback = keyspan_pda_write_bulk_callback,
873 .read_int_callback = keyspan_pda_rx_interrupt,
874 .chars_in_buffer = keyspan_pda_chars_in_buffer,
875 .throttle = keyspan_pda_rx_throttle,
876 .unthrottle = keyspan_pda_rx_unthrottle,
877 .set_termios = keyspan_pda_set_termios,
878 .break_ctl = keyspan_pda_break_ctl,
879 .tiocmget = keyspan_pda_tiocmget,
880 .tiocmset = keyspan_pda_tiocmset,
881 .attach = keyspan_pda_startup,
882 .release = keyspan_pda_release,
883};
884
885
886static int __init keyspan_pda_init(void)
887{
888 int retval;
889 retval = usb_serial_register(&keyspan_pda_device);
890 if (retval)
891 goto failed_pda_register;
892#ifdef KEYSPAN
893 retval = usb_serial_register(&keyspan_pda_fake_device);
894 if (retval)
895 goto failed_pda_fake_register;
896#endif
897#ifdef XIRCOM
898 retval = usb_serial_register(&xircom_pgs_fake_device);
899 if (retval)
900 goto failed_xircom_register;
901#endif
902 retval = usb_register(&keyspan_pda_driver);
903 if (retval)
904 goto failed_usb_register;
905 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
906 DRIVER_DESC "\n");
907 return 0;
908failed_usb_register:
909#ifdef XIRCOM
910 usb_serial_deregister(&xircom_pgs_fake_device);
911failed_xircom_register:
912#endif
913#ifdef KEYSPAN
914 usb_serial_deregister(&keyspan_pda_fake_device);
915#endif
916#ifdef KEYSPAN
917failed_pda_fake_register:
918#endif
919 usb_serial_deregister(&keyspan_pda_device);
920failed_pda_register:
921 return retval;
922}
923
924
925static void __exit keyspan_pda_exit(void)
926{
927 usb_deregister(&keyspan_pda_driver);
928 usb_serial_deregister(&keyspan_pda_device);
929#ifdef KEYSPAN
930 usb_serial_deregister(&keyspan_pda_fake_device);
931#endif
932#ifdef XIRCOM
933 usb_serial_deregister(&xircom_pgs_fake_device);
934#endif
935}
936
937
938module_init(keyspan_pda_init);
939module_exit(keyspan_pda_exit);
940
941MODULE_AUTHOR(DRIVER_AUTHOR);
942MODULE_DESCRIPTION(DRIVER_DESC);
943MODULE_LICENSE("GPL");
944
945module_param(debug, bool, S_IRUGO | S_IWUSR);
946MODULE_PARM_DESC(debug, "Debug enabled or not");
947
948