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