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