Version:  2.0.40 2.2.26 2.4.37 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19

Linux/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         net_warn_ratelimited("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         net_warn_ratelimited("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         const 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                 net_warn_ratelimited("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         net_err_ratelimited("%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                 net_err_ratelimited("%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                 net_err_ratelimited("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                 net_err_ratelimited("%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                 net_err_ratelimited("crc error calc 0x%x len %d\n",
465                                     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                 usb_free_urb(mcs->tx_urb);
506                 mcs->tx_urb = NULL;
507                 return 0;
508         }
509 
510         return 1;
511 }
512 
513 /* Sets up state to be initially outside frame, gets receive urb,
514  * sets status to successful and then submits the urb to start
515  * receiving the data.
516  */
517 static inline int mcs_receive_start(struct mcs_cb *mcs)
518 {
519         mcs->rx_buff.in_frame = FALSE;
520         mcs->rx_buff.state = OUTSIDE_FRAME;
521 
522         usb_fill_bulk_urb(mcs->rx_urb, mcs->usbdev,
523                           usb_rcvbulkpipe(mcs->usbdev, mcs->ep_in),
524                           mcs->in_buf, 4096, mcs_receive_irq, mcs);
525 
526         mcs->rx_urb->status = 0;
527         return usb_submit_urb(mcs->rx_urb, GFP_KERNEL);
528 }
529 
530 /* Finds the in and out endpoints for the mcs control block */
531 static inline int mcs_find_endpoints(struct mcs_cb *mcs,
532                                      struct usb_host_endpoint *ep, int epnum)
533 {
534         int i;
535         int ret = 0;
536 
537         /* If no place to store the endpoints just return */
538         if (!ep)
539                 return ret;
540 
541         /* cycle through all endpoints, find the first two that are DIR_IN */
542         for (i = 0; i < epnum; i++) {
543                 if (ep[i].desc.bEndpointAddress & USB_DIR_IN)
544                         mcs->ep_in = ep[i].desc.bEndpointAddress;
545                 else
546                         mcs->ep_out = ep[i].desc.bEndpointAddress;
547 
548                 /* MosChip says that the chip has only two bulk
549                  * endpoints. Find one for each direction and move on.
550                  */
551                 if ((mcs->ep_in != 0) && (mcs->ep_out != 0)) {
552                         ret = 1;
553                         break;
554                 }
555         }
556 
557         return ret;
558 }
559 
560 static void mcs_speed_work(struct work_struct *work)
561 {
562         struct mcs_cb *mcs = container_of(work, struct mcs_cb, work);
563         struct net_device *netdev = mcs->netdev;
564 
565         mcs_speed_change(mcs);
566         netif_wake_queue(netdev);
567 }
568 
569 /* Function to change the speed of the mcs7780.  Fully supports SIR,
570  * MIR, and FIR speeds.
571  */
572 static int mcs_speed_change(struct mcs_cb *mcs)
573 {
574         int ret = 0;
575         int rst = 0;
576         int cnt = 0;
577         __u16 nspeed;
578         __u16 rval;
579 
580         nspeed = mcs_speed_set[(mcs->new_speed >> 8) & 0x0f];
581 
582         do {
583                 mcs_get_reg(mcs, MCS_RESV_REG, &rval);
584         } while(cnt++ < 100 && (rval & MCS_IRINTX));
585 
586         if (cnt > 100) {
587                 net_err_ratelimited("unable to change speed\n");
588                 ret = -EIO;
589                 goto error;
590         }
591 
592         mcs_get_reg(mcs, MCS_MODE_REG, &rval);
593 
594         /* MINRXPW values recommended by MosChip */
595         if (mcs->new_speed <= 115200) {
596                 rval &= ~MCS_FIR;
597 
598                 if ((rst = (mcs->speed > 115200)))
599                         mcs_set_reg(mcs, MCS_MINRXPW_REG, 0);
600 
601         } else if (mcs->new_speed <= 1152000) {
602                 rval &= ~MCS_FIR;
603 
604                 if ((rst = !(mcs->speed == 576000 || mcs->speed == 1152000)))
605                         mcs_set_reg(mcs, MCS_MINRXPW_REG, 5);
606 
607         } else {
608                 rval |= MCS_FIR;
609 
610                 if ((rst = (mcs->speed != 4000000)))
611                         mcs_set_reg(mcs, MCS_MINRXPW_REG, 5);
612 
613         }
614 
615         rval &= ~MCS_SPEED_MASK;
616         rval |= nspeed;
617 
618         ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
619         if (unlikely(ret))
620                 goto error;
621 
622         if (rst)
623                 switch (mcs->transceiver_type) {
624                 case MCS_TSC_VISHAY:
625                         ret = mcs_setup_transceiver_vishay(mcs);
626                         break;
627 
628                 case MCS_TSC_SHARP:
629                         ret = mcs_setup_transceiver_sharp(mcs);
630                         break;
631 
632                 case MCS_TSC_AGILENT:
633                         ret = mcs_setup_transceiver_agilent(mcs);
634                         break;
635 
636                 default:
637                         ret = 1;
638                         net_warn_ratelimited("Unknown transceiver type: %d\n",
639                                              mcs->transceiver_type);
640                 }
641         if (unlikely(ret))
642                 goto error;
643 
644         mcs_get_reg(mcs, MCS_MODE_REG, &rval);
645         rval &= ~MCS_RESET;
646         ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
647 
648         mcs->speed = mcs->new_speed;
649 error:
650         mcs->new_speed = 0;
651         return ret;
652 }
653 
654 /* Ioctl calls not supported at this time.  Can be an area of future work. */
655 static int mcs_net_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
656 {
657         /* struct if_irda_req *irq = (struct if_irda_req *)rq; */
658         /* struct mcs_cb *mcs = netdev_priv(netdev); */
659         int ret = 0;
660 
661         switch (cmd) {
662         default:
663                 ret = -EOPNOTSUPP;
664         }
665 
666         return ret;
667 }
668 
669 /* Network device is taken down, done by "ifconfig irda0 down" */
670 static int mcs_net_close(struct net_device *netdev)
671 {
672         int ret = 0;
673         struct mcs_cb *mcs = netdev_priv(netdev);
674 
675         /* Stop transmit processing */
676         netif_stop_queue(netdev);
677 
678         kfree_skb(mcs->rx_buff.skb);
679 
680         /* kill and free the receive and transmit URBs */
681         usb_kill_urb(mcs->rx_urb);
682         usb_free_urb(mcs->rx_urb);
683         usb_kill_urb(mcs->tx_urb);
684         usb_free_urb(mcs->tx_urb);
685 
686         /* Stop and remove instance of IrLAP */
687         if (mcs->irlap)
688                 irlap_close(mcs->irlap);
689 
690         mcs->irlap = NULL;
691         return ret;
692 }
693 
694 /* Network device is taken up, done by "ifconfig irda0 up" */
695 static int mcs_net_open(struct net_device *netdev)
696 {
697         struct mcs_cb *mcs = netdev_priv(netdev);
698         char hwname[16];
699         int ret = 0;
700 
701         ret = usb_clear_halt(mcs->usbdev,
702                              usb_sndbulkpipe(mcs->usbdev, mcs->ep_in));
703         if (ret)
704                 goto error1;
705         ret = usb_clear_halt(mcs->usbdev,
706                              usb_rcvbulkpipe(mcs->usbdev, mcs->ep_out));
707         if (ret)
708                 goto error1;
709 
710         ret = mcs_setup_transceiver(mcs);
711         if (ret)
712                 goto error1;
713 
714         ret = -ENOMEM;
715 
716         /* Initialize for SIR/FIR to copy data directly into skb.  */
717         mcs->receiving = 0;
718         mcs->rx_buff.truesize = IRDA_SKB_MAX_MTU;
719         mcs->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
720         if (!mcs->rx_buff.skb)
721                 goto error1;
722 
723         skb_reserve(mcs->rx_buff.skb, 1);
724         mcs->rx_buff.head = mcs->rx_buff.skb->data;
725         do_gettimeofday(&mcs->rx_time);
726 
727         /*
728          * Now that everything should be initialized properly,
729          * Open new IrLAP layer instance to take care of us...
730          * Note : will send immediately a speed change...
731          */
732         sprintf(hwname, "usb#%d", mcs->usbdev->devnum);
733         mcs->irlap = irlap_open(netdev, &mcs->qos, hwname);
734         if (!mcs->irlap) {
735                 net_err_ratelimited("mcs7780: irlap_open failed\n");
736                 goto error2;
737         }
738 
739         if (!mcs_setup_urbs(mcs))
740                 goto error3;
741 
742         ret = mcs_receive_start(mcs);
743         if (ret)
744                 goto error4;
745 
746         netif_start_queue(netdev);
747         return 0;
748 
749 error4:
750         usb_free_urb(mcs->rx_urb);
751         usb_free_urb(mcs->tx_urb);
752 error3:
753         irlap_close(mcs->irlap);
754 error2:
755         kfree_skb(mcs->rx_buff.skb);
756 error1:
757         return ret;
758 }
759 
760 /* Receive callback function.  */
761 static void mcs_receive_irq(struct urb *urb)
762 {
763         __u8 *bytes;
764         struct mcs_cb *mcs = urb->context;
765         int i;
766         int ret;
767 
768         if (!netif_running(mcs->netdev))
769                 return;
770 
771         if (urb->status)
772                 return;
773 
774         if (urb->actual_length > 0) {
775                 bytes = urb->transfer_buffer;
776 
777                 /* MCS returns frames without BOF and EOF
778                  * I assume it returns whole frames.
779                  */
780                 /* SIR speed */
781                 if(mcs->speed < 576000) {
782                         async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
783                                   &mcs->rx_buff, 0xc0);
784 
785                         for (i = 0; i < urb->actual_length; i++)
786                                 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
787                                           &mcs->rx_buff, bytes[i]);
788 
789                         async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
790                                   &mcs->rx_buff, 0xc1);
791                 }
792                 /* MIR speed */
793                 else if(mcs->speed == 576000 || mcs->speed == 1152000) {
794                         mcs_unwrap_mir(mcs, urb->transfer_buffer,
795                                 urb->actual_length);
796                 }
797                 /* FIR speed */
798                 else {
799                         mcs_unwrap_fir(mcs, urb->transfer_buffer,
800                                 urb->actual_length);
801                 }
802                 do_gettimeofday(&mcs->rx_time);
803         }
804 
805         ret = usb_submit_urb(urb, GFP_ATOMIC);
806 }
807 
808 /* Transmit callback function.  */
809 static void mcs_send_irq(struct urb *urb)
810 {
811         struct mcs_cb *mcs = urb->context;
812         struct net_device *ndev = mcs->netdev;
813 
814         if (unlikely(mcs->new_speed))
815                 schedule_work(&mcs->work);
816         else
817                 netif_wake_queue(ndev);
818 }
819 
820 /* Transmit callback function.  */
821 static netdev_tx_t mcs_hard_xmit(struct sk_buff *skb,
822                                        struct net_device *ndev)
823 {
824         unsigned long flags;
825         struct mcs_cb *mcs;
826         int wraplen;
827         int ret = 0;
828 
829         netif_stop_queue(ndev);
830         mcs = netdev_priv(ndev);
831 
832         spin_lock_irqsave(&mcs->lock, flags);
833 
834         mcs->new_speed = irda_get_next_speed(skb);
835         if (likely(mcs->new_speed == mcs->speed))
836                 mcs->new_speed = 0;
837 
838         /* SIR speed */
839         if(mcs->speed < 576000) {
840                 wraplen = mcs_wrap_sir_skb(skb, mcs->out_buf);
841         }
842         /* MIR speed */
843         else if(mcs->speed == 576000 || mcs->speed == 1152000) {
844                 wraplen = mcs_wrap_mir_skb(skb, mcs->out_buf);
845         }
846         /* FIR speed */
847         else {
848                 wraplen = mcs_wrap_fir_skb(skb, mcs->out_buf);
849         }
850         usb_fill_bulk_urb(mcs->tx_urb, mcs->usbdev,
851                           usb_sndbulkpipe(mcs->usbdev, mcs->ep_out),
852                           mcs->out_buf, wraplen, mcs_send_irq, mcs);
853 
854         if ((ret = usb_submit_urb(mcs->tx_urb, GFP_ATOMIC))) {
855                 net_err_ratelimited("failed tx_urb: %d\n", ret);
856                 switch (ret) {
857                 case -ENODEV:
858                 case -EPIPE:
859                         break;
860                 default:
861                         mcs->netdev->stats.tx_errors++;
862                         netif_start_queue(ndev);
863                 }
864         } else {
865                 mcs->netdev->stats.tx_packets++;
866                 mcs->netdev->stats.tx_bytes += skb->len;
867         }
868 
869         dev_kfree_skb(skb);
870         spin_unlock_irqrestore(&mcs->lock, flags);
871         return NETDEV_TX_OK;
872 }
873 
874 static const struct net_device_ops mcs_netdev_ops = {
875         .ndo_open = mcs_net_open,
876         .ndo_stop = mcs_net_close,
877         .ndo_start_xmit = mcs_hard_xmit,
878         .ndo_do_ioctl = mcs_net_ioctl,
879 };
880 
881 /*
882  * This function is called by the USB subsystem for each new device in the
883  * system.  Need to verify the device and if it is, then start handling it.
884  */
885 static int mcs_probe(struct usb_interface *intf,
886                      const struct usb_device_id *id)
887 {
888         struct usb_device *udev = interface_to_usbdev(intf);
889         struct net_device *ndev = NULL;
890         struct mcs_cb *mcs;
891         int ret = -ENOMEM;
892 
893         ndev = alloc_irdadev(sizeof(*mcs));
894         if (!ndev)
895                 goto error1;
896 
897         pr_debug("MCS7780 USB-IrDA bridge found at %d.\n", udev->devnum);
898 
899         SET_NETDEV_DEV(ndev, &intf->dev);
900 
901         ret = usb_reset_configuration(udev);
902         if (ret != 0) {
903                 net_err_ratelimited("mcs7780: usb reset configuration failed\n");
904                 goto error2;
905         }
906 
907         mcs = netdev_priv(ndev);
908         mcs->usbdev = udev;
909         mcs->netdev = ndev;
910         spin_lock_init(&mcs->lock);
911 
912         /* Initialize QoS for this device */
913         irda_init_max_qos_capabilies(&mcs->qos);
914 
915         /* That's the Rx capability. */
916         mcs->qos.baud_rate.bits &=
917             IR_2400 | IR_9600 | IR_19200 | IR_38400 | IR_57600 | IR_115200
918                 | IR_576000 | IR_1152000 | (IR_4000000 << 8);
919 
920 
921         mcs->qos.min_turn_time.bits &= qos_mtt_bits;
922         irda_qos_bits_to_value(&mcs->qos);
923 
924         /* Speed change work initialisation*/
925         INIT_WORK(&mcs->work, mcs_speed_work);
926 
927         ndev->netdev_ops = &mcs_netdev_ops;
928 
929         if (!intf->cur_altsetting) {
930                 ret = -ENOMEM;
931                 goto error2;
932         }
933 
934         ret = mcs_find_endpoints(mcs, intf->cur_altsetting->endpoint,
935                                  intf->cur_altsetting->desc.bNumEndpoints);
936         if (!ret) {
937                 ret = -ENODEV;
938                 goto error2;
939         }
940 
941         ret = register_netdev(ndev);
942         if (ret != 0)
943                 goto error2;
944 
945         pr_debug("IrDA: Registered MosChip MCS7780 device as %s\n",
946                  ndev->name);
947 
948         mcs->transceiver_type = transceiver_type;
949         mcs->sir_tweak = sir_tweak;
950         mcs->receive_mode = receive_mode;
951 
952         usb_set_intfdata(intf, mcs);
953         return 0;
954 
955 error2:
956         free_netdev(ndev);
957 
958 error1:
959         return ret;
960 }
961 
962 /* The current device is removed, the USB layer tells us to shut down. */
963 static void mcs_disconnect(struct usb_interface *intf)
964 {
965         struct mcs_cb *mcs = usb_get_intfdata(intf);
966 
967         if (!mcs)
968                 return;
969 
970         cancel_work_sync(&mcs->work);
971 
972         unregister_netdev(mcs->netdev);
973         free_netdev(mcs->netdev);
974 
975         usb_set_intfdata(intf, NULL);
976         pr_debug("MCS7780 now disconnected.\n");
977 }
978 
979 module_usb_driver(mcs_driver);
980 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us