0b769192d4ce0753c872410c601a1e2eb4849a8e
1 /*****************************************************************************
5 * Description: Irda MosChip USB Dongle Driver
6 * Authors: Lukasz Stelmach <stlman@poczta.fm>
7 * Brian Pugh <bpugh@cs.pdx.edu>
8 * Judy Fischbach <jfisch@cs.pdx.edu>
10 * Based on stir4200 driver, but some things done differently.
11 * Based on earlier driver by Paul Stewart <stewart@parc.com>
13 * Copyright (C) 2000, Roman Weissgaerber <weissg@vienna.at>
14 * Copyright (C) 2001, Dag Brattli <dag@brattli.net>
15 * Copyright (C) 2001, Jean Tourrilhes <jt@hpl.hp.com>
16 * Copyright (C) 2004, Stephen Hemminger <shemminger@osdl.org>
17 * Copyright (C) 2005, Lukasz Stelmach <stlman@poczta.fm>
18 * Copyright (C) 2005, Brian Pugh <bpugh@cs.pdx.edu>
19 * Copyright (C) 2005, Judy Fischbach <jfisch@cs.pdx.edu>
21 * This program is free software; you can redistribute it and/or modify
22 * it under the terms of the GNU General Public License as published by
23 * the Free Software Foundation; either version 2 of the License, or
24 * (at your option) any later version.
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 *****************************************************************************/
38 * MCS7780 is a simple USB to IrDA bridge by MosChip. It is neither
39 * compatibile with irda-usb nor with stir4200. Although it is quite
40 * similar to the later as far as general idea of operation is concerned.
41 * That is it requires the software to do all the framing job at SIR speeds.
42 * The hardware does take care of the framing at MIR and FIR speeds.
43 * It supports all speeds from 2400 through 4Mbps
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/kref.h>
54 #include <linux/usb.h>
55 #include <linux/device.h>
56 #include <linux/crc32.h>
58 #include <asm/unaligned.h>
59 #include <asm/byteorder.h>
60 #include <asm/uaccess.h>
62 #include <net/irda/irda.h>
63 #include <net/irda/wrapper.h>
64 #include <net/irda/crc.h>
68 #define MCS_VENDOR_ID 0x9710
69 #define MCS_PRODUCT_ID 0x7780
71 static struct usb_device_id mcs_table
[] = {
72 /* MosChip Corp., MCS7780 FIR-USB Adapter */
73 {USB_DEVICE(MCS_VENDOR_ID
, MCS_PRODUCT_ID
)},
77 MODULE_AUTHOR("Brian Pugh <bpugh@cs.pdx.edu>");
78 MODULE_DESCRIPTION("IrDA-USB Dongle Driver for MosChip MCS7780");
79 MODULE_VERSION("0.3alpha");
80 MODULE_LICENSE("GPL");
82 MODULE_DEVICE_TABLE(usb
, mcs_table
);
84 static int qos_mtt_bits
= 0x07 /* > 1ms */ ;
85 module_param(qos_mtt_bits
, int, 0);
86 MODULE_PARM_DESC(qos_mtt_bits
, "Minimum Turn Time");
88 static int receive_mode
= 0x1;
89 module_param(receive_mode
, int, 0);
90 MODULE_PARM_DESC(receive_mode
,
91 "Receive mode of the device (1:fast, 0:slow, default:1)");
93 static int sir_tweak
= 1;
94 module_param(sir_tweak
, int, 0444);
95 MODULE_PARM_DESC(sir_tweak
,
96 "Default pulse width (1:1.6us, 0:3/16 bit, default:1).");
98 static int transceiver_type
= MCS_TSC_VISHAY
;
99 module_param(transceiver_type
, int, 0444);
100 MODULE_PARM_DESC(transceiver_type
, "IR transceiver type, see mcs7780.h.");
102 static struct usb_driver mcs_driver
= {
105 .disconnect
= mcs_disconnect
,
106 .id_table
= mcs_table
,
109 /* speed flag selection by direct addressing.
110 addr = (speed >> 8) & 0x0f
112 0x1 57600 0x2 115200 0x4 1152000 0x5 9600
113 0x6 38400 0x9 2400 0xa 576000 0xb 19200
115 4Mbps (or 2400) must be checked separately. Since it also has
116 to be programmed in a different manner that is not a big problem.
118 static __u16 mcs_speed_set
[16] = { 0,
132 /* Set given 16 bit register with a 16 bit value. Send control message
133 * to set dongle register. */
134 static int mcs_set_reg(struct mcs_cb
*mcs
, __u16 reg
, __u16 val
)
136 struct usb_device
*dev
= mcs
->usbdev
;
137 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0), MCS_WRREQ
,
138 MCS_WR_RTYPE
, val
, reg
, NULL
, 0,
139 msecs_to_jiffies(MCS_CTRL_TIMEOUT
));
142 /* Get 16 bit register value. Send contol message to read dongle register. */
143 static int mcs_get_reg(struct mcs_cb
*mcs
, __u16 reg
, __u16
* val
)
145 struct usb_device
*dev
= mcs
->usbdev
;
146 int ret
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0), MCS_RDREQ
,
147 MCS_RD_RTYPE
, 0, reg
, val
, 2,
148 msecs_to_jiffies(MCS_CTRL_TIMEOUT
));
153 /* Setup a communication between mcs7780 and TFDU chips. It is described
154 * in more detail in the data sheet. The setup sequence puts the the
155 * vishay tranceiver into high speed mode. It will also receive SIR speed
156 * packets but at reduced sensitivity.
160 static inline int mcs_setup_transceiver_vishay(struct mcs_cb
*mcs
)
165 /* mcs_get_reg should read exactly two bytes from the dongle */
166 ret
= mcs_get_reg(mcs
, MCS_XCVR_REG
, &rval
);
167 if (unlikely(ret
!= 2)) {
172 /* The MCS_XCVR_CONF bit puts the transceiver into configuration
173 * mode. The MCS_MODE0 bit must start out high (1) and then
174 * transition to low and the MCS_STFIR and MCS_MODE1 bits must
177 rval
|= (MCS_MODE0
| MCS_XCVR_CONF
);
180 ret
= mcs_set_reg(mcs
, MCS_XCVR_REG
, rval
);
185 ret
= mcs_set_reg(mcs
, MCS_XCVR_REG
, rval
);
189 rval
&= ~MCS_XCVR_CONF
;
190 ret
= mcs_set_reg(mcs
, MCS_XCVR_REG
, rval
);
199 /* Setup a communication between mcs7780 and agilent chip. */
200 static inline int mcs_setup_transceiver_agilent(struct mcs_cb
*mcs
)
202 IRDA_WARNING("This transceiver type is not supported yet.\n");
206 /* Setup a communication between mcs7780 and sharp chip. */
207 static inline int mcs_setup_transceiver_sharp(struct mcs_cb
*mcs
)
209 IRDA_WARNING("This transceiver type is not supported yet.\n");
213 /* Common setup for all transceivers */
214 static inline int mcs_setup_transceiver(struct mcs_cb
*mcs
)
220 msg
= "Basic transceiver setup error.";
222 /* read value of MODE Register, set the DRIVER and RESET bits
223 * and write value back out to MODE Register
225 ret
= mcs_get_reg(mcs
, MCS_MODE_REG
, &rval
);
226 if(unlikely(ret
!= 2))
228 rval
|= MCS_DRIVER
; /* put the mcs7780 into configuration mode. */
229 ret
= mcs_set_reg(mcs
, MCS_MODE_REG
, rval
);
233 rval
= 0; /* set min pulse width to 0 initially. */
234 ret
= mcs_set_reg(mcs
, MCS_MINRXPW_REG
, rval
);
238 ret
= mcs_get_reg(mcs
, MCS_MODE_REG
, &rval
);
239 if(unlikely(ret
!= 2))
242 rval
&= ~MCS_FIR
; /* turn off fir mode. */
244 rval
|= MCS_SIR16US
; /* 1.6us pulse width */
246 rval
&= ~MCS_SIR16US
; /* 3/16 bit time pulse width */
248 /* make sure ask mode and back to back packets are off. */
249 rval
&= ~(MCS_BBTG
| MCS_ASK
);
251 rval
&= ~MCS_SPEED_MASK
;
252 rval
|= MCS_SPEED_9600
; /* make sure initial speed is 9600. */
254 mcs
->new_speed
= 0; /* new_speed is set to 0 */
255 rval
&= ~MCS_PLLPWDN
; /* disable power down. */
257 /* make sure device determines direction and that the auto send sip
260 rval
|= MCS_DTD
| MCS_SIPEN
;
262 ret
= mcs_set_reg(mcs
, MCS_MODE_REG
, rval
);
266 msg
= "transceiver model specific setup error.";
267 switch (mcs
->transceiver_type
) {
269 ret
= mcs_setup_transceiver_vishay(mcs
);
273 ret
= mcs_setup_transceiver_sharp(mcs
);
276 case MCS_TSC_AGILENT
:
277 ret
= mcs_setup_transceiver_agilent(mcs
);
281 IRDA_WARNING("Unknown transceiver type: %d\n",
282 mcs
->transceiver_type
);
288 /* If transceiver is not SHARP, then if receive mode set
289 * on the RXFAST bit in the XCVR Register otherwise unset it
291 if (mcs
->transceiver_type
!= MCS_TSC_SHARP
) {
293 ret
= mcs_get_reg(mcs
, MCS_XCVR_REG
, &rval
);
294 if (unlikely(ret
!= 2))
296 if (mcs
->receive_mode
)
300 ret
= mcs_set_reg(mcs
, MCS_XCVR_REG
, rval
);
305 msg
= "transceiver reset.";
307 ret
= mcs_get_reg(mcs
, MCS_MODE_REG
, &rval
);
308 if (unlikely(ret
!= 2))
311 /* reset the mcs7780 so all changes take effect. */
313 ret
= mcs_set_reg(mcs
, MCS_MODE_REG
, rval
);
320 IRDA_ERROR("%s\n", msg
);
324 /* Wraps the data in format for SIR */
325 static inline int mcs_wrap_sir_skb(struct sk_buff
*skb
, __u8
* buf
)
329 /* 2: full frame length, including "the length" */
330 wraplen
= async_wrap_skb(skb
, buf
+ 2, 4094);
333 buf
[0] = wraplen
& 0xff;
334 buf
[1] = (wraplen
>> 8) & 0xff;
339 /* Wraps the data in format for FIR */
340 static unsigned mcs_wrap_fir_skb(const struct sk_buff
*skb
, __u8
*buf
)
342 unsigned int len
= 0;
343 __u32 fcs
= ~(crc32_le(~0, skb
->data
, skb
->len
));
345 /* add 2 bytes for length value and 4 bytes for fcs. */
348 /* The mcs7780 requires that the first two bytes are the packet
349 * length in little endian order. Note: the length value includes
350 * the two bytes for the length value itself.
353 buf
[1] = (len
>> 8) & 0xff;
354 /* copy the data into the tx buffer. */
355 skb_copy_from_linear_data(skb
, buf
+ 2, skb
->len
);
356 /* put the fcs in the last four bytes in little endian order. */
357 buf
[len
- 4] = fcs
& 0xff;
358 buf
[len
- 3] = (fcs
>> 8) & 0xff;
359 buf
[len
- 2] = (fcs
>> 16) & 0xff;
360 buf
[len
- 1] = (fcs
>> 24) & 0xff;
365 /* Wraps the data in format for MIR */
366 static unsigned mcs_wrap_mir_skb(const struct sk_buff
*skb
, __u8
*buf
)
369 int len
= skb
->len
+ 4;
371 fcs
= ~(irda_calc_crc16(~fcs
, skb
->data
, skb
->len
));
372 /* put the total packet length in first. Note: packet length
373 * value includes the two bytes that hold the packet length
377 buf
[1] = (len
>> 8) & 0xff;
379 skb_copy_from_linear_data(skb
, buf
+ 2, skb
->len
);
380 /* put the fcs in last two bytes in little endian order. */
381 buf
[len
- 2] = fcs
& 0xff;
382 buf
[len
- 1] = (fcs
>> 8) & 0xff;
387 /* Unwrap received packets at MIR speed. A 16 bit crc_ccitt checksum is
388 * used for the fcs. When performed over the entire packet the result
389 * should be GOOD_FCS = 0xf0b8. Hands the unwrapped data off to the IrDA
390 * layer via a sk_buff.
392 static void mcs_unwrap_mir(struct mcs_cb
*mcs
, __u8
*buf
, int len
)
398 /* Assume that the frames are going to fill a single packet
399 * rather than span multiple packets.
403 if(unlikely(new_len
<= 0)) {
404 IRDA_ERROR("%s short frame length %d\n",
405 mcs
->netdev
->name
, new_len
);
406 ++mcs
->stats
.rx_errors
;
407 ++mcs
->stats
.rx_length_errors
;
411 fcs
= irda_calc_crc16(~fcs
, buf
, len
);
413 if(fcs
!= GOOD_FCS
) {
414 IRDA_ERROR("crc error calc 0x%x len %d\n",
416 mcs
->stats
.rx_errors
++;
417 mcs
->stats
.rx_crc_errors
++;
421 skb
= dev_alloc_skb(new_len
+ 1);
423 ++mcs
->stats
.rx_dropped
;
428 skb_copy_to_linear_data(skb
, buf
, new_len
);
429 skb_put(skb
, new_len
);
430 skb_reset_mac_header(skb
);
431 skb
->protocol
= htons(ETH_P_IRDA
);
432 skb
->dev
= mcs
->netdev
;
436 mcs
->stats
.rx_packets
++;
437 mcs
->stats
.rx_bytes
+= new_len
;
442 /* Unwrap received packets at FIR speed. A 32 bit crc_ccitt checksum is
443 * used for the fcs. Hands the unwrapped data off to the IrDA
444 * layer via a sk_buff.
446 static void mcs_unwrap_fir(struct mcs_cb
*mcs
, __u8
*buf
, int len
)
452 /* Assume that the frames are going to fill a single packet
453 * rather than span multiple packets. This is most likely a false
458 if(unlikely(new_len
<= 0)) {
459 IRDA_ERROR("%s short frame length %d\n",
460 mcs
->netdev
->name
, new_len
);
461 ++mcs
->stats
.rx_errors
;
462 ++mcs
->stats
.rx_length_errors
;
466 fcs
= ~(crc32_le(~0, buf
, new_len
));
467 if(fcs
!= le32_to_cpu(get_unaligned((__le32
*)(buf
+new_len
)))) {
468 IRDA_ERROR("crc error calc 0x%x len %d\n", fcs
, new_len
);
469 mcs
->stats
.rx_errors
++;
470 mcs
->stats
.rx_crc_errors
++;
474 skb
= dev_alloc_skb(new_len
+ 1);
476 ++mcs
->stats
.rx_dropped
;
481 skb_copy_to_linear_data(skb
, buf
, new_len
);
482 skb_put(skb
, new_len
);
483 skb_reset_mac_header(skb
);
484 skb
->protocol
= htons(ETH_P_IRDA
);
485 skb
->dev
= mcs
->netdev
;
489 mcs
->stats
.rx_packets
++;
490 mcs
->stats
.rx_bytes
+= new_len
;
496 /* Allocates urbs for both receive and transmit.
497 * If alloc fails return error code 0 (fail) otherwise
498 * return error code 1 (success).
500 static inline int mcs_setup_urbs(struct mcs_cb
*mcs
)
504 mcs
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
508 mcs
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
515 /* Sets up state to be initially outside frame, gets receive urb,
516 * sets status to successful and then submits the urb to start
517 * receiving the data.
519 static inline int mcs_receive_start(struct mcs_cb
*mcs
)
521 mcs
->rx_buff
.in_frame
= FALSE
;
522 mcs
->rx_buff
.state
= OUTSIDE_FRAME
;
524 usb_fill_bulk_urb(mcs
->rx_urb
, mcs
->usbdev
,
525 usb_rcvbulkpipe(mcs
->usbdev
, mcs
->ep_in
),
526 mcs
->in_buf
, 4096, mcs_receive_irq
, mcs
);
528 mcs
->rx_urb
->status
= 0;
529 return usb_submit_urb(mcs
->rx_urb
, GFP_KERNEL
);
532 /* Finds the in and out endpoints for the mcs control block */
533 static inline int mcs_find_endpoints(struct mcs_cb
*mcs
,
534 struct usb_host_endpoint
*ep
, int epnum
)
539 /* If no place to store the endpoints just return */
543 /* cycle through all endpoints, find the first two that are DIR_IN */
544 for (i
= 0; i
< epnum
; i
++) {
545 if (ep
[i
].desc
.bEndpointAddress
& USB_DIR_IN
)
546 mcs
->ep_in
= ep
[i
].desc
.bEndpointAddress
;
548 mcs
->ep_out
= ep
[i
].desc
.bEndpointAddress
;
550 /* MosChip says that the chip has only two bulk
551 * endpoints. Find one for each direction and move on.
553 if ((mcs
->ep_in
!= 0) && (mcs
->ep_out
!= 0)) {
562 static void mcs_speed_work(struct work_struct
*work
)
564 struct mcs_cb
*mcs
= container_of(work
, struct mcs_cb
, work
);
565 struct net_device
*netdev
= mcs
->netdev
;
567 mcs_speed_change(mcs
);
568 netif_wake_queue(netdev
);
571 /* Function to change the speed of the mcs7780. Fully supports SIR,
572 * MIR, and FIR speeds.
574 static int mcs_speed_change(struct mcs_cb
*mcs
)
582 nspeed
= mcs_speed_set
[(mcs
->new_speed
>> 8) & 0x0f];
585 mcs_get_reg(mcs
, MCS_RESV_REG
, &rval
);
586 } while(cnt
++ < 100 && (rval
& MCS_IRINTX
));
589 IRDA_ERROR("unable to change speed\n");
594 mcs_get_reg(mcs
, MCS_MODE_REG
, &rval
);
596 /* MINRXPW values recomended by MosChip */
597 if (mcs
->new_speed
<= 115200) {
600 if ((rst
= (mcs
->speed
> 115200)))
601 mcs_set_reg(mcs
, MCS_MINRXPW_REG
, 0);
603 } else if (mcs
->new_speed
<= 1152000) {
606 if ((rst
= !(mcs
->speed
== 576000 || mcs
->speed
== 1152000)))
607 mcs_set_reg(mcs
, MCS_MINRXPW_REG
, 5);
612 if ((rst
= (mcs
->speed
!= 4000000)))
613 mcs_set_reg(mcs
, MCS_MINRXPW_REG
, 5);
617 rval
&= ~MCS_SPEED_MASK
;
620 ret
= mcs_set_reg(mcs
, MCS_MODE_REG
, rval
);
625 switch (mcs
->transceiver_type
) {
627 ret
= mcs_setup_transceiver_vishay(mcs
);
631 ret
= mcs_setup_transceiver_sharp(mcs
);
634 case MCS_TSC_AGILENT
:
635 ret
= mcs_setup_transceiver_agilent(mcs
);
640 IRDA_WARNING("Unknown transceiver type: %d\n",
641 mcs
->transceiver_type
);
646 mcs_get_reg(mcs
, MCS_MODE_REG
, &rval
);
648 ret
= mcs_set_reg(mcs
, MCS_MODE_REG
, rval
);
650 mcs
->speed
= mcs
->new_speed
;
656 /* Ioctl calls not supported at this time. Can be an area of future work. */
657 static int mcs_net_ioctl(struct net_device
*netdev
, struct ifreq
*rq
, int cmd
)
659 /* struct if_irda_req *irq = (struct if_irda_req *)rq; */
660 /* struct mcs_cb *mcs = netdev_priv(netdev); */
671 /* Network device is taken down, done by "ifconfig irda0 down" */
672 static int mcs_net_close(struct net_device
*netdev
)
675 struct mcs_cb
*mcs
= netdev_priv(netdev
);
677 /* Stop transmit processing */
678 netif_stop_queue(netdev
);
680 /* kill and free the receive and transmit URBs */
681 usb_kill_urb(mcs
->rx_urb
);
682 usb_free_urb(mcs
->rx_urb
);
683 usb_kill_urb(mcs
->tx_urb
);
684 usb_free_urb(mcs
->tx_urb
);
686 /* Stop and remove instance of IrLAP */
688 irlap_close(mcs
->irlap
);
694 /* Network device is taken up, done by "ifconfig irda0 up" */
695 static int mcs_net_open(struct net_device
*netdev
)
697 struct mcs_cb
*mcs
= netdev_priv(netdev
);
701 ret
= usb_clear_halt(mcs
->usbdev
,
702 usb_sndbulkpipe(mcs
->usbdev
, mcs
->ep_in
));
705 ret
= usb_clear_halt(mcs
->usbdev
,
706 usb_rcvbulkpipe(mcs
->usbdev
, mcs
->ep_out
));
710 ret
= mcs_setup_transceiver(mcs
);
716 /* Initialize for SIR/FIR to copy data directly into skb. */
718 mcs
->rx_buff
.truesize
= IRDA_SKB_MAX_MTU
;
719 mcs
->rx_buff
.skb
= dev_alloc_skb(IRDA_SKB_MAX_MTU
);
720 if (!mcs
->rx_buff
.skb
)
723 skb_reserve(mcs
->rx_buff
.skb
, 1);
724 mcs
->rx_buff
.head
= mcs
->rx_buff
.skb
->data
;
725 do_gettimeofday(&mcs
->rx_time
);
728 * Now that everything should be initialized properly,
729 * Open new IrLAP layer instance to take care of us...
730 * Note : will send immediately a speed change...
732 sprintf(hwname
, "usb#%d", mcs
->usbdev
->devnum
);
733 mcs
->irlap
= irlap_open(netdev
, &mcs
->qos
, hwname
);
735 IRDA_ERROR("mcs7780: irlap_open failed\n");
739 if (!mcs_setup_urbs(mcs
))
742 ret
= mcs_receive_start(mcs
);
746 netif_start_queue(netdev
);
750 irlap_close(mcs
->irlap
);
752 kfree_skb(mcs
->rx_buff
.skb
);
758 /* Get device stats for /proc/net/dev and ifconfig */
759 static struct net_device_stats
*mcs_net_get_stats(struct net_device
*netdev
)
761 struct mcs_cb
*mcs
= netdev_priv(netdev
);
765 /* Receive callback function. */
766 static void mcs_receive_irq(struct urb
*urb
)
769 struct mcs_cb
*mcs
= urb
->context
;
773 if (!netif_running(mcs
->netdev
))
779 if (urb
->actual_length
> 0) {
780 bytes
= urb
->transfer_buffer
;
782 /* MCS returns frames without BOF and EOF
783 * I assume it returns whole frames.
786 if(mcs
->speed
< 576000) {
787 async_unwrap_char(mcs
->netdev
, &mcs
->stats
,
788 &mcs
->rx_buff
, 0xc0);
790 for (i
= 0; i
< urb
->actual_length
; i
++)
791 async_unwrap_char(mcs
->netdev
, &mcs
->stats
,
792 &mcs
->rx_buff
, bytes
[i
]);
794 async_unwrap_char(mcs
->netdev
, &mcs
->stats
,
795 &mcs
->rx_buff
, 0xc1);
798 else if(mcs
->speed
== 576000 || mcs
->speed
== 1152000) {
799 mcs_unwrap_mir(mcs
, urb
->transfer_buffer
,
804 mcs_unwrap_fir(mcs
, urb
->transfer_buffer
,
807 mcs
->netdev
->last_rx
= jiffies
;
808 do_gettimeofday(&mcs
->rx_time
);
811 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
814 /* Transmit callback funtion. */
815 static void mcs_send_irq(struct urb
*urb
)
817 struct mcs_cb
*mcs
= urb
->context
;
818 struct net_device
*ndev
= mcs
->netdev
;
820 if (unlikely(mcs
->new_speed
))
821 schedule_work(&mcs
->work
);
823 netif_wake_queue(ndev
);
826 /* Transmit callback funtion. */
827 static int mcs_hard_xmit(struct sk_buff
*skb
, struct net_device
*ndev
)
835 if (skb
== NULL
|| ndev
== NULL
)
838 netif_stop_queue(ndev
);
839 mcs
= netdev_priv(ndev
);
841 spin_lock_irqsave(&mcs
->lock
, flags
);
843 mcs
->new_speed
= irda_get_next_speed(skb
);
844 if (likely(mcs
->new_speed
== mcs
->speed
))
848 if(mcs
->speed
< 576000) {
849 wraplen
= mcs_wrap_sir_skb(skb
, mcs
->out_buf
);
852 else if(mcs
->speed
== 576000 || mcs
->speed
== 1152000) {
853 wraplen
= mcs_wrap_mir_skb(skb
, mcs
->out_buf
);
857 wraplen
= mcs_wrap_fir_skb(skb
, mcs
->out_buf
);
859 usb_fill_bulk_urb(mcs
->tx_urb
, mcs
->usbdev
,
860 usb_sndbulkpipe(mcs
->usbdev
, mcs
->ep_out
),
861 mcs
->out_buf
, wraplen
, mcs_send_irq
, mcs
);
863 if ((ret
= usb_submit_urb(mcs
->tx_urb
, GFP_ATOMIC
))) {
864 IRDA_ERROR("failed tx_urb: %d\n", ret
);
870 mcs
->stats
.tx_errors
++;
871 netif_start_queue(ndev
);
874 mcs
->stats
.tx_packets
++;
875 mcs
->stats
.tx_bytes
+= skb
->len
;
879 spin_unlock_irqrestore(&mcs
->lock
, flags
);
884 * This function is called by the USB subsystem for each new device in the
885 * system. Need to verify the device and if it is, then start handling it.
887 static int mcs_probe(struct usb_interface
*intf
,
888 const struct usb_device_id
*id
)
890 struct usb_device
*udev
= interface_to_usbdev(intf
);
891 struct net_device
*ndev
= NULL
;
895 ndev
= alloc_irdadev(sizeof(*mcs
));
899 IRDA_DEBUG(1, "MCS7780 USB-IrDA bridge found at %d.\n", udev
->devnum
);
901 SET_NETDEV_DEV(ndev
, &intf
->dev
);
903 ret
= usb_reset_configuration(udev
);
905 IRDA_ERROR("mcs7780: usb reset configuration failed\n");
909 mcs
= netdev_priv(ndev
);
912 spin_lock_init(&mcs
->lock
);
914 /* Initialize QoS for this device */
915 irda_init_max_qos_capabilies(&mcs
->qos
);
917 /* That's the Rx capability. */
918 mcs
->qos
.baud_rate
.bits
&=
919 IR_2400
| IR_9600
| IR_19200
| IR_38400
| IR_57600
| IR_115200
920 | IR_576000
| IR_1152000
| (IR_4000000
<< 8);
923 mcs
->qos
.min_turn_time
.bits
&= qos_mtt_bits
;
924 irda_qos_bits_to_value(&mcs
->qos
);
926 /* Speed change work initialisation*/
927 INIT_WORK(&mcs
->work
, mcs_speed_work
);
929 /* Override the network functions we need to use */
930 ndev
->hard_start_xmit
= mcs_hard_xmit
;
931 ndev
->open
= mcs_net_open
;
932 ndev
->stop
= mcs_net_close
;
933 ndev
->get_stats
= mcs_net_get_stats
;
934 ndev
->do_ioctl
= mcs_net_ioctl
;
936 if (!intf
->cur_altsetting
)
939 ret
= mcs_find_endpoints(mcs
, intf
->cur_altsetting
->endpoint
,
940 intf
->cur_altsetting
->desc
.bNumEndpoints
);
946 ret
= register_netdev(ndev
);
950 IRDA_DEBUG(1, "IrDA: Registered MosChip MCS7780 device as %s\n",
953 mcs
->transceiver_type
= transceiver_type
;
954 mcs
->sir_tweak
= sir_tweak
;
955 mcs
->receive_mode
= receive_mode
;
957 usb_set_intfdata(intf
, mcs
);
967 /* The current device is removed, the USB layer tells us to shut down. */
968 static void mcs_disconnect(struct usb_interface
*intf
)
970 struct mcs_cb
*mcs
= usb_get_intfdata(intf
);
975 flush_scheduled_work();
977 unregister_netdev(mcs
->netdev
);
978 free_netdev(mcs
->netdev
);
980 usb_set_intfdata(intf
, NULL
);
981 IRDA_DEBUG(0, "MCS7780 now disconnected.\n");
984 /* Module insertion */
985 static int __init
mcs_init(void)
989 /* register this driver with the USB subsystem */
990 result
= usb_register(&mcs_driver
);
992 IRDA_ERROR("usb_register failed. Error number %d\n", result
);
996 module_init(mcs_init
);
999 static void __exit
mcs_exit(void)
1001 /* deregister this driver with the USB subsystem */
1002 usb_deregister(&mcs_driver
);
1004 module_exit(mcs_exit
);
This page took 0.048775 seconds and 4 git commands to generate.