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