blob: 648e54b3f00e97411fb04e2d46e1574e80602270 [file] [log] [blame]
Alex Villac�s Lassoa2af4212007-05-09 16:18:21 -07001/*****************************************************************************
2*
3* Filename: kingsun-sir.c
4* Version: 0.1.1
5* Description: Irda KingSun/DonShine USB Dongle
6* Status: Experimental
Samuel Ortiz66f5e512007-07-02 22:56:15 -07007* Author: Alex Villacís Lasso <a_villacis@palosanto.com>
Alex Villac�s Lassoa2af4212007-05-09 16:18:21 -07008*
9* Based on stir4200 and mcs7780 drivers, with (strange?) differences
10*
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.
14*
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.
19*
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.
23*
24*****************************************************************************/
25
26/*
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:
31 *
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
59 * 9600bps (SIR).
60 */
61
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>
Alex Villac�s Lassoa2af4212007-05-09 16:18:21 -070069#include <linux/kref.h>
70#include <linux/usb.h>
71#include <linux/device.h>
72#include <linux/crc32.h>
73
74#include <asm/unaligned.h>
75#include <asm/byteorder.h>
76#include <asm/uaccess.h>
77
78#include <net/irda/irda.h>
79#include <net/irda/wrapper.h>
80#include <net/irda/crc.h>
81
82/*
83 * According to lsusb, 0x07c0 is assigned to
84 * "Code Mercenaries Hard- und Software GmbH"
85 */
86#define KING_VENDOR_ID 0x07c0
87#define KING_PRODUCT_ID 0x4200
88
89/* These are the currently known USB ids */
90static struct usb_device_id dongles[] = {
91 /* KingSun Co,Ltd IrDA/USB Bridge */
92 { USB_DEVICE(KING_VENDOR_ID, KING_PRODUCT_ID) },
93 { }
94};
95
96MODULE_DEVICE_TABLE(usb, dongles);
97
98#define KINGSUN_MTT 0x07
99
100#define KINGSUN_FIFO_SIZE 4096
101#define KINGSUN_EP_IN 0
102#define KINGSUN_EP_OUT 1
103
104struct kingsun_cb {
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 */
109 struct qos_info qos;
110
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
116 (usually 8) */
117
118 iobuff_t rx_buff; /* receive unwrap state machine */
119 struct timeval rx_time;
120 spinlock_t lock;
121 int receiving;
122
123 __u8 ep_in;
124 __u8 ep_out;
125
126 struct urb *tx_urb;
127 struct urb *rx_urb;
128};
129
130/* Callback transmission routine */
131static void kingsun_send_irq(struct urb *urb)
132{
133 struct kingsun_cb *kingsun = urb->context;
134 struct net_device *netdev = kingsun->netdev;
135
136 /* in process of stopping, just drop data */
137 if (!netif_running(kingsun->netdev)) {
138 err("kingsun_send_irq: Network not running!");
139 return;
140 }
141
142 /* unlink, shutdown, unplug, other nasties */
143 if (urb->status != 0) {
144 err("kingsun_send_irq: urb asynchronously failed - %d",
145 urb->status);
146 }
147 netif_wake_queue(netdev);
148}
149
150/*
151 * Called from net/core when new frame is available.
152 */
153static int kingsun_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
154{
155 struct kingsun_cb *kingsun;
156 int wraplen;
157 int ret = 0;
158
159 if (skb == NULL || netdev == NULL)
160 return -EINVAL;
161
162 netif_stop_queue(netdev);
163
164 /* the IRDA wrapping routines don't deal with non linear skb */
165 SKB_LINEAR_ASSERT(skb);
166
167 kingsun = netdev_priv(netdev);
168
169 spin_lock(&kingsun->lock);
170
171 /* Append data to the end of whatever data remains to be transmitted */
172 wraplen = async_wrap_skb(skb,
173 kingsun->out_buf,
174 KINGSUN_FIFO_SIZE);
175
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,
180 kingsun, 1);
181
182 if ((ret = usb_submit_urb(kingsun->tx_urb, GFP_ATOMIC))) {
183 err("kingsun_hard_xmit: failed tx_urb submit: %d", ret);
184 switch (ret) {
185 case -ENODEV:
186 case -EPIPE:
187 break;
188 default:
189 kingsun->stats.tx_errors++;
190 netif_start_queue(netdev);
191 }
192 } else {
193 kingsun->stats.tx_packets++;
194 kingsun->stats.tx_bytes += skb->len;
195 }
196
197 dev_kfree_skb(skb);
198 spin_unlock(&kingsun->lock);
199
200 return ret;
201}
202
203/* Receive callback function */
204static void kingsun_rcv_irq(struct urb *urb)
205{
206 struct kingsun_cb *kingsun = urb->context;
207 int ret;
208
209 /* in process of stopping, just drop data */
210 if (!netif_running(kingsun->netdev)) {
211 kingsun->receiving = 0;
212 return;
213 }
214
215 /* unlink, shutdown, unplug, other nasties */
216 if (urb->status != 0) {
217 err("kingsun_rcv_irq: urb asynchronously failed - %d",
218 urb->status);
219 kingsun->receiving = 0;
220 return;
221 }
222
223 if (urb->actual_length == kingsun->max_rx) {
224 __u8 *bytes = urb->transfer_buffer;
225 int i;
226
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
231 plugged in. */
232 if (bytes[0] >= 1 && bytes[0] < kingsun->max_rx) {
233 for (i = 1; i <= bytes[0]; i++) {
234 async_unwrap_char(kingsun->netdev,
235 &kingsun->stats,
236 &kingsun->rx_buff, bytes[i]);
237 }
238 kingsun->netdev->last_rx = jiffies;
239 do_gettimeofday(&kingsun->rx_time);
240 kingsun->receiving =
241 (kingsun->rx_buff.state != OUTSIDE_FRAME)
242 ? 1 : 0;
243 }
244 } else if (urb->actual_length > 0) {
245 err("%s(): Unexpected response length, expected %d got %d",
246 __FUNCTION__, kingsun->max_rx, urb->actual_length);
247 }
248 /* This urb has already been filled in kingsun_net_open */
249 ret = usb_submit_urb(urb, GFP_ATOMIC);
250}
251
252/*
253 * Function kingsun_net_open (dev)
254 *
255 * Network device is taken up. Usually this is done by "ifconfig irda0 up"
256 */
257static int kingsun_net_open(struct net_device *netdev)
258{
259 struct kingsun_cb *kingsun = netdev_priv(netdev);
260 int err = -ENOMEM;
261 char hwname[16];
262
263 /* At this point, urbs are NULL, and skb is NULL (see kingsun_probe) */
264 kingsun->receiving = 0;
265
266 /* Initialize for SIR to copy data directly into skb. */
267 kingsun->rx_buff.in_frame = FALSE;
268 kingsun->rx_buff.state = OUTSIDE_FRAME;
269 kingsun->rx_buff.truesize = IRDA_SKB_MAX_MTU;
270 kingsun->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
271 if (!kingsun->rx_buff.skb)
272 goto free_mem;
273
274 skb_reserve(kingsun->rx_buff.skb, 1);
275 kingsun->rx_buff.head = kingsun->rx_buff.skb->data;
276 do_gettimeofday(&kingsun->rx_time);
277
278 kingsun->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
279 if (!kingsun->rx_urb)
280 goto free_mem;
281
282 kingsun->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
283 if (!kingsun->tx_urb)
284 goto free_mem;
285
286 /*
287 * Now that everything should be initialized properly,
288 * Open new IrLAP layer instance to take care of us...
289 */
290 sprintf(hwname, "usb#%d", kingsun->usbdev->devnum);
291 kingsun->irlap = irlap_open(netdev, &kingsun->qos, hwname);
292 if (!kingsun->irlap) {
293 err("kingsun-sir: irlap_open failed");
294 goto free_mem;
295 }
296
297 /* Start first reception */
298 usb_fill_int_urb(kingsun->rx_urb, kingsun->usbdev,
299 usb_rcvintpipe(kingsun->usbdev, kingsun->ep_in),
300 kingsun->in_buf, kingsun->max_rx,
301 kingsun_rcv_irq, kingsun, 1);
302 kingsun->rx_urb->status = 0;
303 err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
304 if (err) {
305 err("kingsun-sir: first urb-submit failed: %d", err);
306 goto close_irlap;
307 }
308
309 netif_start_queue(netdev);
310
311 /* Situation at this point:
312 - all work buffers allocated
313 - urbs allocated and ready to fill
314 - max rx packet known (in max_rx)
315 - unwrap state machine initialized, in state outside of any frame
316 - receive request in progress
317 - IrLAP layer started, about to hand over packets to send
318 */
319
320 return 0;
321
322 close_irlap:
323 irlap_close(kingsun->irlap);
324 free_mem:
325 if (kingsun->tx_urb) {
326 usb_free_urb(kingsun->tx_urb);
327 kingsun->tx_urb = NULL;
328 }
329 if (kingsun->rx_urb) {
330 usb_free_urb(kingsun->rx_urb);
331 kingsun->rx_urb = NULL;
332 }
333 if (kingsun->rx_buff.skb) {
334 kfree_skb(kingsun->rx_buff.skb);
335 kingsun->rx_buff.skb = NULL;
336 kingsun->rx_buff.head = NULL;
337 }
338 return err;
339}
340
341/*
342 * Function kingsun_net_close (kingsun)
343 *
344 * Network device is taken down. Usually this is done by
345 * "ifconfig irda0 down"
346 */
347static int kingsun_net_close(struct net_device *netdev)
348{
349 struct kingsun_cb *kingsun = netdev_priv(netdev);
350
351 /* Stop transmit processing */
352 netif_stop_queue(netdev);
353
354 /* Mop up receive && transmit urb's */
355 usb_kill_urb(kingsun->tx_urb);
356 usb_kill_urb(kingsun->rx_urb);
357
358 usb_free_urb(kingsun->tx_urb);
359 usb_free_urb(kingsun->rx_urb);
360
361 kingsun->tx_urb = NULL;
362 kingsun->rx_urb = NULL;
363
364 kfree_skb(kingsun->rx_buff.skb);
365 kingsun->rx_buff.skb = NULL;
366 kingsun->rx_buff.head = NULL;
367 kingsun->rx_buff.in_frame = FALSE;
368 kingsun->rx_buff.state = OUTSIDE_FRAME;
369 kingsun->receiving = 0;
370
371 /* Stop and remove instance of IrLAP */
372 if (kingsun->irlap)
373 irlap_close(kingsun->irlap);
374
375 kingsun->irlap = NULL;
376
377 return 0;
378}
379
380/*
381 * IOCTLs : Extra out-of-band network commands...
382 */
383static int kingsun_net_ioctl(struct net_device *netdev, struct ifreq *rq,
384 int cmd)
385{
386 struct if_irda_req *irq = (struct if_irda_req *) rq;
387 struct kingsun_cb *kingsun = netdev_priv(netdev);
388 int ret = 0;
389
390 switch (cmd) {
391 case SIOCSBANDWIDTH: /* Set bandwidth */
392 if (!capable(CAP_NET_ADMIN))
393 return -EPERM;
394
395 /* Check if the device is still there */
396 if (netif_device_present(kingsun->netdev))
397 /* No observed commands for speed change */
398 ret = -EOPNOTSUPP;
399 break;
400
401 case SIOCSMEDIABUSY: /* Set media busy */
402 if (!capable(CAP_NET_ADMIN))
403 return -EPERM;
404
405 /* Check if the IrDA stack is still there */
406 if (netif_running(kingsun->netdev))
407 irda_device_set_media_busy(kingsun->netdev, TRUE);
408 break;
409
410 case SIOCGRECEIVING:
411 /* Only approximately true */
412 irq->ifr_receiving = kingsun->receiving;
413 break;
414
415 default:
416 ret = -EOPNOTSUPP;
417 }
418
419 return ret;
420}
421
422/*
423 * Get device stats (for /proc/net/dev and ifconfig)
424 */
425static struct net_device_stats *
426kingsun_net_get_stats(struct net_device *netdev)
427{
428 struct kingsun_cb *kingsun = netdev_priv(netdev);
429 return &kingsun->stats;
430}
431
432/*
433 * This routine is called by the USB subsystem for each new device
434 * in the system. We need to check if the device is ours, and in
435 * this case start handling it.
436 */
437static int kingsun_probe(struct usb_interface *intf,
438 const struct usb_device_id *id)
439{
440 struct usb_host_interface *interface;
441 struct usb_endpoint_descriptor *endpoint;
442
443 struct usb_device *dev = interface_to_usbdev(intf);
444 struct kingsun_cb *kingsun = NULL;
445 struct net_device *net = NULL;
446 int ret = -ENOMEM;
447 int pipe, maxp_in, maxp_out;
448 __u8 ep_in;
449 __u8 ep_out;
450
451 /* Check that there really are two interrupt endpoints.
452 Check based on the one in drivers/usb/input/usbmouse.c
453 */
454 interface = intf->cur_altsetting;
455 if (interface->desc.bNumEndpoints != 2) {
456 err("kingsun-sir: expected 2 endpoints, found %d",
457 interface->desc.bNumEndpoints);
458 return -ENODEV;
459 }
460 endpoint = &interface->endpoint[KINGSUN_EP_IN].desc;
461 if (!usb_endpoint_is_int_in(endpoint)) {
462 err("kingsun-sir: endpoint 0 is not interrupt IN");
463 return -ENODEV;
464 }
465
466 ep_in = endpoint->bEndpointAddress;
467 pipe = usb_rcvintpipe(dev, ep_in);
468 maxp_in = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
469 if (maxp_in > 255 || maxp_in <= 1) {
470 err("%s: endpoint 0 has max packet size %d not in range",
471 __FILE__, maxp_in);
472 return -ENODEV;
473 }
474
475 endpoint = &interface->endpoint[KINGSUN_EP_OUT].desc;
476 if (!usb_endpoint_is_int_out(endpoint)) {
477 err("kingsun-sir: endpoint 1 is not interrupt OUT");
478 return -ENODEV;
479 }
480
481 ep_out = endpoint->bEndpointAddress;
482 pipe = usb_sndintpipe(dev, ep_out);
483 maxp_out = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
484
485 /* Allocate network device container. */
486 net = alloc_irdadev(sizeof(*kingsun));
487 if(!net)
488 goto err_out1;
489
Alex Villac�s Lassoa2af4212007-05-09 16:18:21 -0700490 SET_NETDEV_DEV(net, &intf->dev);
491 kingsun = netdev_priv(net);
492 kingsun->irlap = NULL;
493 kingsun->tx_urb = NULL;
494 kingsun->rx_urb = NULL;
495 kingsun->ep_in = ep_in;
496 kingsun->ep_out = ep_out;
497 kingsun->in_buf = NULL;
498 kingsun->out_buf = NULL;
499 kingsun->max_rx = (__u8)maxp_in;
500 kingsun->max_tx = (__u8)maxp_out;
501 kingsun->netdev = net;
502 kingsun->usbdev = dev;
503 kingsun->rx_buff.in_frame = FALSE;
504 kingsun->rx_buff.state = OUTSIDE_FRAME;
505 kingsun->rx_buff.skb = NULL;
506 kingsun->receiving = 0;
507 spin_lock_init(&kingsun->lock);
508
509 /* Allocate input buffer */
Jesper Juhl901ded22007-08-24 23:23:41 -0700510 kingsun->in_buf = kmalloc(kingsun->max_rx, GFP_KERNEL);
Alex Villac�s Lassoa2af4212007-05-09 16:18:21 -0700511 if (!kingsun->in_buf)
512 goto free_mem;
513
514 /* Allocate output buffer */
Jesper Juhl901ded22007-08-24 23:23:41 -0700515 kingsun->out_buf = kmalloc(KINGSUN_FIFO_SIZE, GFP_KERNEL);
Alex Villac�s Lassoa2af4212007-05-09 16:18:21 -0700516 if (!kingsun->out_buf)
517 goto free_mem;
518
519 printk(KERN_INFO "KingSun/DonShine IRDA/USB found at address %d, "
520 "Vendor: %x, Product: %x\n",
521 dev->devnum, le16_to_cpu(dev->descriptor.idVendor),
522 le16_to_cpu(dev->descriptor.idProduct));
523
524 /* Initialize QoS for this device */
525 irda_init_max_qos_capabilies(&kingsun->qos);
526
527 /* That's the Rx capability. */
528 kingsun->qos.baud_rate.bits &= IR_9600;
529 kingsun->qos.min_turn_time.bits &= KINGSUN_MTT;
530 irda_qos_bits_to_value(&kingsun->qos);
531
532 /* Override the network functions we need to use */
533 net->hard_start_xmit = kingsun_hard_xmit;
534 net->open = kingsun_net_open;
535 net->stop = kingsun_net_close;
536 net->get_stats = kingsun_net_get_stats;
537 net->do_ioctl = kingsun_net_ioctl;
538
539 ret = register_netdev(net);
540 if (ret != 0)
541 goto free_mem;
542
543 info("IrDA: Registered KingSun/DonShine device %s", net->name);
544
545 usb_set_intfdata(intf, kingsun);
546
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
552 */
553
554 return 0;
555
556free_mem:
557 if (kingsun->out_buf) kfree(kingsun->out_buf);
558 if (kingsun->in_buf) kfree(kingsun->in_buf);
559 free_netdev(net);
560err_out1:
561 return ret;
562}
563
564/*
565 * The current device is removed, the USB layer tell us to shut it down...
566 */
567static void kingsun_disconnect(struct usb_interface *intf)
568{
569 struct kingsun_cb *kingsun = usb_get_intfdata(intf);
570
571 if (!kingsun)
572 return;
573
574 unregister_netdev(kingsun->netdev);
575
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;
581 }
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;
586 }
587
588 kfree(kingsun->out_buf);
589 kfree(kingsun->in_buf);
590 free_netdev(kingsun->netdev);
591
592 usb_set_intfdata(intf, NULL);
593}
594
595#ifdef CONFIG_PM
596/* USB suspend, so power off the transmitter/receiver */
597static int kingsun_suspend(struct usb_interface *intf, pm_message_t message)
598{
599 struct kingsun_cb *kingsun = usb_get_intfdata(intf);
600
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);
604 return 0;
605}
606
607/* Coming out of suspend, so reset hardware */
608static int kingsun_resume(struct usb_interface *intf)
609{
610 struct kingsun_cb *kingsun = usb_get_intfdata(intf);
611
612 if (kingsun->rx_urb != NULL)
613 usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
614 netif_device_attach(kingsun->netdev);
615
616 return 0;
617}
618#endif
619
620/*
621 * USB device callbacks
622 */
623static struct usb_driver irda_driver = {
624 .name = "kingsun-sir",
625 .probe = kingsun_probe,
626 .disconnect = kingsun_disconnect,
627 .id_table = dongles,
628#ifdef CONFIG_PM
629 .suspend = kingsun_suspend,
630 .resume = kingsun_resume,
631#endif
632};
633
634/*
635 * Module insertion
636 */
637static int __init kingsun_init(void)
638{
639 return usb_register(&irda_driver);
640}
641module_init(kingsun_init);
642
643/*
644 * Module removal
645 */
646static void __exit kingsun_cleanup(void)
647{
648 /* Deregister the driver and remove all pending instances */
649 usb_deregister(&irda_driver);
650}
651module_exit(kingsun_cleanup);
652
Samuel Ortiz66f5e512007-07-02 22:56:15 -0700653MODULE_AUTHOR("Alex Villacís Lasso <a_villacis@palosanto.com>");
Alex Villac�s Lassoa2af4212007-05-09 16:18:21 -0700654MODULE_DESCRIPTION("IrDA-USB Dongle Driver for KingSun/DonShine");
655MODULE_LICENSE("GPL");