git.oblomov.eu Git - linux-2.6/blob - drivers/net/irda/ks959-sir.c

   1 /*****************************************************************************
   2 *
   3 * Filename:      ks959-sir.c
   4 * Version:       0.1.2
   5 * Description:   Irda KingSun KS-959 USB Dongle
   6 * Status:        Experimental
   7 * Author:        Alex Villacís Lasso <a_villacis@palosanto.com>
   8 *         with help from Domen Puncer <domen@coderock.org>
   9 *
  10 *    Based on stir4200, mcs7780, kingsun-sir drivers.
  11 *
  12 *    This program is free software; you can redistribute it and/or modify
  13 *    it under the terms of the GNU General Public License as published by
  14 *    the Free Software Foundation; either version 2 of the License.
  15 *
  16 *    This program is distributed in the hope that it will be useful,
  17 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 *    GNU General Public License for more details.
  20 *
  21 *    You should have received a copy of the GNU General Public License
  22 *    along with this program; if not, write to the Free Software
  23 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24 *
  25 *****************************************************************************/
  26
  27 /*
  28  * Following is my most current (2007-07-17) understanding of how the Kingsun
  29  * KS-959 dongle is supposed to work. This information was deduced by
  30  * reverse-engineering and examining the USB traffic captured with USBSnoopy
  31  * from the WinXP driver. Feel free to update here as more of the dongle is
  32  * known.
  33  *
  34  * My most sincere thanks must go to Domen Puncer <domen@coderock.org> for
  35  * invaluable help in cracking the obfuscation and padding required for this
  36  * dongle.
  37  *
  38  * General: This dongle exposes one interface with one interrupt IN endpoint.
  39  * However, the interrupt endpoint is NOT used at all for this dongle. Instead,
  40  * this dongle uses control transfers for everything, including sending and
  41  * receiving the IrDA frame data. Apparently the interrupt endpoint is just a
  42  * dummy to ensure the dongle has a valid interface to present to the PC.And I
  43  * thought the DonShine dongle was weird... In addition, this dongle uses
  44  * obfuscation (?!?!), applied at the USB level, to hide the traffic, both sent
  45  * and received, from the dongle. I call it obfuscation because the XOR keying
  46  * and padding required to produce an USB traffic acceptable for the dongle can
  47  * not be explained by any other technical requirement.
  48  *
  49  * Transmission: To transmit an IrDA frame, the driver must prepare a control
  50  * URB with the following as a setup packet:
  51  *    bRequestType    USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE
  52  *    bRequest        0x09
  53  *    wValue          <length of valid data before padding, little endian>
  54  *    wIndex          0x0000
  55  *    wLength         <length of padded data>
  56  * The payload packet must be manually wrapped and escaped (as in stir4200.c),
  57  * then padded and obfuscated before being sent. Both padding and obfuscation
  58  * are implemented in the procedure obfuscate_tx_buffer(). Suffice to say, the
  59  * designer/programmer of the dongle used his name as a source for the
  60  * obfuscation. WTF?!
  61  * Apparently the dongle cannot handle payloads larger than 256 bytes. The
  62  * driver has to perform fragmentation in order to send anything larger than
  63  * this limit.
  64  *
  65  * Reception: To receive data, the driver must poll the dongle regularly (like
  66  * kingsun-sir.c) with control URBs and the following as a setup packet:
  67  *    bRequestType    USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE
  68  *    bRequest        0x01
  69  *    wValue          0x0200
  70  *    wIndex          0x0000
  71  *    wLength         0x0800 (size of available buffer)
  72  * If there is data to be read, it will be returned as the response payload.
  73  * This data is (apparently) not padded, but it is obfuscated. To de-obfuscate
  74  * it, the driver must XOR every byte, in sequence, with a value that starts at
  75  * 1 and is incremented with each byte processed, and then with 0x55. The value
  76  * incremented with each byte processed overflows as an unsigned char. The
  77  * resulting bytes form a wrapped SIR frame that is unwrapped and unescaped
  78  * as in stir4200.c The incremented value is NOT reset with each frame, but is
  79  * kept across the entire session with the dongle. Also, the dongle inserts an
  80  * extra garbage byte with value 0x95 (after decoding) every 0xff bytes, which
  81  * must be skipped.
  82  *
  83  * Speed change: To change the speed of the dongle, the driver prepares a
  84  * control URB with the following as a setup packet:
  85  *    bRequestType    USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE
  86  *    bRequest        0x09
  87  *    wValue          0x0200
  88  *    wIndex          0x0001
  89  *    wLength         0x0008 (length of the payload)
  90  * The payload is a 8-byte record, apparently identical to the one used in
  91  * drivers/usb/serial/cypress_m8.c to change speed:
  92  *     __u32 baudSpeed;
  93  *    unsigned int dataBits : 2;    // 0 - 5 bits 3 - 8 bits
  94  *    unsigned int : 1;
  95  *    unsigned int stopBits : 1;
  96  *    unsigned int parityEnable : 1;
  97  *    unsigned int parityType : 1;
  98  *    unsigned int : 1;
  99  *    unsigned int reset : 1;
 100  *    unsigned char reserved[3];    // set to 0
 101  *
 102  * For now only SIR speeds have been observed with this dongle. Therefore,
 103  * nothing is known on what changes (if any) must be done to frame wrapping /
 104  * unwrapping for higher than SIR speeds. This driver assumes no change is
 105  * necessary and announces support for all the way to 57600 bps. Although the
 106  * package announces support for up to 4MBps, tests with a Sony Ericcson K300
 107  * phone show corruption when receiving large frames at 115200 bps, the highest
 108  * speed announced by the phone. However, transmission at 115200 bps is OK. Go
 109  * figure. Since I don't know whether the phone or the dongle is at fault, max
 110  * announced speed is 57600 bps until someone produces a device that can run
 111  * at higher speeds with this dongle.
 112  */
 113
 114 #include <linux/module.h>
 115 #include <linux/moduleparam.h>
 116 #include <linux/kernel.h>
 117 #include <linux/types.h>
 118 #include <linux/errno.h>
 119 #include <linux/init.h>
 120 #include <linux/slab.h>
 121 #include <linux/kref.h>
 122 #include <linux/usb.h>
 123 #include <linux/device.h>
 124 #include <linux/crc32.h>
 125
 126 #include <asm/unaligned.h>
 127 #include <asm/byteorder.h>
 128 #include <asm/uaccess.h>
 129
 130 #include <net/irda/irda.h>
 131 #include <net/irda/wrapper.h>
 132 #include <net/irda/crc.h>
 133
 134 #define KS959_VENDOR_ID 0x07d0
 135 #define KS959_PRODUCT_ID 0x4959
 136
 137 /* These are the currently known USB ids */
 138 static struct usb_device_id dongles[] = {
 139         /* KingSun Co,Ltd  IrDA/USB Bridge */
 140         {USB_DEVICE(KS959_VENDOR_ID, KS959_PRODUCT_ID)},
 141         {}
 142 };
 143
 144 MODULE_DEVICE_TABLE(usb, dongles);
 145
 146 #define KINGSUN_MTT 0x07
 147 #define KINGSUN_REQ_RECV 0x01
 148 #define KINGSUN_REQ_SEND 0x09
 149
 150 #define KINGSUN_RCV_FIFO_SIZE    2048   /* Max length we can receive */
 151 #define KINGSUN_SND_FIFO_SIZE    2048   /* Max packet we can send */
 152 #define KINGSUN_SND_PACKET_SIZE    256  /* Max packet dongle can handle */
 153
 154 struct ks959_speedparams {
 155         __le32 baudrate;        /* baud rate, little endian */
 156         __u8 flags;
 157         __u8 reserved[3];
 158 } __attribute__ ((packed));
 159
 160 #define KS_DATA_5_BITS 0x00
 161 #define KS_DATA_6_BITS 0x01
 162 #define KS_DATA_7_BITS 0x02
 163 #define KS_DATA_8_BITS 0x03
 164
 165 #define KS_STOP_BITS_1 0x00
 166 #define KS_STOP_BITS_2 0x08
 167
 168 #define KS_PAR_DISABLE    0x00
 169 #define KS_PAR_EVEN    0x10
 170 #define KS_PAR_ODD    0x30
 171 #define KS_RESET    0x80
 172
 173 struct ks959_cb {
 174         struct usb_device *usbdev;      /* init: probe_irda */
 175         struct net_device *netdev;      /* network layer */
 176         struct irlap_cb *irlap; /* The link layer we are binded to */
 177         struct net_device_stats stats;  /* network statistics */
 178         struct qos_info qos;
 179
 180         struct usb_ctrlrequest *tx_setuprequest;
 181         struct urb *tx_urb;
 182         __u8 *tx_buf_clear;
 183         unsigned int tx_buf_clear_used;
 184         unsigned int tx_buf_clear_sent;
 185         __u8 *tx_buf_xored;
 186
 187         struct usb_ctrlrequest *rx_setuprequest;
 188         struct urb *rx_urb;
 189         __u8 *rx_buf;
 190         __u8 rx_variable_xormask;
 191         iobuff_t rx_unwrap_buff;
 192         struct timeval rx_time;
 193
 194         struct usb_ctrlrequest *speed_setuprequest;
 195         struct urb *speed_urb;
 196         struct ks959_speedparams speedparams;
 197         unsigned int new_speed;
 198
 199         spinlock_t lock;
 200         int receiving;
 201 };
 202
 203 /* Procedure to perform the obfuscation/padding expected by the dongle
 204  *
 205  * buf_cleartext    (IN) Cleartext version of the IrDA frame to transmit
 206  * len_cleartext    (IN) Length of the cleartext version of IrDA frame
 207  * buf_xoredtext    (OUT) Obfuscated version of frame built by proc
 208  * len_maxbuf        (OUT) Maximum space available at buf_xoredtext
 209  *
 210  * (return)         length of obfuscated frame with padding
 211  *
 212  * If not enough space (as indicated by len_maxbuf vs. required padding),
 213  * zero is returned
 214  *
 215  * The value of lookup_string is actually a required portion of the algorithm.
 216  * Seems the designer of the dongle wanted to state who exactly is responsible
 217  * for implementing obfuscation. Send your best (or other) wishes to him ]:-)
 218  */
 219 static unsigned int obfuscate_tx_buffer(const __u8 * buf_cleartext,
 220                                         unsigned int len_cleartext,
 221                                         __u8 * buf_xoredtext,
 222                                         unsigned int len_maxbuf)
 223 {
 224         unsigned int len_xoredtext;
 225
 226         /* Calculate required length with padding, check for necessary space */
 227         len_xoredtext = ((len_cleartext + 7) & ~0x7) + 0x10;
 228         if (len_xoredtext <= len_maxbuf) {
 229                 static const __u8 lookup_string[] = "wangshuofei19710";
 230                 __u8 xor_mask;
 231
 232                 /* Unlike the WinXP driver, we *do* clear out the padding */
 233                 memset(buf_xoredtext, 0, len_xoredtext);
 234
 235                 xor_mask = lookup_string[(len_cleartext & 0x0f) ^ 0x06] ^ 0x55;
 236
 237                 while (len_cleartext-- > 0) {
 238                         *buf_xoredtext++ = *buf_cleartext++ ^ xor_mask;
 239                 }
 240         } else {
 241                 len_xoredtext = 0;
 242         }
 243         return len_xoredtext;
 244 }
 245
 246 /* Callback transmission routine */
 247 static void ks959_speed_irq(struct urb *urb)
 248 {
 249         /* unlink, shutdown, unplug, other nasties */
 250         if (urb->status != 0) {
 251                 err("ks959_speed_irq: urb asynchronously failed - %d",
 252                     urb->status);
 253         }
 254 }
 255
 256 /* Send a control request to change speed of the dongle */
 257 static int ks959_change_speed(struct ks959_cb *kingsun, unsigned speed)
 258 {
 259         static unsigned int supported_speeds[] = { 2400, 9600, 19200, 38400,
 260                 57600, 115200, 576000, 1152000, 4000000, 0
 261         };
 262         int err;
 263         unsigned int i;
 264
 265         if (kingsun->speed_setuprequest == NULL || kingsun->speed_urb == NULL)
 266                 return -ENOMEM;
 267
 268         /* Check that requested speed is among the supported ones */
 269         for (i = 0; supported_speeds[i] && supported_speeds[i] != speed; i++) ;
 270         if (supported_speeds[i] == 0)
 271                 return -EOPNOTSUPP;
 272
 273         memset(&(kingsun->speedparams), 0, sizeof(struct ks959_speedparams));
 274         kingsun->speedparams.baudrate = cpu_to_le32(speed);
 275         kingsun->speedparams.flags = KS_DATA_8_BITS;
 276
 277         /* speed_setuprequest pre-filled in ks959_probe */
 278         usb_fill_control_urb(kingsun->speed_urb, kingsun->usbdev,
 279                              usb_sndctrlpipe(kingsun->usbdev, 0),
 280                              (unsigned char *)kingsun->speed_setuprequest,
 281                              &(kingsun->speedparams),
 282                              sizeof(struct ks959_speedparams), ks959_speed_irq,
 283                              kingsun);
 284         kingsun->speed_urb->status = 0;
 285         err = usb_submit_urb(kingsun->speed_urb, GFP_ATOMIC);
 286
 287         return err;
 288 }
 289
 290 /* Submit one fragment of an IrDA frame to the dongle */
 291 static void ks959_send_irq(struct urb *urb);
 292 static int ks959_submit_tx_fragment(struct ks959_cb *kingsun)
 293 {
 294         unsigned int padlen;
 295         unsigned int wraplen;
 296         int ret;
 297
 298         /* Check whether current plaintext can produce a padded buffer that fits
 299            within the range handled by the dongle */
 300         wraplen = (KINGSUN_SND_PACKET_SIZE & ~0x7) - 0x10;
 301         if (wraplen > kingsun->tx_buf_clear_used)
 302                 wraplen = kingsun->tx_buf_clear_used;
 303
 304         /* Perform dongle obfuscation. Also remove the portion of the frame that
 305            was just obfuscated and will now be sent to the dongle. */
 306         padlen = obfuscate_tx_buffer(kingsun->tx_buf_clear, wraplen,
 307                                      kingsun->tx_buf_xored,
 308                                      KINGSUN_SND_PACKET_SIZE);
 309
 310         /* Calculate how much data can be transmitted in this urb */
 311         kingsun->tx_setuprequest->wValue = cpu_to_le16(wraplen);
 312         kingsun->tx_setuprequest->wLength = cpu_to_le16(padlen);
 313         /* Rest of the fields were filled in ks959_probe */
 314         usb_fill_control_urb(kingsun->tx_urb, kingsun->usbdev,
 315                              usb_sndctrlpipe(kingsun->usbdev, 0),
 316                              (unsigned char *)kingsun->tx_setuprequest,
 317                              kingsun->tx_buf_xored, padlen,
 318                              ks959_send_irq, kingsun);
 319         kingsun->tx_urb->status = 0;
 320         ret = usb_submit_urb(kingsun->tx_urb, GFP_ATOMIC);
 321
 322         /* Remember how much data was sent, in order to update at callback */
 323         kingsun->tx_buf_clear_sent = (ret == 0) ? wraplen : 0;
 324         return ret;
 325 }
 326
 327 /* Callback transmission routine */
 328 static void ks959_send_irq(struct urb *urb)
 329 {
 330         struct ks959_cb *kingsun = urb->context;
 331         struct net_device *netdev = kingsun->netdev;
 332         int ret = 0;
 333
 334         /* in process of stopping, just drop data */
 335         if (!netif_running(kingsun->netdev)) {
 336                 err("ks959_send_irq: Network not running!");
 337                 return;
 338         }
 339
 340         /* unlink, shutdown, unplug, other nasties */
 341         if (urb->status != 0) {
 342                 err("ks959_send_irq: urb asynchronously failed - %d",
 343                     urb->status);
 344                 return;
 345         }
 346
 347         if (kingsun->tx_buf_clear_used > 0) {
 348                 /* Update data remaining to be sent */
 349                 if (kingsun->tx_buf_clear_sent < kingsun->tx_buf_clear_used) {
 350                         memmove(kingsun->tx_buf_clear,
 351                                 kingsun->tx_buf_clear +
 352                                 kingsun->tx_buf_clear_sent,
 353                                 kingsun->tx_buf_clear_used -
 354                                 kingsun->tx_buf_clear_sent);
 355                 }
 356                 kingsun->tx_buf_clear_used -= kingsun->tx_buf_clear_sent;
 357                 kingsun->tx_buf_clear_sent = 0;
 358
 359                 if (kingsun->tx_buf_clear_used > 0) {
 360                         /* There is more data to be sent */
 361                         if ((ret = ks959_submit_tx_fragment(kingsun)) != 0) {
 362                                 err("ks959_send_irq: failed tx_urb submit: %d",
 363                                     ret);
 364                                 switch (ret) {
 365                                 case -ENODEV:
 366                                 case -EPIPE:
 367                                         break;
 368                                 default:
 369                                         kingsun->stats.tx_errors++;
 370                                         netif_start_queue(netdev);
 371                                 }
 372                         }
 373                 } else {
 374                         /* All data sent, send next speed && wake network queue */
 375                         if (kingsun->new_speed != -1 &&
 376                             cpu_to_le32(kingsun->new_speed) !=
 377                             kingsun->speedparams.baudrate)
 378                                 ks959_change_speed(kingsun, kingsun->new_speed);
 379
 380                         netif_wake_queue(netdev);
 381                 }
 382         }
 383 }
 384
 385 /*
 386  * Called from net/core when new frame is available.
 387  */
 388 static int ks959_hard_xmit(struct sk_buff *skb, struct net_device *netdev)
 389 {
 390         struct ks959_cb *kingsun;
 391         unsigned int wraplen;
 392         int ret = 0;
 393
 394         if (skb == NULL || netdev == NULL)
 395                 return -EINVAL;
 396
 397         netif_stop_queue(netdev);
 398
 399         /* the IRDA wrapping routines don't deal with non linear skb */
 400         SKB_LINEAR_ASSERT(skb);
 401
 402         kingsun = netdev_priv(netdev);
 403
 404         spin_lock(&kingsun->lock);
 405         kingsun->new_speed = irda_get_next_speed(skb);
 406
 407         /* Append data to the end of whatever data remains to be transmitted */
 408         wraplen =
 409             async_wrap_skb(skb, kingsun->tx_buf_clear, KINGSUN_SND_FIFO_SIZE);
 410         kingsun->tx_buf_clear_used = wraplen;
 411
 412         if ((ret = ks959_submit_tx_fragment(kingsun)) != 0) {
 413                 err("ks959_hard_xmit: failed tx_urb submit: %d", ret);
 414                 switch (ret) {
 415                 case -ENODEV:
 416                 case -EPIPE:
 417                         break;
 418                 default:
 419                         kingsun->stats.tx_errors++;
 420                         netif_start_queue(netdev);
 421                 }
 422         } else {
 423                 kingsun->stats.tx_packets++;
 424                 kingsun->stats.tx_bytes += skb->len;
 425
 426         }
 427
 428         dev_kfree_skb(skb);
 429         spin_unlock(&kingsun->lock);
 430
 431         return ret;
 432 }
 433
 434 /* Receive callback function */
 435 static void ks959_rcv_irq(struct urb *urb)
 436 {
 437         struct ks959_cb *kingsun = urb->context;
 438         int ret;
 439
 440         /* in process of stopping, just drop data */
 441         if (!netif_running(kingsun->netdev)) {
 442                 kingsun->receiving = 0;
 443                 return;
 444         }
 445
 446         /* unlink, shutdown, unplug, other nasties */
 447         if (urb->status != 0) {
 448                 err("kingsun_rcv_irq: urb asynchronously failed - %d",
 449                     urb->status);
 450                 kingsun->receiving = 0;
 451                 return;
 452         }
 453
 454         if (urb->actual_length > 0) {
 455                 __u8 *bytes = urb->transfer_buffer;
 456                 unsigned int i;
 457
 458                 for (i = 0; i < urb->actual_length; i++) {
 459                         /* De-obfuscation implemented here: variable portion of
 460                            xormask is incremented, and then used with the encoded
 461                            byte for the XOR. The result of the operation is used
 462                            to unwrap the SIR frame. */
 463                         kingsun->rx_variable_xormask++;
 464                         bytes[i] =
 465                             bytes[i] ^ kingsun->rx_variable_xormask ^ 0x55u;
 466
 467                         /* rx_variable_xormask doubles as an index counter so we
 468                            can skip the byte at 0xff (wrapped around to 0).
 469                          */
 470                         if (kingsun->rx_variable_xormask != 0) {
 471                                 async_unwrap_char(kingsun->netdev,
 472                                                   &kingsun->stats,
 473                                                   &kingsun->rx_unwrap_buff,
 474                                                   bytes[i]);
 475                         }
 476                 }
 477                 kingsun->netdev->last_rx = jiffies;
 478                 do_gettimeofday(&kingsun->rx_time);
 479                 kingsun->receiving =
 480                     (kingsun->rx_unwrap_buff.state != OUTSIDE_FRAME) ? 1 : 0;
 481         }
 482
 483         /* This urb has already been filled in kingsun_net_open. Setup
 484            packet must be re-filled, but it is assumed that urb keeps the
 485            pointer to the initial setup packet, as well as the payload buffer.
 486            Setup packet is already pre-filled at ks959_probe.
 487          */
 488         urb->status = 0;
 489         ret = usb_submit_urb(urb, GFP_ATOMIC);
 490 }
 491
 492 /*
 493  * Function kingsun_net_open (dev)
 494  *
 495  *    Network device is taken up. Usually this is done by "ifconfig irda0 up"
 496  */
 497 static int ks959_net_open(struct net_device *netdev)
 498 {
 499         struct ks959_cb *kingsun = netdev_priv(netdev);
 500         int err = -ENOMEM;
 501         char hwname[16];
 502
 503         /* At this point, urbs are NULL, and skb is NULL (see kingsun_probe) */
 504         kingsun->receiving = 0;
 505
 506         /* Initialize for SIR to copy data directly into skb.  */
 507         kingsun->rx_unwrap_buff.in_frame = FALSE;
 508         kingsun->rx_unwrap_buff.state = OUTSIDE_FRAME;
 509         kingsun->rx_unwrap_buff.truesize = IRDA_SKB_MAX_MTU;
 510         kingsun->rx_unwrap_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
 511         if (!kingsun->rx_unwrap_buff.skb)
 512                 goto free_mem;
 513
 514         skb_reserve(kingsun->rx_unwrap_buff.skb, 1);
 515         kingsun->rx_unwrap_buff.head = kingsun->rx_unwrap_buff.skb->data;
 516         do_gettimeofday(&kingsun->rx_time);
 517
 518         kingsun->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
 519         if (!kingsun->rx_urb)
 520                 goto free_mem;
 521
 522         kingsun->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
 523         if (!kingsun->tx_urb)
 524                 goto free_mem;
 525
 526         kingsun->speed_urb = usb_alloc_urb(0, GFP_KERNEL);
 527         if (!kingsun->speed_urb)
 528                 goto free_mem;
 529
 530         /* Initialize speed for dongle */
 531         kingsun->new_speed = 9600;
 532         err = ks959_change_speed(kingsun, 9600);
 533         if (err < 0)
 534                 goto free_mem;
 535
 536         /*
 537          * Now that everything should be initialized properly,
 538          * Open new IrLAP layer instance to take care of us...
 539          */
 540         sprintf(hwname, "usb#%d", kingsun->usbdev->devnum);
 541         kingsun->irlap = irlap_open(netdev, &kingsun->qos, hwname);
 542         if (!kingsun->irlap) {
 543                 err("ks959-sir: irlap_open failed");
 544                 goto free_mem;
 545         }
 546
 547         /* Start reception. Setup request already pre-filled in ks959_probe */
 548         usb_fill_control_urb(kingsun->rx_urb, kingsun->usbdev,
 549                              usb_rcvctrlpipe(kingsun->usbdev, 0),
 550                              (unsigned char *)kingsun->rx_setuprequest,
 551                              kingsun->rx_buf, KINGSUN_RCV_FIFO_SIZE,
 552                              ks959_rcv_irq, kingsun);
 553         kingsun->rx_urb->status = 0;
 554         err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
 555         if (err) {
 556                 err("ks959-sir: first urb-submit failed: %d", err);
 557                 goto close_irlap;
 558         }
 559
 560         netif_start_queue(netdev);
 561
 562         /* Situation at this point:
 563            - all work buffers allocated
 564            - urbs allocated and ready to fill
 565            - max rx packet known (in max_rx)
 566            - unwrap state machine initialized, in state outside of any frame
 567            - receive request in progress
 568            - IrLAP layer started, about to hand over packets to send
 569          */
 570
 571         return 0;
 572
 573       close_irlap:
 574         irlap_close(kingsun->irlap);
 575       free_mem:
 576         usb_free_urb(kingsun->speed_urb);
 577         kingsun->speed_urb = NULL;
 578         usb_free_urb(kingsun->tx_urb);
 579         kingsun->tx_urb = NULL;
 580         usb_free_urb(kingsun->rx_urb);
 581         kingsun->rx_urb = NULL;
 582         if (kingsun->rx_unwrap_buff.skb) {
 583                 kfree_skb(kingsun->rx_unwrap_buff.skb);
 584                 kingsun->rx_unwrap_buff.skb = NULL;
 585                 kingsun->rx_unwrap_buff.head = NULL;
 586         }
 587         return err;
 588 }
 589
 590 /*
 591  * Function kingsun_net_close (kingsun)
 592  *
 593  *    Network device is taken down. Usually this is done by
 594  *    "ifconfig irda0 down"
 595  */
 596 static int ks959_net_close(struct net_device *netdev)
 597 {
 598         struct ks959_cb *kingsun = netdev_priv(netdev);
 599
 600         /* Stop transmit processing */
 601         netif_stop_queue(netdev);
 602
 603         /* Mop up receive && transmit urb's */
 604         usb_kill_urb(kingsun->tx_urb);
 605         usb_free_urb(kingsun->tx_urb);
 606         kingsun->tx_urb = NULL;
 607
 608         usb_kill_urb(kingsun->speed_urb);
 609         usb_free_urb(kingsun->speed_urb);
 610         kingsun->speed_urb = NULL;
 611
 612         usb_kill_urb(kingsun->rx_urb);
 613         usb_free_urb(kingsun->rx_urb);
 614         kingsun->rx_urb = NULL;
 615
 616         kfree_skb(kingsun->rx_unwrap_buff.skb);
 617         kingsun->rx_unwrap_buff.skb = NULL;
 618         kingsun->rx_unwrap_buff.head = NULL;
 619         kingsun->rx_unwrap_buff.in_frame = FALSE;
 620         kingsun->rx_unwrap_buff.state = OUTSIDE_FRAME;
 621         kingsun->receiving = 0;
 622
 623         /* Stop and remove instance of IrLAP */
 624         if (kingsun->irlap)
 625                 irlap_close(kingsun->irlap);
 626
 627         kingsun->irlap = NULL;
 628
 629         return 0;
 630 }
 631
 632 /*
 633  * IOCTLs : Extra out-of-band network commands...
 634  */
 635 static int ks959_net_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 636 {
 637         struct if_irda_req *irq = (struct if_irda_req *)rq;
 638         struct ks959_cb *kingsun = netdev_priv(netdev);
 639         int ret = 0;
 640
 641         switch (cmd) {
 642         case SIOCSBANDWIDTH:    /* Set bandwidth */
 643                 if (!capable(CAP_NET_ADMIN))
 644                         return -EPERM;
 645
 646                 /* Check if the device is still there */
 647                 if (netif_device_present(kingsun->netdev))
 648                         return ks959_change_speed(kingsun, irq->ifr_baudrate);
 649                 break;
 650
 651         case SIOCSMEDIABUSY:    /* Set media busy */
 652                 if (!capable(CAP_NET_ADMIN))
 653                         return -EPERM;
 654
 655                 /* Check if the IrDA stack is still there */
 656                 if (netif_running(kingsun->netdev))
 657                         irda_device_set_media_busy(kingsun->netdev, TRUE);
 658                 break;
 659
 660         case SIOCGRECEIVING:
 661                 /* Only approximately true */
 662                 irq->ifr_receiving = kingsun->receiving;
 663                 break;
 664
 665         default:
 666                 ret = -EOPNOTSUPP;
 667         }
 668
 669         return ret;
 670 }
 671
 672 /*
 673  * Get device stats (for /proc/net/dev and ifconfig)
 674  */
 675 static struct net_device_stats *ks959_net_get_stats(struct net_device *netdev)
 676 {
 677         struct ks959_cb *kingsun = netdev_priv(netdev);
 678         return &kingsun->stats;
 679 }
 680
 681 /*
 682  * This routine is called by the USB subsystem for each new device
 683  * in the system. We need to check if the device is ours, and in
 684  * this case start handling it.
 685  */
 686 static int ks959_probe(struct usb_interface *intf,
 687                        const struct usb_device_id *id)
 688 {
 689         struct usb_device *dev = interface_to_usbdev(intf);
 690         struct ks959_cb *kingsun = NULL;
 691         struct net_device *net = NULL;
 692         int ret = -ENOMEM;
 693
 694         /* Allocate network device container. */
 695         net = alloc_irdadev(sizeof(*kingsun));
 696         if (!net)
 697                 goto err_out1;
 698
 699         SET_NETDEV_DEV(net, &intf->dev);
 700         kingsun = netdev_priv(net);
 701         kingsun->netdev = net;
 702         kingsun->usbdev = dev;
 703         kingsun->irlap = NULL;
 704         kingsun->tx_setuprequest = NULL;
 705         kingsun->tx_urb = NULL;
 706         kingsun->tx_buf_clear = NULL;
 707         kingsun->tx_buf_xored = NULL;
 708         kingsun->tx_buf_clear_used = 0;
 709         kingsun->tx_buf_clear_sent = 0;
 710
 711         kingsun->rx_setuprequest = NULL;
 712         kingsun->rx_urb = NULL;
 713         kingsun->rx_buf = NULL;
 714         kingsun->rx_variable_xormask = 0;
 715         kingsun->rx_unwrap_buff.in_frame = FALSE;
 716         kingsun->rx_unwrap_buff.state = OUTSIDE_FRAME;
 717         kingsun->rx_unwrap_buff.skb = NULL;
 718         kingsun->receiving = 0;
 719         spin_lock_init(&kingsun->lock);
 720
 721         kingsun->speed_setuprequest = NULL;
 722         kingsun->speed_urb = NULL;
 723         kingsun->speedparams.baudrate = 0;
 724
 725         /* Allocate input buffer */
 726         kingsun->rx_buf = kmalloc(KINGSUN_RCV_FIFO_SIZE, GFP_KERNEL);
 727         if (!kingsun->rx_buf)
 728                 goto free_mem;
 729
 730         /* Allocate input setup packet */
 731         kingsun->rx_setuprequest =
 732             kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 733         if (!kingsun->rx_setuprequest)
 734                 goto free_mem;
 735         kingsun->rx_setuprequest->bRequestType =
 736             USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
 737         kingsun->rx_setuprequest->bRequest = KINGSUN_REQ_RECV;
 738         kingsun->rx_setuprequest->wValue = cpu_to_le16(0x0200);
 739         kingsun->rx_setuprequest->wIndex = 0;
 740         kingsun->rx_setuprequest->wLength = cpu_to_le16(KINGSUN_RCV_FIFO_SIZE);
 741
 742         /* Allocate output buffer */
 743         kingsun->tx_buf_clear = kmalloc(KINGSUN_SND_FIFO_SIZE, GFP_KERNEL);
 744         if (!kingsun->tx_buf_clear)
 745                 goto free_mem;
 746         kingsun->tx_buf_xored = kmalloc(KINGSUN_SND_PACKET_SIZE, GFP_KERNEL);
 747         if (!kingsun->tx_buf_xored)
 748                 goto free_mem;
 749
 750         /* Allocate and initialize output setup packet */
 751         kingsun->tx_setuprequest =
 752             kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 753         if (!kingsun->tx_setuprequest)
 754                 goto free_mem;
 755         kingsun->tx_setuprequest->bRequestType =
 756             USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
 757         kingsun->tx_setuprequest->bRequest = KINGSUN_REQ_SEND;
 758         kingsun->tx_setuprequest->wValue = 0;
 759         kingsun->tx_setuprequest->wIndex = 0;
 760         kingsun->tx_setuprequest->wLength = 0;
 761
 762         /* Allocate and initialize speed setup packet */
 763         kingsun->speed_setuprequest =
 764             kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
 765         if (!kingsun->speed_setuprequest)
 766                 goto free_mem;
 767         kingsun->speed_setuprequest->bRequestType =
 768             USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
 769         kingsun->speed_setuprequest->bRequest = KINGSUN_REQ_SEND;
 770         kingsun->speed_setuprequest->wValue = cpu_to_le16(0x0200);
 771         kingsun->speed_setuprequest->wIndex = cpu_to_le16(0x0001);
 772         kingsun->speed_setuprequest->wLength =
 773             cpu_to_le16(sizeof(struct ks959_speedparams));
 774
 775         printk(KERN_INFO "KingSun KS-959 IRDA/USB found at address %d, "
 776                "Vendor: %x, Product: %x\n",
 777                dev->devnum, le16_to_cpu(dev->descriptor.idVendor),
 778                le16_to_cpu(dev->descriptor.idProduct));
 779
 780         /* Initialize QoS for this device */
 781         irda_init_max_qos_capabilies(&kingsun->qos);
 782
 783         /* Baud rates known to be supported. Please uncomment if devices (other
 784            than a SonyEriccson K300 phone) can be shown to support higher speed
 785            with this dongle.
 786          */
 787         kingsun->qos.baud_rate.bits =
 788             IR_2400 | IR_9600 | IR_19200 | IR_38400 | IR_57600;
 789         kingsun->qos.min_turn_time.bits &= KINGSUN_MTT;
 790         irda_qos_bits_to_value(&kingsun->qos);
 791
 792         /* Override the network functions we need to use */
 793         net->hard_start_xmit = ks959_hard_xmit;
 794         net->open = ks959_net_open;
 795         net->stop = ks959_net_close;
 796         net->get_stats = ks959_net_get_stats;
 797         net->do_ioctl = ks959_net_ioctl;
 798
 799         ret = register_netdev(net);
 800         if (ret != 0)
 801                 goto free_mem;
 802
 803         dev_info(&net->dev, "IrDA: Registered KingSun KS-959 device %s\n",
 804                  net->name);
 805
 806         usb_set_intfdata(intf, kingsun);
 807
 808         /* Situation at this point:
 809            - all work buffers allocated
 810            - setup requests pre-filled
 811            - urbs not allocated, set to NULL
 812            - max rx packet known (is KINGSUN_FIFO_SIZE)
 813            - unwrap state machine (partially) initialized, but skb == NULL
 814          */
 815
 816         return 0;
 817
 818       free_mem:
 819         kfree(kingsun->speed_setuprequest);
 820         kfree(kingsun->tx_setuprequest);
 821         kfree(kingsun->tx_buf_xored);
 822         kfree(kingsun->tx_buf_clear);
 823         kfree(kingsun->rx_setuprequest);
 824         kfree(kingsun->rx_buf);
 825         free_netdev(net);
 826       err_out1:
 827         return ret;
 828 }
 829
 830 /*
 831  * The current device is removed, the USB layer tell us to shut it down...
 832  */
 833 static void ks959_disconnect(struct usb_interface *intf)
 834 {
 835         struct ks959_cb *kingsun = usb_get_intfdata(intf);
 836
 837         if (!kingsun)
 838                 return;
 839
 840         unregister_netdev(kingsun->netdev);
 841
 842         /* Mop up receive && transmit urb's */
 843         if (kingsun->speed_urb != NULL) {
 844                 usb_kill_urb(kingsun->speed_urb);
 845                 usb_free_urb(kingsun->speed_urb);
 846                 kingsun->speed_urb = NULL;
 847         }
 848         if (kingsun->tx_urb != NULL) {
 849                 usb_kill_urb(kingsun->tx_urb);
 850                 usb_free_urb(kingsun->tx_urb);
 851                 kingsun->tx_urb = NULL;
 852         }
 853         if (kingsun->rx_urb != NULL) {
 854                 usb_kill_urb(kingsun->rx_urb);
 855                 usb_free_urb(kingsun->rx_urb);
 856                 kingsun->rx_urb = NULL;
 857         }
 858
 859         kfree(kingsun->speed_setuprequest);
 860         kfree(kingsun->tx_setuprequest);
 861         kfree(kingsun->tx_buf_xored);
 862         kfree(kingsun->tx_buf_clear);
 863         kfree(kingsun->rx_setuprequest);
 864         kfree(kingsun->rx_buf);
 865         free_netdev(kingsun->netdev);
 866
 867         usb_set_intfdata(intf, NULL);
 868 }
 869
 870 #ifdef CONFIG_PM
 871 /* USB suspend, so power off the transmitter/receiver */
 872 static int ks959_suspend(struct usb_interface *intf, pm_message_t message)
 873 {
 874         struct ks959_cb *kingsun = usb_get_intfdata(intf);
 875
 876         netif_device_detach(kingsun->netdev);
 877         if (kingsun->speed_urb != NULL)
 878                 usb_kill_urb(kingsun->speed_urb);
 879         if (kingsun->tx_urb != NULL)
 880                 usb_kill_urb(kingsun->tx_urb);
 881         if (kingsun->rx_urb != NULL)
 882                 usb_kill_urb(kingsun->rx_urb);
 883         return 0;
 884 }
 885
 886 /* Coming out of suspend, so reset hardware */
 887 static int ks959_resume(struct usb_interface *intf)
 888 {
 889         struct ks959_cb *kingsun = usb_get_intfdata(intf);
 890
 891         if (kingsun->rx_urb != NULL) {
 892                 /* Setup request already filled in ks959_probe */
 893                 usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
 894         }
 895         netif_device_attach(kingsun->netdev);
 896
 897         return 0;
 898 }
 899 #endif
 900
 901 /*
 902  * USB device callbacks
 903  */
 904 static struct usb_driver irda_driver = {
 905         .name = "ks959-sir",
 906         .probe = ks959_probe,
 907         .disconnect = ks959_disconnect,
 908         .id_table = dongles,
 909 #ifdef CONFIG_PM
 910         .suspend = ks959_suspend,
 911         .resume = ks959_resume,
 912 #endif
 913 };
 914
 915 /*
 916  * Module insertion
 917  */
 918 static int __init ks959_init(void)
 919 {
 920         return usb_register(&irda_driver);
 921 }
 922
 923 module_init(ks959_init);
 924
 925 /*
 926  * Module removal
 927  */
 928 static void __exit ks959_cleanup(void)
 929 {
 930         /* Deregister the driver and remove all pending instances */
 931         usb_deregister(&irda_driver);
 932 }
 933
 934 module_exit(ks959_cleanup);
 935
 936 MODULE_AUTHOR("Alex Villacís Lasso <a_villacis@palosanto.com>");
 937 MODULE_DESCRIPTION("IrDA-USB Dongle Driver for KingSun KS-959");
 938 MODULE_LICENSE("GPL");