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#include <linux/module.h>
47#include <linux/moduleparam.h>
48#include <linux/kernel.h>
49#include <linux/types.h>
50#include <linux/errno.h>
51#include <linux/init.h>
52#include <linux/slab.h>
53#include <linux/usb.h>
54#include <linux/device.h>
55#include <linux/crc32.h>
56
57#include <asm/unaligned.h>
58#include <asm/byteorder.h>
59#include <asm/uaccess.h>
60
61#include <net/irda/irda.h>
62#include <net/irda/wrapper.h>
63#include <net/irda/crc.h>
64
65#include "mcs7780.h"
66
67#define MCS_VENDOR_ID 0x9710
68#define MCS_PRODUCT_ID 0x7780
69
70static struct usb_device_id mcs_table[] = {
71
72 {USB_DEVICE(MCS_VENDOR_ID, MCS_PRODUCT_ID)},
73 {},
74};
75
76MODULE_AUTHOR("Brian Pugh <bpugh@cs.pdx.edu>");
77MODULE_DESCRIPTION("IrDA-USB Dongle Driver for MosChip MCS7780");
78MODULE_VERSION("0.3alpha");
79MODULE_LICENSE("GPL");
80
81MODULE_DEVICE_TABLE(usb, mcs_table);
82
83static int qos_mtt_bits = 0x07 ;
84module_param(qos_mtt_bits, int, 0);
85MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time");
86
87static int receive_mode = 0x1;
88module_param(receive_mode, int, 0);
89MODULE_PARM_DESC(receive_mode,
90 "Receive mode of the device (1:fast, 0:slow, default:1)");
91
92static int sir_tweak = 1;
93module_param(sir_tweak, int, 0444);
94MODULE_PARM_DESC(sir_tweak,
95 "Default pulse width (1:1.6us, 0:3/16 bit, default:1).");
96
97static int transceiver_type = MCS_TSC_VISHAY;
98module_param(transceiver_type, int, 0444);
99MODULE_PARM_DESC(transceiver_type, "IR transceiver type, see mcs7780.h.");
100
101static struct usb_driver mcs_driver = {
102 .name = "mcs7780",
103 .probe = mcs_probe,
104 .disconnect = mcs_disconnect,
105 .id_table = mcs_table,
106};
107
108
109
110
111
112
113
114
115
116
117static __u16 mcs_speed_set[16] = { 0,
118 MCS_SPEED_57600,
119 MCS_SPEED_115200,
120 0,
121 MCS_SPEED_1152000,
122 MCS_SPEED_9600,
123 MCS_SPEED_38400,
124 0, 0,
125 MCS_SPEED_2400,
126 MCS_SPEED_576000,
127 MCS_SPEED_19200,
128 0, 0, 0,
129};
130
131
132
133static int mcs_set_reg(struct mcs_cb *mcs, __u16 reg, __u16 val)
134{
135 struct usb_device *dev = mcs->usbdev;
136 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
137 MCS_WR_RTYPE, val, reg, NULL, 0,
138 msecs_to_jiffies(MCS_CTRL_TIMEOUT));
139}
140
141
142static int mcs_get_reg(struct mcs_cb *mcs, __u16 reg, __u16 * val)
143{
144 struct usb_device *dev = mcs->usbdev;
145 int ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
146 MCS_RD_RTYPE, 0, reg, val, 2,
147 msecs_to_jiffies(MCS_CTRL_TIMEOUT));
148
149 return ret;
150}
151
152
153
154
155
156
157
158
159static inline int mcs_setup_transceiver_vishay(struct mcs_cb *mcs)
160{
161 int ret = 0;
162 __u16 rval;
163
164
165 ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval);
166 if (unlikely(ret != 2)) {
167 ret = -EIO;
168 goto error;
169 }
170
171
172
173
174
175
176 rval |= (MCS_MODE0 | MCS_XCVR_CONF);
177 rval &= ~MCS_STFIR;
178 rval &= ~MCS_MODE1;
179 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
180 if (unlikely(ret))
181 goto error;
182
183 rval &= ~MCS_MODE0;
184 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
185 if (unlikely(ret))
186 goto error;
187
188 rval &= ~MCS_XCVR_CONF;
189 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
190 if (unlikely(ret))
191 goto error;
192
193 ret = 0;
194 error:
195 return ret;
196}
197
198
199static inline int mcs_setup_transceiver_agilent(struct mcs_cb *mcs)
200{
201 IRDA_WARNING("This transceiver type is not supported yet.\n");
202 return 1;
203}
204
205
206static inline int mcs_setup_transceiver_sharp(struct mcs_cb *mcs)
207{
208 IRDA_WARNING("This transceiver type is not supported yet.\n");
209 return 1;
210}
211
212
213static inline int mcs_setup_transceiver(struct mcs_cb *mcs)
214{
215 int ret = 0;
216 __u16 rval;
217 char *msg;
218
219 msg = "Basic transceiver setup error.";
220
221
222
223
224 ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
225 if(unlikely(ret != 2))
226 goto error;
227 rval |= MCS_DRIVER;
228 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
229 if(unlikely(ret))
230 goto error;
231
232 rval = 0;
233 ret = mcs_set_reg(mcs, MCS_MINRXPW_REG, rval);
234 if(unlikely(ret))
235 goto error;
236
237 ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
238 if(unlikely(ret != 2))
239 goto error;
240
241 rval &= ~MCS_FIR;
242 if(mcs->sir_tweak)
243 rval |= MCS_SIR16US;
244 else
245 rval &= ~MCS_SIR16US;
246
247
248 rval &= ~(MCS_BBTG | MCS_ASK);
249
250 rval &= ~MCS_SPEED_MASK;
251 rval |= MCS_SPEED_9600;
252 mcs->speed = 9600;
253 mcs->new_speed = 0;
254 rval &= ~MCS_PLLPWDN;
255
256
257
258
259 rval |= MCS_DTD | MCS_SIPEN;
260
261 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
262 if(unlikely(ret))
263 goto error;
264
265 msg = "transceiver model specific setup error.";
266 switch (mcs->transceiver_type) {
267 case MCS_TSC_VISHAY:
268 ret = mcs_setup_transceiver_vishay(mcs);
269 break;
270
271 case MCS_TSC_SHARP:
272 ret = mcs_setup_transceiver_sharp(mcs);
273 break;
274
275 case MCS_TSC_AGILENT:
276 ret = mcs_setup_transceiver_agilent(mcs);
277 break;
278
279 default:
280 IRDA_WARNING("Unknown transceiver type: %d\n",
281 mcs->transceiver_type);
282 ret = 1;
283 }
284 if (unlikely(ret))
285 goto error;
286
287
288
289
290 if (mcs->transceiver_type != MCS_TSC_SHARP) {
291
292 ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval);
293 if (unlikely(ret != 2))
294 goto error;
295 if (mcs->receive_mode)
296 rval |= MCS_RXFAST;
297 else
298 rval &= ~MCS_RXFAST;
299 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
300 if (unlikely(ret))
301 goto error;
302 }
303
304 msg = "transceiver reset.";
305
306 ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
307 if (unlikely(ret != 2))
308 goto error;
309
310
311 rval &= ~MCS_RESET;
312 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
313 if (unlikely(ret))
314 goto error;
315 else
316 return ret;
317
318error:
319 IRDA_ERROR("%s\n", msg);
320 return ret;
321}
322
323
324static inline int mcs_wrap_sir_skb(struct sk_buff *skb, __u8 * buf)
325{
326 int wraplen;
327
328
329 wraplen = async_wrap_skb(skb, buf + 2, 4094);
330
331 wraplen += 2;
332 buf[0] = wraplen & 0xff;
333 buf[1] = (wraplen >> 8) & 0xff;
334
335 return wraplen;
336}
337
338
339static unsigned mcs_wrap_fir_skb(const struct sk_buff *skb, __u8 *buf)
340{
341 unsigned int len = 0;
342 __u32 fcs = ~(crc32_le(~0, skb->data, skb->len));
343
344
345 len = skb->len + 6;
346
347
348
349
350
351 buf[0] = len & 0xff;
352 buf[1] = (len >> 8) & 0xff;
353
354 skb_copy_from_linear_data(skb, buf + 2, skb->len);
355
356 buf[len - 4] = fcs & 0xff;
357 buf[len - 3] = (fcs >> 8) & 0xff;
358 buf[len - 2] = (fcs >> 16) & 0xff;
359 buf[len - 1] = (fcs >> 24) & 0xff;
360
361 return len;
362}
363
364
365static unsigned mcs_wrap_mir_skb(const struct sk_buff *skb, __u8 *buf)
366{
367 __u16 fcs = 0;
368 int len = skb->len + 4;
369
370 fcs = ~(irda_calc_crc16(~fcs, skb->data, skb->len));
371
372
373
374
375 buf[0] = len & 0xff;
376 buf[1] = (len >> 8) & 0xff;
377
378 skb_copy_from_linear_data(skb, buf + 2, skb->len);
379
380 buf[len - 2] = fcs & 0xff;
381 buf[len - 1] = (fcs >> 8) & 0xff;
382
383 return len;
384}
385
386
387
388
389
390
391static void mcs_unwrap_mir(struct mcs_cb *mcs, __u8 *buf, int len)
392{
393 __u16 fcs;
394 int new_len;
395 struct sk_buff *skb;
396
397
398
399
400
401 new_len = len - 2;
402 if(unlikely(new_len <= 0)) {
403 IRDA_ERROR("%s short frame length %d\n",
404 mcs->netdev->name, new_len);
405 ++mcs->netdev->stats.rx_errors;
406 ++mcs->netdev->stats.rx_length_errors;
407 return;
408 }
409 fcs = 0;
410 fcs = irda_calc_crc16(~fcs, buf, len);
411
412 if(fcs != GOOD_FCS) {
413 IRDA_ERROR("crc error calc 0x%x len %d\n",
414 fcs, new_len);
415 mcs->netdev->stats.rx_errors++;
416 mcs->netdev->stats.rx_crc_errors++;
417 return;
418 }
419
420 skb = dev_alloc_skb(new_len + 1);
421 if(unlikely(!skb)) {
422 ++mcs->netdev->stats.rx_dropped;
423 return;
424 }
425
426 skb_reserve(skb, 1);
427 skb_copy_to_linear_data(skb, buf, new_len);
428 skb_put(skb, new_len);
429 skb_reset_mac_header(skb);
430 skb->protocol = htons(ETH_P_IRDA);
431 skb->dev = mcs->netdev;
432
433 netif_rx(skb);
434
435 mcs->netdev->stats.rx_packets++;
436 mcs->netdev->stats.rx_bytes += new_len;
437
438 return;
439}
440
441
442
443
444
445static void mcs_unwrap_fir(struct mcs_cb *mcs, __u8 *buf, int len)
446{
447 __u32 fcs;
448 int new_len;
449 struct sk_buff *skb;
450
451
452
453
454
455
456 new_len = len - 4;
457 if(unlikely(new_len <= 0)) {
458 IRDA_ERROR("%s short frame length %d\n",
459 mcs->netdev->name, new_len);
460 ++mcs->netdev->stats.rx_errors;
461 ++mcs->netdev->stats.rx_length_errors;
462 return;
463 }
464
465 fcs = ~(crc32_le(~0, buf, new_len));
466 if(fcs != get_unaligned_le32(buf + new_len)) {
467 IRDA_ERROR("crc error calc 0x%x len %d\n", fcs, new_len);
468 mcs->netdev->stats.rx_errors++;
469 mcs->netdev->stats.rx_crc_errors++;
470 return;
471 }
472
473 skb = dev_alloc_skb(new_len + 1);
474 if(unlikely(!skb)) {
475 ++mcs->netdev->stats.rx_dropped;
476 return;
477 }
478
479 skb_reserve(skb, 1);
480 skb_copy_to_linear_data(skb, buf, new_len);
481 skb_put(skb, new_len);
482 skb_reset_mac_header(skb);
483 skb->protocol = htons(ETH_P_IRDA);
484 skb->dev = mcs->netdev;
485
486 netif_rx(skb);
487
488 mcs->netdev->stats.rx_packets++;
489 mcs->netdev->stats.rx_bytes += new_len;
490
491 return;
492}
493
494
495
496
497
498
499static inline int mcs_setup_urbs(struct mcs_cb *mcs)
500{
501 mcs->rx_urb = NULL;
502
503 mcs->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
504 if (!mcs->tx_urb)
505 return 0;
506
507 mcs->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
508 if (!mcs->rx_urb)
509 return 0;
510
511 return 1;
512}
513
514
515
516
517
518static inline int mcs_receive_start(struct mcs_cb *mcs)
519{
520 mcs->rx_buff.in_frame = FALSE;
521 mcs->rx_buff.state = OUTSIDE_FRAME;
522
523 usb_fill_bulk_urb(mcs->rx_urb, mcs->usbdev,
524 usb_rcvbulkpipe(mcs->usbdev, mcs->ep_in),
525 mcs->in_buf, 4096, mcs_receive_irq, mcs);
526
527 mcs->rx_urb->status = 0;
528 return usb_submit_urb(mcs->rx_urb, GFP_KERNEL);
529}
530
531
532static inline int mcs_find_endpoints(struct mcs_cb *mcs,
533 struct usb_host_endpoint *ep, int epnum)
534{
535 int i;
536 int ret = 0;
537
538
539 if (!ep)
540 return ret;
541
542
543 for (i = 0; i < epnum; i++) {
544 if (ep[i].desc.bEndpointAddress & USB_DIR_IN)
545 mcs->ep_in = ep[i].desc.bEndpointAddress;
546 else
547 mcs->ep_out = ep[i].desc.bEndpointAddress;
548
549
550
551
552 if ((mcs->ep_in != 0) && (mcs->ep_out != 0)) {
553 ret = 1;
554 break;
555 }
556 }
557
558 return ret;
559}
560
561static void mcs_speed_work(struct work_struct *work)
562{
563 struct mcs_cb *mcs = container_of(work, struct mcs_cb, work);
564 struct net_device *netdev = mcs->netdev;
565
566 mcs_speed_change(mcs);
567 netif_wake_queue(netdev);
568}
569
570
571
572
573static int mcs_speed_change(struct mcs_cb *mcs)
574{
575 int ret = 0;
576 int rst = 0;
577 int cnt = 0;
578 __u16 nspeed;
579 __u16 rval;
580
581 nspeed = mcs_speed_set[(mcs->new_speed >> 8) & 0x0f];
582
583 do {
584 mcs_get_reg(mcs, MCS_RESV_REG, &rval);
585 } while(cnt++ < 100 && (rval & MCS_IRINTX));
586
587 if (cnt > 100) {
588 IRDA_ERROR("unable to change speed\n");
589 ret = -EIO;
590 goto error;
591 }
592
593 mcs_get_reg(mcs, MCS_MODE_REG, &rval);
594
595
596 if (mcs->new_speed <= 115200) {
597 rval &= ~MCS_FIR;
598
599 if ((rst = (mcs->speed > 115200)))
600 mcs_set_reg(mcs, MCS_MINRXPW_REG, 0);
601
602 } else if (mcs->new_speed <= 1152000) {
603 rval &= ~MCS_FIR;
604
605 if ((rst = !(mcs->speed == 576000 || mcs->speed == 1152000)))
606 mcs_set_reg(mcs, MCS_MINRXPW_REG, 5);
607
608 } else {
609 rval |= MCS_FIR;
610
611 if ((rst = (mcs->speed != 4000000)))
612 mcs_set_reg(mcs, MCS_MINRXPW_REG, 5);
613
614 }
615
616 rval &= ~MCS_SPEED_MASK;
617 rval |= nspeed;
618
619 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
620 if (unlikely(ret))
621 goto error;
622
623 if (rst)
624 switch (mcs->transceiver_type) {
625 case MCS_TSC_VISHAY:
626 ret = mcs_setup_transceiver_vishay(mcs);
627 break;
628
629 case MCS_TSC_SHARP:
630 ret = mcs_setup_transceiver_sharp(mcs);
631 break;
632
633 case MCS_TSC_AGILENT:
634 ret = mcs_setup_transceiver_agilent(mcs);
635 break;
636
637 default:
638 ret = 1;
639 IRDA_WARNING("Unknown transceiver type: %d\n",
640 mcs->transceiver_type);
641 }
642 if (unlikely(ret))
643 goto error;
644
645 mcs_get_reg(mcs, MCS_MODE_REG, &rval);
646 rval &= ~MCS_RESET;
647 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
648
649 mcs->speed = mcs->new_speed;
650 error:
651 mcs->new_speed = 0;
652 return ret;
653}
654
655
656static int mcs_net_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
657{
658
659
660 int ret = 0;
661
662 switch (cmd) {
663 default:
664 ret = -EOPNOTSUPP;
665 }
666
667 return ret;
668}
669
670
671static int mcs_net_close(struct net_device *netdev)
672{
673 int ret = 0;
674 struct mcs_cb *mcs = netdev_priv(netdev);
675
676
677 netif_stop_queue(netdev);
678
679 kfree_skb(mcs->rx_buff.skb);
680
681
682 usb_kill_urb(mcs->rx_urb);
683 usb_free_urb(mcs->rx_urb);
684 usb_kill_urb(mcs->tx_urb);
685 usb_free_urb(mcs->tx_urb);
686
687
688 if (mcs->irlap)
689 irlap_close(mcs->irlap);
690
691 mcs->irlap = NULL;
692 return ret;
693}
694
695
696static int mcs_net_open(struct net_device *netdev)
697{
698 struct mcs_cb *mcs = netdev_priv(netdev);
699 char hwname[16];
700 int ret = 0;
701
702 ret = usb_clear_halt(mcs->usbdev,
703 usb_sndbulkpipe(mcs->usbdev, mcs->ep_in));
704 if (ret)
705 goto error1;
706 ret = usb_clear_halt(mcs->usbdev,
707 usb_rcvbulkpipe(mcs->usbdev, mcs->ep_out));
708 if (ret)
709 goto error1;
710
711 ret = mcs_setup_transceiver(mcs);
712 if (ret)
713 goto error1;
714
715 ret = -ENOMEM;
716
717
718 mcs->receiving = 0;
719 mcs->rx_buff.truesize = IRDA_SKB_MAX_MTU;
720 mcs->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
721 if (!mcs->rx_buff.skb)
722 goto error1;
723
724 skb_reserve(mcs->rx_buff.skb, 1);
725 mcs->rx_buff.head = mcs->rx_buff.skb->data;
726 do_gettimeofday(&mcs->rx_time);
727
728
729
730
731
732
733 sprintf(hwname, "usb#%d", mcs->usbdev->devnum);
734 mcs->irlap = irlap_open(netdev, &mcs->qos, hwname);
735 if (!mcs->irlap) {
736 IRDA_ERROR("mcs7780: irlap_open failed\n");
737 goto error2;
738 }
739
740 if (!mcs_setup_urbs(mcs))
741 goto error3;
742
743 ret = mcs_receive_start(mcs);
744 if (ret)
745 goto error3;
746
747 netif_start_queue(netdev);
748 return 0;
749
750 error3:
751 irlap_close(mcs->irlap);
752 error2:
753 kfree_skb(mcs->rx_buff.skb);
754 error1:
755 return ret;
756}
757
758
759static void mcs_receive_irq(struct urb *urb)
760{
761 __u8 *bytes;
762 struct mcs_cb *mcs = urb->context;
763 int i;
764 int ret;
765
766 if (!netif_running(mcs->netdev))
767 return;
768
769 if (urb->status)
770 return;
771
772 if (urb->actual_length > 0) {
773 bytes = urb->transfer_buffer;
774
775
776
777
778
779 if(mcs->speed < 576000) {
780 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
781 &mcs->rx_buff, 0xc0);
782
783 for (i = 0; i < urb->actual_length; i++)
784 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
785 &mcs->rx_buff, bytes[i]);
786
787 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
788 &mcs->rx_buff, 0xc1);
789 }
790
791 else if(mcs->speed == 576000 || mcs->speed == 1152000) {
792 mcs_unwrap_mir(mcs, urb->transfer_buffer,
793 urb->actual_length);
794 }
795
796 else {
797 mcs_unwrap_fir(mcs, urb->transfer_buffer,
798 urb->actual_length);
799 }
800 do_gettimeofday(&mcs->rx_time);
801 }
802
803 ret = usb_submit_urb(urb, GFP_ATOMIC);
804}
805
806
807static void mcs_send_irq(struct urb *urb)
808{
809 struct mcs_cb *mcs = urb->context;
810 struct net_device *ndev = mcs->netdev;
811
812 if (unlikely(mcs->new_speed))
813 schedule_work(&mcs->work);
814 else
815 netif_wake_queue(ndev);
816}
817
818
819static netdev_tx_t mcs_hard_xmit(struct sk_buff *skb,
820 struct net_device *ndev)
821{
822 unsigned long flags;
823 struct mcs_cb *mcs;
824 int wraplen;
825 int ret = 0;
826
827 netif_stop_queue(ndev);
828 mcs = netdev_priv(ndev);
829
830 spin_lock_irqsave(&mcs->lock, flags);
831
832 mcs->new_speed = irda_get_next_speed(skb);
833 if (likely(mcs->new_speed == mcs->speed))
834 mcs->new_speed = 0;
835
836
837 if(mcs->speed < 576000) {
838 wraplen = mcs_wrap_sir_skb(skb, mcs->out_buf);
839 }
840
841 else if(mcs->speed == 576000 || mcs->speed == 1152000) {
842 wraplen = mcs_wrap_mir_skb(skb, mcs->out_buf);
843 }
844
845 else {
846 wraplen = mcs_wrap_fir_skb(skb, mcs->out_buf);
847 }
848 usb_fill_bulk_urb(mcs->tx_urb, mcs->usbdev,
849 usb_sndbulkpipe(mcs->usbdev, mcs->ep_out),
850 mcs->out_buf, wraplen, mcs_send_irq, mcs);
851
852 if ((ret = usb_submit_urb(mcs->tx_urb, GFP_ATOMIC))) {
853 IRDA_ERROR("failed tx_urb: %d\n", ret);
854 switch (ret) {
855 case -ENODEV:
856 case -EPIPE:
857 break;
858 default:
859 mcs->netdev->stats.tx_errors++;
860 netif_start_queue(ndev);
861 }
862 } else {
863 mcs->netdev->stats.tx_packets++;
864 mcs->netdev->stats.tx_bytes += skb->len;
865 }
866
867 dev_kfree_skb(skb);
868 spin_unlock_irqrestore(&mcs->lock, flags);
869 return NETDEV_TX_OK;
870}
871
872static const struct net_device_ops mcs_netdev_ops = {
873 .ndo_open = mcs_net_open,
874 .ndo_stop = mcs_net_close,
875 .ndo_start_xmit = mcs_hard_xmit,
876 .ndo_do_ioctl = mcs_net_ioctl,
877};
878
879
880
881
882
883static int mcs_probe(struct usb_interface *intf,
884 const struct usb_device_id *id)
885{
886 struct usb_device *udev = interface_to_usbdev(intf);
887 struct net_device *ndev = NULL;
888 struct mcs_cb *mcs;
889 int ret = -ENOMEM;
890
891 ndev = alloc_irdadev(sizeof(*mcs));
892 if (!ndev)
893 goto error1;
894
895 IRDA_DEBUG(1, "MCS7780 USB-IrDA bridge found at %d.\n", udev->devnum);
896
897 SET_NETDEV_DEV(ndev, &intf->dev);
898
899 ret = usb_reset_configuration(udev);
900 if (ret != 0) {
901 IRDA_ERROR("mcs7780: usb reset configuration failed\n");
902 goto error2;
903 }
904
905 mcs = netdev_priv(ndev);
906 mcs->usbdev = udev;
907 mcs->netdev = ndev;
908 spin_lock_init(&mcs->lock);
909
910
911 irda_init_max_qos_capabilies(&mcs->qos);
912
913
914 mcs->qos.baud_rate.bits &=
915 IR_2400 | IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200
916 | IR_576000 | IR_1152000 | (IR_4000000 << 8);
917
918
919 mcs->qos.min_turn_time.bits &= qos_mtt_bits;
920 irda_qos_bits_to_value(&mcs->qos);
921
922
923 INIT_WORK(&mcs->work, mcs_speed_work);
924
925 ndev->netdev_ops = &mcs_netdev_ops;
926
927 if (!intf->cur_altsetting)
928 goto error2;
929
930 ret = mcs_find_endpoints(mcs, intf->cur_altsetting->endpoint,
931 intf->cur_altsetting->desc.bNumEndpoints);
932 if (!ret) {
933 ret = -ENODEV;
934 goto error2;
935 }
936
937 ret = register_netdev(ndev);
938 if (ret != 0)
939 goto error2;
940
941 IRDA_DEBUG(1, "IrDA: Registered MosChip MCS7780 device as %s\n",
942 ndev->name);
943
944 mcs->transceiver_type = transceiver_type;
945 mcs->sir_tweak = sir_tweak;
946 mcs->receive_mode = receive_mode;
947
948 usb_set_intfdata(intf, mcs);
949 return 0;
950
951 error2:
952 free_netdev(ndev);
953
954 error1:
955 return ret;
956}
957
958
959static void mcs_disconnect(struct usb_interface *intf)
960{
961 struct mcs_cb *mcs = usb_get_intfdata(intf);
962
963 if (!mcs)
964 return;
965
966 flush_scheduled_work();
967
968 unregister_netdev(mcs->netdev);
969 free_netdev(mcs->netdev);
970
971 usb_set_intfdata(intf, NULL);
972 IRDA_DEBUG(0, "MCS7780 now disconnected.\n");
973}
974
975
976static int __init mcs_init(void)
977{
978 int result;
979
980
981 result = usb_register(&mcs_driver);
982 if (result)
983 IRDA_ERROR("usb_register failed. Error number %d\n", result);
984
985 return result;
986}
987module_init(mcs_init);
988
989
990static void __exit mcs_exit(void)
991{
992
993 usb_deregister(&mcs_driver);
994}
995module_exit(mcs_exit);
996
997