1 /*****************************************************************************
3 * Filename: kingsun-sir.c
5 * Description: Irda KingSun/DonShine USB Dongle
7 * Author: Alex Villacís Lasso <a_villacis@palosanto.com>
9 * Based on stir4200 and mcs7780 drivers, with (strange?) differences
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *****************************************************************************/
27 * This is my current (2007-04-25) understanding of how this dongle is supposed
28 * to work. This is based on reverse-engineering and examination of the packet
29 * data sent and received by the WinXP driver using USBSnoopy. Feel free to
30 * update here as more of this dongle is known:
32 * General: Unlike the other USB IrDA dongles, this particular dongle exposes,
33 * not two bulk (in and out) endpoints, but two *interrupt* ones. This dongle,
34 * like the bulk based ones (stir4200.c and mcs7780.c), requires polling in
35 * order to receive data.
36 * Transmission: Just like stir4200, this dongle uses a raw stream of data,
37 * which needs to be wrapped and escaped in a similar way as in stir4200.c.
38 * Reception: Poll-based, as in stir4200. Each read returns the contents of a
39 * 8-byte buffer, of which the first byte (LSB) indicates the number of bytes
40 * (1-7) of valid data contained within the remaining 7 bytes. For example, if
41 * the buffer had the following contents:
42 * 06 ff ff ff c0 01 04 aa
43 * This means that (06) there are 6 bytes of valid data. The byte 0xaa at the
44 * end is garbage (left over from a previous reception) and is discarded.
45 * If a read returns an "impossible" value as the length of valid data (such as
46 * 0x36) in the first byte, then the buffer is uninitialized (as is the case of
47 * first plug-in) and its contents should be discarded. There is currently no
48 * evidence that the top 5 bits of the 1st byte of the buffer can have values
49 * other than 0 once reception begins.
50 * Once valid bytes are collected, the assembled stream is a sequence of
51 * wrapped IrDA frames that is unwrapped and unescaped as in stir4200.c.
52 * BIG FAT WARNING: the dongle does *not* reset the RX buffer in any way after
53 * a successful read from the host, which means that in absence of further
54 * reception, repeated reads from the dongle will return the exact same
55 * contents repeatedly. Attempts to be smart and cache a previous read seem
56 * to result in corrupted packets, so this driver depends on the unwrap logic
57 * to sort out any repeated reads.
58 * Speed change: no commands observed so far to change speed, assumed fixed
62 #include <linux/module.h>
63 #include <linux/moduleparam.h>
64 #include <linux/kernel.h>
65 #include <linux/types.h>
66 #include <linux/errno.h>
67 #include <linux/init.h>
68 #include <linux/slab.h>
69 #include <linux/kref.h>
70 #include <linux/usb.h>
71 #include <linux/device.h>
72 #include <linux/crc32.h>
74 #include <asm/unaligned.h>
75 #include <asm/byteorder.h>
76 #include <asm/uaccess.h>
78 #include <net/irda/irda.h>
79 #include <net/irda/wrapper.h>
80 #include <net/irda/crc.h>
83 * According to lsusb, 0x07c0 is assigned to
84 * "Code Mercenaries Hard- und Software GmbH"
86 #define KING_VENDOR_ID 0x07c0
87 #define KING_PRODUCT_ID 0x4200
89 /* These are the currently known USB ids */
90 static struct usb_device_id dongles
[] = {
91 /* KingSun Co,Ltd IrDA/USB Bridge */
92 { USB_DEVICE(KING_VENDOR_ID
, KING_PRODUCT_ID
) },
96 MODULE_DEVICE_TABLE(usb
, dongles
);
98 #define KINGSUN_MTT 0x07
100 #define KINGSUN_FIFO_SIZE 4096
101 #define KINGSUN_EP_IN 0
102 #define KINGSUN_EP_OUT 1
105 struct usb_device
*usbdev
; /* init: probe_irda */
106 struct net_device
*netdev
; /* network layer */
107 struct irlap_cb
*irlap
; /* The link layer we are binded to */
108 struct net_device_stats stats
; /* network statistics */
111 __u8
*in_buf
; /* receive buffer */
112 __u8
*out_buf
; /* transmit buffer */
113 __u8 max_rx
; /* max. atomic read from dongle
114 (usually 8), also size of in_buf */
115 __u8 max_tx
; /* max. atomic write to dongle
118 iobuff_t rx_buff
; /* receive unwrap state machine */
119 struct timeval rx_time
;
130 /* Callback transmission routine */
131 static void kingsun_send_irq(struct urb
*urb
)
133 struct kingsun_cb
*kingsun
= urb
->context
;
134 struct net_device
*netdev
= kingsun
->netdev
;
136 /* in process of stopping, just drop data */
137 if (!netif_running(kingsun
->netdev
)) {
138 err("kingsun_send_irq: Network not running!");
142 /* unlink, shutdown, unplug, other nasties */
143 if (urb
->status
!= 0) {
144 err("kingsun_send_irq: urb asynchronously failed - %d",
147 netif_wake_queue(netdev
);
151 * Called from net/core when new frame is available.
153 static int kingsun_hard_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
155 struct kingsun_cb
*kingsun
;
159 if (skb
== NULL
|| netdev
== NULL
)
162 netif_stop_queue(netdev
);
164 /* the IRDA wrapping routines don't deal with non linear skb */
165 SKB_LINEAR_ASSERT(skb
);
167 kingsun
= netdev_priv(netdev
);
169 spin_lock(&kingsun
->lock
);
171 /* Append data to the end of whatever data remains to be transmitted */
172 wraplen
= async_wrap_skb(skb
,
176 /* Calculate how much data can be transmitted in this urb */
177 usb_fill_int_urb(kingsun
->tx_urb
, kingsun
->usbdev
,
178 usb_sndintpipe(kingsun
->usbdev
, kingsun
->ep_out
),
179 kingsun
->out_buf
, wraplen
, kingsun_send_irq
,
182 if ((ret
= usb_submit_urb(kingsun
->tx_urb
, GFP_ATOMIC
))) {
183 err("kingsun_hard_xmit: failed tx_urb submit: %d", ret
);
189 kingsun
->stats
.tx_errors
++;
190 netif_start_queue(netdev
);
193 kingsun
->stats
.tx_packets
++;
194 kingsun
->stats
.tx_bytes
+= skb
->len
;
198 spin_unlock(&kingsun
->lock
);
203 /* Receive callback function */
204 static void kingsun_rcv_irq(struct urb
*urb
)
206 struct kingsun_cb
*kingsun
= urb
->context
;
209 /* in process of stopping, just drop data */
210 if (!netif_running(kingsun
->netdev
)) {
211 kingsun
->receiving
= 0;
215 /* unlink, shutdown, unplug, other nasties */
216 if (urb
->status
!= 0) {
217 err("kingsun_rcv_irq: urb asynchronously failed - %d",
219 kingsun
->receiving
= 0;
223 if (urb
->actual_length
== kingsun
->max_rx
) {
224 __u8
*bytes
= urb
->transfer_buffer
;
227 /* The very first byte in the buffer indicates the length of
228 valid data in the read. This byte must be in the range
229 1..kingsun->max_rx -1 . Values outside this range indicate
230 an uninitialized Rx buffer when the dongle has just been
232 if (bytes
[0] >= 1 && bytes
[0] < kingsun
->max_rx
) {
233 for (i
= 1; i
<= bytes
[0]; i
++) {
234 async_unwrap_char(kingsun
->netdev
,
236 &kingsun
->rx_buff
, bytes
[i
]);
238 do_gettimeofday(&kingsun
->rx_time
);
240 (kingsun
->rx_buff
.state
!= OUTSIDE_FRAME
)
243 } else if (urb
->actual_length
> 0) {
244 err("%s(): Unexpected response length, expected %d got %d",
245 __func__
, kingsun
->max_rx
, urb
->actual_length
);
247 /* This urb has already been filled in kingsun_net_open */
248 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
252 * Function kingsun_net_open (dev)
254 * Network device is taken up. Usually this is done by "ifconfig irda0 up"
256 static int kingsun_net_open(struct net_device
*netdev
)
258 struct kingsun_cb
*kingsun
= netdev_priv(netdev
);
262 /* At this point, urbs are NULL, and skb is NULL (see kingsun_probe) */
263 kingsun
->receiving
= 0;
265 /* Initialize for SIR to copy data directly into skb. */
266 kingsun
->rx_buff
.in_frame
= FALSE
;
267 kingsun
->rx_buff
.state
= OUTSIDE_FRAME
;
268 kingsun
->rx_buff
.truesize
= IRDA_SKB_MAX_MTU
;
269 kingsun
->rx_buff
.skb
= dev_alloc_skb(IRDA_SKB_MAX_MTU
);
270 if (!kingsun
->rx_buff
.skb
)
273 skb_reserve(kingsun
->rx_buff
.skb
, 1);
274 kingsun
->rx_buff
.head
= kingsun
->rx_buff
.skb
->data
;
275 do_gettimeofday(&kingsun
->rx_time
);
277 kingsun
->rx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
278 if (!kingsun
->rx_urb
)
281 kingsun
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
282 if (!kingsun
->tx_urb
)
286 * Now that everything should be initialized properly,
287 * Open new IrLAP layer instance to take care of us...
289 sprintf(hwname
, "usb#%d", kingsun
->usbdev
->devnum
);
290 kingsun
->irlap
= irlap_open(netdev
, &kingsun
->qos
, hwname
);
291 if (!kingsun
->irlap
) {
292 err("kingsun-sir: irlap_open failed");
296 /* Start first reception */
297 usb_fill_int_urb(kingsun
->rx_urb
, kingsun
->usbdev
,
298 usb_rcvintpipe(kingsun
->usbdev
, kingsun
->ep_in
),
299 kingsun
->in_buf
, kingsun
->max_rx
,
300 kingsun_rcv_irq
, kingsun
, 1);
301 kingsun
->rx_urb
->status
= 0;
302 err
= usb_submit_urb(kingsun
->rx_urb
, GFP_KERNEL
);
304 err("kingsun-sir: first urb-submit failed: %d", err
);
308 netif_start_queue(netdev
);
310 /* Situation at this point:
311 - all work buffers allocated
312 - urbs allocated and ready to fill
313 - max rx packet known (in max_rx)
314 - unwrap state machine initialized, in state outside of any frame
315 - receive request in progress
316 - IrLAP layer started, about to hand over packets to send
322 irlap_close(kingsun
->irlap
);
324 if (kingsun
->tx_urb
) {
325 usb_free_urb(kingsun
->tx_urb
);
326 kingsun
->tx_urb
= NULL
;
328 if (kingsun
->rx_urb
) {
329 usb_free_urb(kingsun
->rx_urb
);
330 kingsun
->rx_urb
= NULL
;
332 if (kingsun
->rx_buff
.skb
) {
333 kfree_skb(kingsun
->rx_buff
.skb
);
334 kingsun
->rx_buff
.skb
= NULL
;
335 kingsun
->rx_buff
.head
= NULL
;
341 * Function kingsun_net_close (kingsun)
343 * Network device is taken down. Usually this is done by
344 * "ifconfig irda0 down"
346 static int kingsun_net_close(struct net_device
*netdev
)
348 struct kingsun_cb
*kingsun
= netdev_priv(netdev
);
350 /* Stop transmit processing */
351 netif_stop_queue(netdev
);
353 /* Mop up receive && transmit urb's */
354 usb_kill_urb(kingsun
->tx_urb
);
355 usb_kill_urb(kingsun
->rx_urb
);
357 usb_free_urb(kingsun
->tx_urb
);
358 usb_free_urb(kingsun
->rx_urb
);
360 kingsun
->tx_urb
= NULL
;
361 kingsun
->rx_urb
= NULL
;
363 kfree_skb(kingsun
->rx_buff
.skb
);
364 kingsun
->rx_buff
.skb
= NULL
;
365 kingsun
->rx_buff
.head
= NULL
;
366 kingsun
->rx_buff
.in_frame
= FALSE
;
367 kingsun
->rx_buff
.state
= OUTSIDE_FRAME
;
368 kingsun
->receiving
= 0;
370 /* Stop and remove instance of IrLAP */
372 irlap_close(kingsun
->irlap
);
374 kingsun
->irlap
= NULL
;
380 * IOCTLs : Extra out-of-band network commands...
382 static int kingsun_net_ioctl(struct net_device
*netdev
, struct ifreq
*rq
,
385 struct if_irda_req
*irq
= (struct if_irda_req
*) rq
;
386 struct kingsun_cb
*kingsun
= netdev_priv(netdev
);
390 case SIOCSBANDWIDTH
: /* Set bandwidth */
391 if (!capable(CAP_NET_ADMIN
))
394 /* Check if the device is still there */
395 if (netif_device_present(kingsun
->netdev
))
396 /* No observed commands for speed change */
400 case SIOCSMEDIABUSY
: /* Set media busy */
401 if (!capable(CAP_NET_ADMIN
))
404 /* Check if the IrDA stack is still there */
405 if (netif_running(kingsun
->netdev
))
406 irda_device_set_media_busy(kingsun
->netdev
, TRUE
);
410 /* Only approximately true */
411 irq
->ifr_receiving
= kingsun
->receiving
;
422 * Get device stats (for /proc/net/dev and ifconfig)
424 static struct net_device_stats
*
425 kingsun_net_get_stats(struct net_device
*netdev
)
427 struct kingsun_cb
*kingsun
= netdev_priv(netdev
);
428 return &kingsun
->stats
;
432 * This routine is called by the USB subsystem for each new device
433 * in the system. We need to check if the device is ours, and in
434 * this case start handling it.
436 static int kingsun_probe(struct usb_interface
*intf
,
437 const struct usb_device_id
*id
)
439 struct usb_host_interface
*interface
;
440 struct usb_endpoint_descriptor
*endpoint
;
442 struct usb_device
*dev
= interface_to_usbdev(intf
);
443 struct kingsun_cb
*kingsun
= NULL
;
444 struct net_device
*net
= NULL
;
446 int pipe
, maxp_in
, maxp_out
;
450 /* Check that there really are two interrupt endpoints.
451 Check based on the one in drivers/usb/input/usbmouse.c
453 interface
= intf
->cur_altsetting
;
454 if (interface
->desc
.bNumEndpoints
!= 2) {
455 err("kingsun-sir: expected 2 endpoints, found %d",
456 interface
->desc
.bNumEndpoints
);
459 endpoint
= &interface
->endpoint
[KINGSUN_EP_IN
].desc
;
460 if (!usb_endpoint_is_int_in(endpoint
)) {
461 err("kingsun-sir: endpoint 0 is not interrupt IN");
465 ep_in
= endpoint
->bEndpointAddress
;
466 pipe
= usb_rcvintpipe(dev
, ep_in
);
467 maxp_in
= usb_maxpacket(dev
, pipe
, usb_pipeout(pipe
));
468 if (maxp_in
> 255 || maxp_in
<= 1) {
469 err("%s: endpoint 0 has max packet size %d not in range",
474 endpoint
= &interface
->endpoint
[KINGSUN_EP_OUT
].desc
;
475 if (!usb_endpoint_is_int_out(endpoint
)) {
476 err("kingsun-sir: endpoint 1 is not interrupt OUT");
480 ep_out
= endpoint
->bEndpointAddress
;
481 pipe
= usb_sndintpipe(dev
, ep_out
);
482 maxp_out
= usb_maxpacket(dev
, pipe
, usb_pipeout(pipe
));
484 /* Allocate network device container. */
485 net
= alloc_irdadev(sizeof(*kingsun
));
489 SET_NETDEV_DEV(net
, &intf
->dev
);
490 kingsun
= netdev_priv(net
);
491 kingsun
->irlap
= NULL
;
492 kingsun
->tx_urb
= NULL
;
493 kingsun
->rx_urb
= NULL
;
494 kingsun
->ep_in
= ep_in
;
495 kingsun
->ep_out
= ep_out
;
496 kingsun
->in_buf
= NULL
;
497 kingsun
->out_buf
= NULL
;
498 kingsun
->max_rx
= (__u8
)maxp_in
;
499 kingsun
->max_tx
= (__u8
)maxp_out
;
500 kingsun
->netdev
= net
;
501 kingsun
->usbdev
= dev
;
502 kingsun
->rx_buff
.in_frame
= FALSE
;
503 kingsun
->rx_buff
.state
= OUTSIDE_FRAME
;
504 kingsun
->rx_buff
.skb
= NULL
;
505 kingsun
->receiving
= 0;
506 spin_lock_init(&kingsun
->lock
);
508 /* Allocate input buffer */
509 kingsun
->in_buf
= kmalloc(kingsun
->max_rx
, GFP_KERNEL
);
510 if (!kingsun
->in_buf
)
513 /* Allocate output buffer */
514 kingsun
->out_buf
= kmalloc(KINGSUN_FIFO_SIZE
, GFP_KERNEL
);
515 if (!kingsun
->out_buf
)
518 printk(KERN_INFO
"KingSun/DonShine IRDA/USB found at address %d, "
519 "Vendor: %x, Product: %x\n",
520 dev
->devnum
, le16_to_cpu(dev
->descriptor
.idVendor
),
521 le16_to_cpu(dev
->descriptor
.idProduct
));
523 /* Initialize QoS for this device */
524 irda_init_max_qos_capabilies(&kingsun
->qos
);
526 /* That's the Rx capability. */
527 kingsun
->qos
.baud_rate
.bits
&= IR_9600
;
528 kingsun
->qos
.min_turn_time
.bits
&= KINGSUN_MTT
;
529 irda_qos_bits_to_value(&kingsun
->qos
);
531 /* Override the network functions we need to use */
532 net
->hard_start_xmit
= kingsun_hard_xmit
;
533 net
->open
= kingsun_net_open
;
534 net
->stop
= kingsun_net_close
;
535 net
->get_stats
= kingsun_net_get_stats
;
536 net
->do_ioctl
= kingsun_net_ioctl
;
538 ret
= register_netdev(net
);
542 dev_info(&net
->dev
, "IrDA: Registered KingSun/DonShine device %s\n",
545 usb_set_intfdata(intf
, kingsun
);
547 /* Situation at this point:
548 - all work buffers allocated
549 - urbs not allocated, set to NULL
550 - max rx packet known (in max_rx)
551 - unwrap state machine (partially) initialized, but skb == NULL
557 if (kingsun
->out_buf
) kfree(kingsun
->out_buf
);
558 if (kingsun
->in_buf
) kfree(kingsun
->in_buf
);
565 * The current device is removed, the USB layer tell us to shut it down...
567 static void kingsun_disconnect(struct usb_interface
*intf
)
569 struct kingsun_cb
*kingsun
= usb_get_intfdata(intf
);
574 unregister_netdev(kingsun
->netdev
);
576 /* Mop up receive && transmit urb's */
577 if (kingsun
->tx_urb
!= NULL
) {
578 usb_kill_urb(kingsun
->tx_urb
);
579 usb_free_urb(kingsun
->tx_urb
);
580 kingsun
->tx_urb
= NULL
;
582 if (kingsun
->rx_urb
!= NULL
) {
583 usb_kill_urb(kingsun
->rx_urb
);
584 usb_free_urb(kingsun
->rx_urb
);
585 kingsun
->rx_urb
= NULL
;
588 kfree(kingsun
->out_buf
);
589 kfree(kingsun
->in_buf
);
590 free_netdev(kingsun
->netdev
);
592 usb_set_intfdata(intf
, NULL
);
596 /* USB suspend, so power off the transmitter/receiver */
597 static int kingsun_suspend(struct usb_interface
*intf
, pm_message_t message
)
599 struct kingsun_cb
*kingsun
= usb_get_intfdata(intf
);
601 netif_device_detach(kingsun
->netdev
);
602 if (kingsun
->tx_urb
!= NULL
) usb_kill_urb(kingsun
->tx_urb
);
603 if (kingsun
->rx_urb
!= NULL
) usb_kill_urb(kingsun
->rx_urb
);
607 /* Coming out of suspend, so reset hardware */
608 static int kingsun_resume(struct usb_interface
*intf
)
610 struct kingsun_cb
*kingsun
= usb_get_intfdata(intf
);
612 if (kingsun
->rx_urb
!= NULL
)
613 usb_submit_urb(kingsun
->rx_urb
, GFP_KERNEL
);
614 netif_device_attach(kingsun
->netdev
);
621 * USB device callbacks
623 static struct usb_driver irda_driver
= {
624 .name
= "kingsun-sir",
625 .probe
= kingsun_probe
,
626 .disconnect
= kingsun_disconnect
,
629 .suspend
= kingsun_suspend
,
630 .resume
= kingsun_resume
,
637 static int __init
kingsun_init(void)
639 return usb_register(&irda_driver
);
641 module_init(kingsun_init
);
646 static void __exit
kingsun_cleanup(void)
648 /* Deregister the driver and remove all pending instances */
649 usb_deregister(&irda_driver
);
651 module_exit(kingsun_cleanup
);
653 MODULE_AUTHOR("Alex Villacís Lasso <a_villacis@palosanto.com>");
654 MODULE_DESCRIPTION("IrDA-USB Dongle Driver for KingSun/DonShine");
655 MODULE_LICENSE("GPL");
This page took 0.061724 seconds and 5 git commands to generate.