Pileus Git - ~andy/linux/blob - drivers/net/irda/mcs7780.c

   1 /*****************************************************************************
   2 *
   3 * Filename:      mcs7780.c
   4 * Version:       0.4-alpha
   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>
   9 *
  10 *       Based on stir4200 driver, but some things done differently.
  11 *       Based on earlier driver by Paul Stewart <stewart@parc.com>
  12 *
  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>
  20 *
  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.
  25 *
  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.
  30 *
  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.
  34 *
  35 *****************************************************************************/
  36
  37 /*
  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
  44  */
  45
  46 #include <linux/module.h>
  47 #include <linux/moduleparam.h>
  48 #include <linux/kernel.h>
  49 #include <linux/types.h>
  50 #include <linux/errno.h>
  51 #include <linux/slab.h>
  52 #include <linux/usb.h>
  53 #include <linux/device.h>
  54 #include <linux/crc32.h>
  55
  56 #include <asm/unaligned.h>
  57 #include <asm/byteorder.h>
  58 #include <asm/uaccess.h>
  59
  60 #include <net/irda/irda.h>
  61 #include <net/irda/wrapper.h>
  62 #include <net/irda/crc.h>
  63
  64 #include "mcs7780.h"
  65
  66 #define MCS_VENDOR_ID 0x9710
  67 #define MCS_PRODUCT_ID 0x7780
  68
  69 static struct usb_device_id mcs_table[] = {
  70         /* MosChip Corp.,  MCS7780 FIR-USB Adapter */
  71         {USB_DEVICE(MCS_VENDOR_ID, MCS_PRODUCT_ID)},
  72         {},
  73 };
  74
  75 MODULE_AUTHOR("Brian Pugh <bpugh@cs.pdx.edu>");
  76 MODULE_DESCRIPTION("IrDA-USB Dongle Driver for MosChip MCS7780");
  77 MODULE_VERSION("0.3alpha");
  78 MODULE_LICENSE("GPL");
  79
  80 MODULE_DEVICE_TABLE(usb, mcs_table);
  81
  82 static int qos_mtt_bits = 0x07 /* > 1ms */ ;
  83 module_param(qos_mtt_bits, int, 0);
  84 MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time");
  85
  86 static int receive_mode = 0x1;
  87 module_param(receive_mode, int, 0);
  88 MODULE_PARM_DESC(receive_mode,
  89                  "Receive mode of the device (1:fast, 0:slow, default:1)");
  90
  91 static int sir_tweak = 1;
  92 module_param(sir_tweak, int, 0444);
  93 MODULE_PARM_DESC(sir_tweak,
  94                  "Default pulse width (1:1.6us, 0:3/16 bit, default:1).");
  95
  96 static int transceiver_type = MCS_TSC_VISHAY;
  97 module_param(transceiver_type, int, 0444);
  98 MODULE_PARM_DESC(transceiver_type, "IR transceiver type, see mcs7780.h.");
  99
 100 static struct usb_driver mcs_driver = {
 101         .name = "mcs7780",
 102         .probe = mcs_probe,
 103         .disconnect = mcs_disconnect,
 104         .id_table = mcs_table,
 105 };
 106
 107 /* speed flag selection by direct addressing.
 108 addr = (speed >> 8) & 0x0f
 109
 110 0x1   57600      0x2  115200     0x4 1152000     0x5    9600
 111 0x6   38400      0x9    2400     0xa  576000     0xb   19200
 112
 113 4Mbps (or 2400) must be checked separately. Since it also has
 114 to be programmed in a different manner that is not a big problem.
 115 */
 116 static __u16 mcs_speed_set[16] = { 0,
 117         MCS_SPEED_57600,
 118         MCS_SPEED_115200,
 119         0,
 120         MCS_SPEED_1152000,
 121         MCS_SPEED_9600,
 122         MCS_SPEED_38400,
 123         0, 0,
 124         MCS_SPEED_2400,
 125         MCS_SPEED_576000,
 126         MCS_SPEED_19200,
 127         0, 0, 0,
 128 };
 129
 130 /* Set given 16 bit register with a 16 bit value. Send control message
 131  * to set dongle register. */
 132 static int mcs_set_reg(struct mcs_cb *mcs, __u16 reg, __u16 val)
 133 {
 134         struct usb_device *dev = mcs->usbdev;
 135         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
 136                                MCS_WR_RTYPE, val, reg, NULL, 0,
 137                                msecs_to_jiffies(MCS_CTRL_TIMEOUT));
 138 }
 139
 140 /* Get 16 bit register value. Send contol message to read dongle register. */
 141 static int mcs_get_reg(struct mcs_cb *mcs, __u16 reg, __u16 * val)
 142 {
 143         struct usb_device *dev = mcs->usbdev;
 144         int ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
 145                                   MCS_RD_RTYPE, 0, reg, val, 2,
 146                                   msecs_to_jiffies(MCS_CTRL_TIMEOUT));
 147
 148         return ret;
 149 }
 150
 151 /* Setup a communication between mcs7780 and TFDU chips.  It is described
 152  * in more detail in the data sheet.  The setup sequence puts the the
 153  * vishay tranceiver into high speed mode.  It will also receive SIR speed
 154  * packets but at reduced sensitivity.
 155  */
 156
 157 /* 0: OK 1:ERROR */
 158 static inline int mcs_setup_transceiver_vishay(struct mcs_cb *mcs)
 159 {
 160         int ret = 0;
 161         __u16 rval;
 162
 163         /* mcs_get_reg should read exactly two bytes from the dongle */
 164         ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval);
 165         if (unlikely(ret != 2)) {
 166                 ret = -EIO;
 167                 goto error;
 168         }
 169
 170         /* The MCS_XCVR_CONF bit puts the transceiver into configuration
 171          * mode.  The MCS_MODE0 bit must start out high (1) and then
 172          * transition to low and the MCS_STFIR and MCS_MODE1 bits must
 173          * be low.
 174          */
 175         rval |= (MCS_MODE0 | MCS_XCVR_CONF);
 176         rval &= ~MCS_STFIR;
 177         rval &= ~MCS_MODE1;
 178         ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
 179         if (unlikely(ret))
 180                 goto error;
 181
 182         rval &= ~MCS_MODE0;
 183         ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
 184         if (unlikely(ret))
 185                 goto error;
 186
 187         rval &= ~MCS_XCVR_CONF;
 188         ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
 189         if (unlikely(ret))
 190                 goto error;
 191
 192         ret = 0;
 193 error:
 194         return ret;
 195 }
 196
 197 /* Setup a communication between mcs7780 and agilent chip. */
 198 static inline int mcs_setup_transceiver_agilent(struct mcs_cb *mcs)
 199 {
 200         IRDA_WARNING("This transceiver type is not supported yet.\n");
 201         return 1;
 202 }
 203
 204 /* Setup a communication between mcs7780 and sharp chip. */
 205 static inline int mcs_setup_transceiver_sharp(struct mcs_cb *mcs)
 206 {
 207         IRDA_WARNING("This transceiver type is not supported yet.\n");
 208         return 1;
 209 }
 210
 211 /* Common setup for all transceivers */
 212 static inline int mcs_setup_transceiver(struct mcs_cb *mcs)
 213 {
 214         int ret = 0;
 215         __u16 rval;
 216         char *msg;
 217
 218         msg = "Basic transceiver setup error.";
 219
 220         /* read value of MODE Register, set the DRIVER and RESET bits
 221         * and write value back out to MODE Register
 222         */
 223         ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
 224         if(unlikely(ret != 2))
 225                 goto error;
 226         rval |= MCS_DRIVER;     /* put the mcs7780 into configuration mode. */
 227         ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
 228         if(unlikely(ret))
 229                 goto error;
 230
 231         rval = 0;               /* set min pulse width to 0 initially. */
 232         ret = mcs_set_reg(mcs, MCS_MINRXPW_REG, rval);
 233         if(unlikely(ret))
 234                 goto error;
 235
 236         ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
 237         if(unlikely(ret != 2))
 238                 goto error;
 239
 240         rval &= ~MCS_FIR;       /* turn off fir mode. */
 241         if(mcs->sir_tweak)
 242                 rval |= MCS_SIR16US;    /* 1.6us pulse width */
 243         else
 244                 rval &= ~MCS_SIR16US;   /* 3/16 bit time pulse width */
 245
 246         /* make sure ask mode and back to back packets are off. */
 247         rval &= ~(MCS_BBTG | MCS_ASK);
 248
 249         rval &= ~MCS_SPEED_MASK;
 250         rval |= MCS_SPEED_9600;         /* make sure initial speed is 9600. */
 251         mcs->speed = 9600;
 252         mcs->new_speed = 0;             /* new_speed is set to 0 */
 253         rval &= ~MCS_PLLPWDN;           /* disable power down. */
 254
 255         /* make sure device determines direction and that the auto send sip
 256          * pulse are on.
 257          */
 258         rval |= MCS_DTD | MCS_SIPEN;
 259
 260         ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
 261         if(unlikely(ret))
 262                 goto error;
 263
 264         msg = "transceiver model specific setup error.";
 265         switch (mcs->transceiver_type) {
 266         case MCS_TSC_VISHAY:
 267                 ret = mcs_setup_transceiver_vishay(mcs);
 268                 break;
 269
 270         case MCS_TSC_SHARP:
 271                 ret = mcs_setup_transceiver_sharp(mcs);
 272                 break;
 273
 274         case MCS_TSC_AGILENT:
 275                 ret = mcs_setup_transceiver_agilent(mcs);
 276                 break;
 277
 278         default:
 279                 IRDA_WARNING("Unknown transceiver type: %d\n",
 280                              mcs->transceiver_type);
 281                 ret = 1;
 282         }
 283         if (unlikely(ret))
 284                 goto error;
 285
 286         /* If transceiver is not SHARP, then if receive mode set
 287         * on the RXFAST bit in the XCVR Register otherwise unset it
 288         */
 289         if (mcs->transceiver_type != MCS_TSC_SHARP) {
 290
 291                 ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval);
 292                 if (unlikely(ret != 2))
 293                         goto error;
 294                 if (mcs->receive_mode)
 295                         rval |= MCS_RXFAST;
 296                 else
 297                         rval &= ~MCS_RXFAST;
 298                 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
 299                 if (unlikely(ret))
 300                         goto error;
 301         }
 302
 303         msg = "transceiver reset.";
 304
 305         ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
 306         if (unlikely(ret != 2))
 307                 goto error;
 308
 309         /* reset the mcs7780 so all changes take effect. */
 310         rval &= ~MCS_RESET;
 311         ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
 312         if (unlikely(ret))
 313                 goto error;
 314         else
 315                 return ret;
 316
 317 error:
 318         IRDA_ERROR("%s\n", msg);
 319         return ret;
 320 }
 321
 322 /* Wraps the data in format for SIR */
 323 static inline int mcs_wrap_sir_skb(struct sk_buff *skb, __u8 * buf)
 324 {
 325         int wraplen;
 326
 327         /* 2: full frame length, including "the length" */
 328         wraplen = async_wrap_skb(skb, buf + 2, 4094);
 329
 330         wraplen += 2;
 331         buf[0] = wraplen & 0xff;
 332         buf[1] = (wraplen >> 8) & 0xff;
 333
 334         return wraplen;
 335 }
 336
 337 /* Wraps the data in format for FIR */
 338 static unsigned mcs_wrap_fir_skb(const struct sk_buff *skb, __u8 *buf)
 339 {
 340         unsigned int len = 0;
 341         __u32 fcs = ~(crc32_le(~0, skb->data, skb->len));
 342
 343         /* add 2 bytes for length value and 4 bytes for fcs. */
 344         len = skb->len + 6;
 345
 346         /* The mcs7780 requires that the first two bytes are the packet
 347          * length in little endian order.  Note: the length value includes
 348          * the two bytes for the length value itself.
 349          */
 350         buf[0] = len & 0xff;
 351         buf[1] = (len >> 8) & 0xff;
 352         /* copy the data into the tx buffer. */
 353         skb_copy_from_linear_data(skb, buf + 2, skb->len);
 354         /* put the fcs in the last four bytes in little endian order. */
 355         buf[len - 4] = fcs & 0xff;
 356         buf[len - 3] = (fcs >> 8) & 0xff;
 357         buf[len - 2] = (fcs >> 16) & 0xff;
 358         buf[len - 1] = (fcs >> 24) & 0xff;
 359
 360         return len;
 361 }
 362
 363 /* Wraps the data in format for MIR */
 364 static unsigned mcs_wrap_mir_skb(const struct sk_buff *skb, __u8 *buf)
 365 {
 366         __u16 fcs = 0;
 367         int len = skb->len + 4;
 368
 369         fcs = ~(irda_calc_crc16(~fcs, skb->data, skb->len));
 370         /* put the total packet length in first.  Note: packet length
 371          * value includes the two bytes that hold the packet length
 372          * itself.
 373          */
 374         buf[0] = len & 0xff;
 375         buf[1] = (len >> 8) & 0xff;
 376         /* copy the data */
 377         skb_copy_from_linear_data(skb, buf + 2, skb->len);
 378         /* put the fcs in last two bytes in little endian order. */
 379         buf[len - 2] = fcs & 0xff;
 380         buf[len - 1] = (fcs >> 8) & 0xff;
 381
 382         return len;
 383 }
 384
 385 /* Unwrap received packets at MIR speed.  A 16 bit crc_ccitt checksum is
 386  * used for the fcs.  When performed over the entire packet the result
 387  * should be GOOD_FCS = 0xf0b8.  Hands the unwrapped data off to the IrDA
 388  * layer via a sk_buff.
 389  */
 390 static void mcs_unwrap_mir(struct mcs_cb *mcs, __u8 *buf, int len)
 391 {
 392         __u16 fcs;
 393         int new_len;
 394         struct sk_buff *skb;
 395
 396         /* Assume that the frames are going to fill a single packet
 397          * rather than span multiple packets.
 398          */
 399
 400         new_len = len - 2;
 401         if(unlikely(new_len <= 0)) {
 402                 IRDA_ERROR("%s short frame length %d\n",
 403                              mcs->netdev->name, new_len);
 404                 ++mcs->netdev->stats.rx_errors;
 405                 ++mcs->netdev->stats.rx_length_errors;
 406                 return;
 407         }
 408         fcs = 0;
 409         fcs = irda_calc_crc16(~fcs, buf, len);
 410
 411         if(fcs != GOOD_FCS) {
 412                 IRDA_ERROR("crc error calc 0x%x len %d\n",
 413                            fcs, new_len);
 414                 mcs->netdev->stats.rx_errors++;
 415                 mcs->netdev->stats.rx_crc_errors++;
 416                 return;
 417         }
 418
 419         skb = dev_alloc_skb(new_len + 1);
 420         if(unlikely(!skb)) {
 421                 ++mcs->netdev->stats.rx_dropped;
 422                 return;
 423         }
 424
 425         skb_reserve(skb, 1);
 426         skb_copy_to_linear_data(skb, buf, new_len);
 427         skb_put(skb, new_len);
 428         skb_reset_mac_header(skb);
 429         skb->protocol = htons(ETH_P_IRDA);
 430         skb->dev = mcs->netdev;
 431
 432         netif_rx(skb);
 433
 434         mcs->netdev->stats.rx_packets++;
 435         mcs->netdev->stats.rx_bytes += new_len;
 436 }
 437
 438 /* Unwrap received packets at FIR speed.  A 32 bit crc_ccitt checksum is
 439  * used for the fcs.  Hands the unwrapped data off to the IrDA
 440  * layer via a sk_buff.
 441  */
 442 static void mcs_unwrap_fir(struct mcs_cb *mcs, __u8 *buf, int len)
 443 {
 444         __u32 fcs;
 445         int new_len;
 446         struct sk_buff *skb;
 447
 448         /* Assume that the frames are going to fill a single packet
 449          * rather than span multiple packets.  This is most likely a false
 450          * assumption.
 451          */
 452
 453         new_len = len - 4;
 454         if(unlikely(new_len <= 0)) {
 455                 IRDA_ERROR("%s short frame length %d\n",
 456                            mcs->netdev->name, new_len);
 457                 ++mcs->netdev->stats.rx_errors;
 458                 ++mcs->netdev->stats.rx_length_errors;
 459                 return;
 460         }
 461
 462         fcs = ~(crc32_le(~0, buf, new_len));
 463         if(fcs != get_unaligned_le32(buf + new_len)) {
 464                 IRDA_ERROR("crc error calc 0x%x len %d\n", fcs, new_len);
 465                 mcs->netdev->stats.rx_errors++;
 466                 mcs->netdev->stats.rx_crc_errors++;
 467                 return;
 468         }
 469
 470         skb = dev_alloc_skb(new_len + 1);
 471         if(unlikely(!skb)) {
 472                 ++mcs->netdev->stats.rx_dropped;
 473                 return;
 474         }
 475
 476         skb_reserve(skb, 1);
 477         skb_copy_to_linear_data(skb, buf, new_len);
 478         skb_put(skb, new_len);
 479         skb_reset_mac_header(skb);
 480         skb->protocol = htons(ETH_P_IRDA);
 481         skb->dev = mcs->netdev;
 482
 483         netif_rx(skb);
 484
 485         mcs->netdev->stats.rx_packets++;
 486         mcs->netdev->stats.rx_bytes += new_len;
 487 }
 488
 489
 490 /* Allocates urbs for both receive and transmit.
 491  * If alloc fails return error code 0 (fail) otherwise
 492  * return error code 1 (success).
 493  */
 494 static inline int mcs_setup_urbs(struct mcs_cb *mcs)
 495 {
 496         mcs->rx_urb = NULL;
 497
 498         mcs->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
 499         if (!mcs->tx_urb)
 500                 return 0;
 501
 502         mcs->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
 503         if (!mcs->rx_urb) {
 504                 usb_free_urb(mcs->tx_urb);
 505                 mcs->tx_urb = NULL;
 506                 return 0;
 507         }
 508
 509         return 1;
 510 }
 511
 512 /* Sets up state to be initially outside frame, gets receive urb,
 513  * sets status to successful and then submits the urb to start
 514  * receiving the data.
 515  */
 516 static inline int mcs_receive_start(struct mcs_cb *mcs)
 517 {
 518         mcs->rx_buff.in_frame = FALSE;
 519         mcs->rx_buff.state = OUTSIDE_FRAME;
 520
 521         usb_fill_bulk_urb(mcs->rx_urb, mcs->usbdev,
 522                           usb_rcvbulkpipe(mcs->usbdev, mcs->ep_in),
 523                           mcs->in_buf, 4096, mcs_receive_irq, mcs);
 524
 525         mcs->rx_urb->status = 0;
 526         return usb_submit_urb(mcs->rx_urb, GFP_KERNEL);
 527 }
 528
 529 /* Finds the in and out endpoints for the mcs control block */
 530 static inline int mcs_find_endpoints(struct mcs_cb *mcs,
 531                                      struct usb_host_endpoint *ep, int epnum)
 532 {
 533         int i;
 534         int ret = 0;
 535
 536         /* If no place to store the endpoints just return */
 537         if (!ep)
 538                 return ret;
 539
 540         /* cycle through all endpoints, find the first two that are DIR_IN */
 541         for (i = 0; i < epnum; i++) {
 542                 if (ep[i].desc.bEndpointAddress & USB_DIR_IN)
 543                         mcs->ep_in = ep[i].desc.bEndpointAddress;
 544                 else
 545                         mcs->ep_out = ep[i].desc.bEndpointAddress;
 546
 547                 /* MosChip says that the chip has only two bulk
 548                  * endpoints. Find one for each direction and move on.
 549                  */
 550                 if ((mcs->ep_in != 0) && (mcs->ep_out != 0)) {
 551                         ret = 1;
 552                         break;
 553                 }
 554         }
 555
 556         return ret;
 557 }
 558
 559 static void mcs_speed_work(struct work_struct *work)
 560 {
 561         struct mcs_cb *mcs = container_of(work, struct mcs_cb, work);
 562         struct net_device *netdev = mcs->netdev;
 563
 564         mcs_speed_change(mcs);
 565         netif_wake_queue(netdev);
 566 }
 567
 568 /* Function to change the speed of the mcs7780.  Fully supports SIR,
 569  * MIR, and FIR speeds.
 570  */
 571 static int mcs_speed_change(struct mcs_cb *mcs)
 572 {
 573         int ret = 0;
 574         int rst = 0;
 575         int cnt = 0;
 576         __u16 nspeed;
 577         __u16 rval;
 578
 579         nspeed = mcs_speed_set[(mcs->new_speed >> 8) & 0x0f];
 580
 581         do {
 582                 mcs_get_reg(mcs, MCS_RESV_REG, &rval);
 583         } while(cnt++ < 100 && (rval & MCS_IRINTX));
 584
 585         if (cnt > 100) {
 586                 IRDA_ERROR("unable to change speed\n");
 587                 ret = -EIO;
 588                 goto error;
 589         }
 590
 591         mcs_get_reg(mcs, MCS_MODE_REG, &rval);
 592
 593         /* MINRXPW values recommended by MosChip */
 594         if (mcs->new_speed <= 115200) {
 595                 rval &= ~MCS_FIR;
 596
 597                 if ((rst = (mcs->speed > 115200)))
 598                         mcs_set_reg(mcs, MCS_MINRXPW_REG, 0);
 599
 600         } else if (mcs->new_speed <= 1152000) {
 601                 rval &= ~MCS_FIR;
 602
 603                 if ((rst = !(mcs->speed == 576000 || mcs->speed == 1152000)))
 604                         mcs_set_reg(mcs, MCS_MINRXPW_REG, 5);
 605
 606         } else {
 607                 rval |= MCS_FIR;
 608
 609                 if ((rst = (mcs->speed != 4000000)))
 610                         mcs_set_reg(mcs, MCS_MINRXPW_REG, 5);
 611
 612         }
 613
 614         rval &= ~MCS_SPEED_MASK;
 615         rval |= nspeed;
 616
 617         ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
 618         if (unlikely(ret))
 619                 goto error;
 620
 621         if (rst)
 622                 switch (mcs->transceiver_type) {
 623                 case MCS_TSC_VISHAY:
 624                         ret = mcs_setup_transceiver_vishay(mcs);
 625                         break;
 626
 627                 case MCS_TSC_SHARP:
 628                         ret = mcs_setup_transceiver_sharp(mcs);
 629                         break;
 630
 631                 case MCS_TSC_AGILENT:
 632                         ret = mcs_setup_transceiver_agilent(mcs);
 633                         break;
 634
 635                 default:
 636                         ret = 1;
 637                         IRDA_WARNING("Unknown transceiver type: %d\n",
 638                                      mcs->transceiver_type);
 639                 }
 640         if (unlikely(ret))
 641                 goto error;
 642
 643         mcs_get_reg(mcs, MCS_MODE_REG, &rval);
 644         rval &= ~MCS_RESET;
 645         ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
 646
 647         mcs->speed = mcs->new_speed;
 648 error:
 649         mcs->new_speed = 0;
 650         return ret;
 651 }
 652
 653 /* Ioctl calls not supported at this time.  Can be an area of future work. */
 654 static int mcs_net_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 655 {
 656         /* struct if_irda_req *irq = (struct if_irda_req *)rq; */
 657         /* struct mcs_cb *mcs = netdev_priv(netdev); */
 658         int ret = 0;
 659
 660         switch (cmd) {
 661         default:
 662                 ret = -EOPNOTSUPP;
 663         }
 664
 665         return ret;
 666 }
 667
 668 /* Network device is taken down, done by "ifconfig irda0 down" */
 669 static int mcs_net_close(struct net_device *netdev)
 670 {
 671         int ret = 0;
 672         struct mcs_cb *mcs = netdev_priv(netdev);
 673
 674         /* Stop transmit processing */
 675         netif_stop_queue(netdev);
 676
 677         kfree_skb(mcs->rx_buff.skb);
 678
 679         /* kill and free the receive and transmit URBs */
 680         usb_kill_urb(mcs->rx_urb);
 681         usb_free_urb(mcs->rx_urb);
 682         usb_kill_urb(mcs->tx_urb);
 683         usb_free_urb(mcs->tx_urb);
 684
 685         /* Stop and remove instance of IrLAP */
 686         if (mcs->irlap)
 687                 irlap_close(mcs->irlap);
 688
 689         mcs->irlap = NULL;
 690         return ret;
 691 }
 692
 693 /* Network device is taken up, done by "ifconfig irda0 up" */
 694 static int mcs_net_open(struct net_device *netdev)
 695 {
 696         struct mcs_cb *mcs = netdev_priv(netdev);
 697         char hwname[16];
 698         int ret = 0;
 699
 700         ret = usb_clear_halt(mcs->usbdev,
 701                              usb_sndbulkpipe(mcs->usbdev, mcs->ep_in));
 702         if (ret)
 703                 goto error1;
 704         ret = usb_clear_halt(mcs->usbdev,
 705                              usb_rcvbulkpipe(mcs->usbdev, mcs->ep_out));
 706         if (ret)
 707                 goto error1;
 708
 709         ret = mcs_setup_transceiver(mcs);
 710         if (ret)
 711                 goto error1;
 712
 713         ret = -ENOMEM;
 714
 715         /* Initialize for SIR/FIR to copy data directly into skb.  */
 716         mcs->receiving = 0;
 717         mcs->rx_buff.truesize = IRDA_SKB_MAX_MTU;
 718         mcs->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
 719         if (!mcs->rx_buff.skb)
 720                 goto error1;
 721
 722         skb_reserve(mcs->rx_buff.skb, 1);
 723         mcs->rx_buff.head = mcs->rx_buff.skb->data;
 724         do_gettimeofday(&mcs->rx_time);
 725
 726         /*
 727          * Now that everything should be initialized properly,
 728          * Open new IrLAP layer instance to take care of us...
 729          * Note : will send immediately a speed change...
 730          */
 731         sprintf(hwname, "usb#%d", mcs->usbdev->devnum);
 732         mcs->irlap = irlap_open(netdev, &mcs->qos, hwname);
 733         if (!mcs->irlap) {
 734                 IRDA_ERROR("mcs7780: irlap_open failed\n");
 735                 goto error2;
 736         }
 737
 738         if (!mcs_setup_urbs(mcs))
 739                 goto error3;
 740
 741         ret = mcs_receive_start(mcs);
 742         if (ret)
 743                 goto error4;
 744
 745         netif_start_queue(netdev);
 746         return 0;
 747
 748 error4:
 749         usb_free_urb(mcs->rx_urb);
 750         usb_free_urb(mcs->tx_urb);
 751 error3:
 752         irlap_close(mcs->irlap);
 753 error2:
 754         kfree_skb(mcs->rx_buff.skb);
 755 error1:
 756         return ret;
 757 }
 758
 759 /* Receive callback function.  */
 760 static void mcs_receive_irq(struct urb *urb)
 761 {
 762         __u8 *bytes;
 763         struct mcs_cb *mcs = urb->context;
 764         int i;
 765         int ret;
 766
 767         if (!netif_running(mcs->netdev))
 768                 return;
 769
 770         if (urb->status)
 771                 return;
 772
 773         if (urb->actual_length > 0) {
 774                 bytes = urb->transfer_buffer;
 775
 776                 /* MCS returns frames without BOF and EOF
 777                  * I assume it returns whole frames.
 778                  */
 779                 /* SIR speed */
 780                 if(mcs->speed < 576000) {
 781                         async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
 782                                   &mcs->rx_buff, 0xc0);
 783
 784                         for (i = 0; i < urb->actual_length; i++)
 785                                 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
 786                                           &mcs->rx_buff, bytes[i]);
 787
 788                         async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
 789                                   &mcs->rx_buff, 0xc1);
 790                 }
 791                 /* MIR speed */
 792                 else if(mcs->speed == 576000 || mcs->speed == 1152000) {
 793                         mcs_unwrap_mir(mcs, urb->transfer_buffer,
 794                                 urb->actual_length);
 795                 }
 796                 /* FIR speed */
 797                 else {
 798                         mcs_unwrap_fir(mcs, urb->transfer_buffer,
 799                                 urb->actual_length);
 800                 }
 801                 do_gettimeofday(&mcs->rx_time);
 802         }
 803
 804         ret = usb_submit_urb(urb, GFP_ATOMIC);
 805 }
 806
 807 /* Transmit callback function.  */
 808 static void mcs_send_irq(struct urb *urb)
 809 {
 810         struct mcs_cb *mcs = urb->context;
 811         struct net_device *ndev = mcs->netdev;
 812
 813         if (unlikely(mcs->new_speed))
 814                 schedule_work(&mcs->work);
 815         else
 816                 netif_wake_queue(ndev);
 817 }
 818
 819 /* Transmit callback function.  */
 820 static netdev_tx_t mcs_hard_xmit(struct sk_buff *skb,
 821                                        struct net_device *ndev)
 822 {
 823         unsigned long flags;
 824         struct mcs_cb *mcs;
 825         int wraplen;
 826         int ret = 0;
 827
 828         netif_stop_queue(ndev);
 829         mcs = netdev_priv(ndev);
 830
 831         spin_lock_irqsave(&mcs->lock, flags);
 832
 833         mcs->new_speed = irda_get_next_speed(skb);
 834         if (likely(mcs->new_speed == mcs->speed))
 835                 mcs->new_speed = 0;
 836
 837         /* SIR speed */
 838         if(mcs->speed < 576000) {
 839                 wraplen = mcs_wrap_sir_skb(skb, mcs->out_buf);
 840         }
 841         /* MIR speed */
 842         else if(mcs->speed == 576000 || mcs->speed == 1152000) {
 843                 wraplen = mcs_wrap_mir_skb(skb, mcs->out_buf);
 844         }
 845         /* FIR speed */
 846         else {
 847                 wraplen = mcs_wrap_fir_skb(skb, mcs->out_buf);
 848         }
 849         usb_fill_bulk_urb(mcs->tx_urb, mcs->usbdev,
 850                           usb_sndbulkpipe(mcs->usbdev, mcs->ep_out),
 851                           mcs->out_buf, wraplen, mcs_send_irq, mcs);
 852
 853         if ((ret = usb_submit_urb(mcs->tx_urb, GFP_ATOMIC))) {
 854                 IRDA_ERROR("failed tx_urb: %d\n", ret);
 855                 switch (ret) {
 856                 case -ENODEV:
 857                 case -EPIPE:
 858                         break;
 859                 default:
 860                         mcs->netdev->stats.tx_errors++;
 861                         netif_start_queue(ndev);
 862                 }
 863         } else {
 864                 mcs->netdev->stats.tx_packets++;
 865                 mcs->netdev->stats.tx_bytes += skb->len;
 866         }
 867
 868         dev_kfree_skb(skb);
 869         spin_unlock_irqrestore(&mcs->lock, flags);
 870         return NETDEV_TX_OK;
 871 }
 872
 873 static const struct net_device_ops mcs_netdev_ops = {
 874         .ndo_open = mcs_net_open,
 875         .ndo_stop = mcs_net_close,
 876         .ndo_start_xmit = mcs_hard_xmit,
 877         .ndo_do_ioctl = mcs_net_ioctl,
 878 };
 879
 880 /*
 881  * This function is called by the USB subsystem for each new device in the
 882  * system.  Need to verify the device and if it is, then start handling it.
 883  */
 884 static int mcs_probe(struct usb_interface *intf,
 885                      const struct usb_device_id *id)
 886 {
 887         struct usb_device *udev = interface_to_usbdev(intf);
 888         struct net_device *ndev = NULL;
 889         struct mcs_cb *mcs;
 890         int ret = -ENOMEM;
 891
 892         ndev = alloc_irdadev(sizeof(*mcs));
 893         if (!ndev)
 894                 goto error1;
 895
 896         IRDA_DEBUG(1, "MCS7780 USB-IrDA bridge found at %d.\n", udev->devnum);
 897
 898         SET_NETDEV_DEV(ndev, &intf->dev);
 899
 900         ret = usb_reset_configuration(udev);
 901         if (ret != 0) {
 902                 IRDA_ERROR("mcs7780: usb reset configuration failed\n");
 903                 goto error2;
 904         }
 905
 906         mcs = netdev_priv(ndev);
 907         mcs->usbdev = udev;
 908         mcs->netdev = ndev;
 909         spin_lock_init(&mcs->lock);
 910
 911         /* Initialize QoS for this device */
 912         irda_init_max_qos_capabilies(&mcs->qos);
 913
 914         /* That's the Rx capability. */
 915         mcs->qos.baud_rate.bits &=
 916             IR_2400 | IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200
 917                 | IR_576000 | IR_1152000 | (IR_4000000 << 8);
 918
 919
 920         mcs->qos.min_turn_time.bits &= qos_mtt_bits;
 921         irda_qos_bits_to_value(&mcs->qos);
 922
 923         /* Speed change work initialisation*/
 924         INIT_WORK(&mcs->work, mcs_speed_work);
 925
 926         ndev->netdev_ops = &mcs_netdev_ops;
 927
 928         if (!intf->cur_altsetting) {
 929                 ret = -ENOMEM;
 930                 goto error2;
 931         }
 932
 933         ret = mcs_find_endpoints(mcs, intf->cur_altsetting->endpoint,
 934                                  intf->cur_altsetting->desc.bNumEndpoints);
 935         if (!ret) {
 936                 ret = -ENODEV;
 937                 goto error2;
 938         }
 939
 940         ret = register_netdev(ndev);
 941         if (ret != 0)
 942                 goto error2;
 943
 944         IRDA_DEBUG(1, "IrDA: Registered MosChip MCS7780 device as %s\n",
 945                    ndev->name);
 946
 947         mcs->transceiver_type = transceiver_type;
 948         mcs->sir_tweak = sir_tweak;
 949         mcs->receive_mode = receive_mode;
 950
 951         usb_set_intfdata(intf, mcs);
 952         return 0;
 953
 954 error2:
 955         free_netdev(ndev);
 956
 957 error1:
 958         return ret;
 959 }
 960
 961 /* The current device is removed, the USB layer tells us to shut down. */
 962 static void mcs_disconnect(struct usb_interface *intf)
 963 {
 964         struct mcs_cb *mcs = usb_get_intfdata(intf);
 965
 966         if (!mcs)
 967                 return;
 968
 969         cancel_work_sync(&mcs->work);
 970
 971         unregister_netdev(mcs->netdev);
 972         free_netdev(mcs->netdev);
 973
 974         usb_set_intfdata(intf, NULL);
 975         IRDA_DEBUG(0, "MCS7780 now disconnected.\n");
 976 }
 977
 978 module_usb_driver(mcs_driver);