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