]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blame - drivers/net/irda/mcs7780.c
projects / mirror_ubuntu-eoan-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'jfs-3.12' of git://github.com/kleikamp/linux-shaggy
[mirror_ubuntu-eoan-kernel.git] / drivers / net / irda / mcs7780.c
CommitLineData
c6ae522e
SO		 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>
c6ae522e
SO		 48#include <linux/kernel.h>
49#include <linux/types.h>
50#include <linux/errno.h>
51#include <linux/init.h>
52#include <linux/slab.h>
c6ae522e
SO		 53#include <linux/usb.h>
54#include <linux/device.h>
55#include <linux/crc32.h>
56
57#include <asm/unaligned.h>
58#include <asm/byteorder.h>
59#include <asm/uaccess.h>
60
61#include <net/irda/irda.h>
62#include <net/irda/wrapper.h>
63#include <net/irda/crc.h>
64
65#include "mcs7780.h"
66
67#define MCS_VENDOR_ID 0x9710
68#define MCS_PRODUCT_ID 0x7780
69
70static struct usb_device_id mcs_table[] = {
71 /* MosChip Corp., MCS7780 FIR-USB Adapter */
72 {USB_DEVICE(MCS_VENDOR_ID, MCS_PRODUCT_ID)},
73 {},
74};
75
76MODULE_AUTHOR("Brian Pugh <bpugh@cs.pdx.edu>");
77MODULE_DESCRIPTION("IrDA-USB Dongle Driver for MosChip MCS7780");
78MODULE_VERSION("0.3alpha");
79MODULE_LICENSE("GPL");
80
81MODULE_DEVICE_TABLE(usb, mcs_table);
82
83static int qos_mtt_bits = 0x07 /* > 1ms */ ;
84module_param(qos_mtt_bits, int, 0);
85MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time");
86
87static int receive_mode = 0x1;
88module_param(receive_mode, int, 0);
89MODULE_PARM_DESC(receive_mode,
90 "Receive mode of the device (1:fast, 0:slow, default:1)");
91
92static int sir_tweak = 1;
93module_param(sir_tweak, int, 0444);
94MODULE_PARM_DESC(sir_tweak,
95 "Default pulse width (1:1.6us, 0:3/16 bit, default:1).");
96
97static int transceiver_type = MCS_TSC_VISHAY;
98module_param(transceiver_type, int, 0444);
99MODULE_PARM_DESC(transceiver_type, "IR transceiver type, see mcs7780.h.");
100
7263ade1 101static struct usb_driver mcs_driver = {
c6ae522e
SO		 102 .name = "mcs7780",
103 .probe = mcs_probe,
104 .disconnect = mcs_disconnect,
105 .id_table = mcs_table,
106};
107
108/* speed flag selection by direct addressing.
109addr = (speed >> 8) & 0x0f
110
1110x1 57600 0x2 115200 0x4 1152000 0x5 9600
1120x6 38400 0x9 2400 0xa 576000 0xb 19200
113
1144Mbps (or 2400) must be checked separately. Since it also has
115to be programmed in a different manner that is not a big problem.
116*/
117static __u16 mcs_speed_set[16] = { 0,
118 MCS_SPEED_57600,
119 MCS_SPEED_115200,
120 0,
121 MCS_SPEED_1152000,
122 MCS_SPEED_9600,
123 MCS_SPEED_38400,
124 0, 0,
125 MCS_SPEED_2400,
126 MCS_SPEED_576000,
127 MCS_SPEED_19200,
128 0, 0, 0,
129};
130
131/* Set given 16 bit register with a 16 bit value. Send control message
132 * to set dongle register. */
133static int mcs_set_reg(struct mcs_cb *mcs, __u16 reg, __u16 val)
134{
135 struct usb_device *dev = mcs->usbdev;
136 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
137 MCS_WR_RTYPE, val, reg, NULL, 0,
138 msecs_to_jiffies(MCS_CTRL_TIMEOUT));
139}
140
141/* Get 16 bit register value. Send contol message to read dongle register. */
142static int mcs_get_reg(struct mcs_cb *mcs, __u16 reg, __u16 * val)
143{
144 struct usb_device *dev = mcs->usbdev;
145 int ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
146 MCS_RD_RTYPE, 0, reg, val, 2,
147 msecs_to_jiffies(MCS_CTRL_TIMEOUT));
148
149 return ret;
150}
151
152/* Setup a communication between mcs7780 and TFDU chips. It is described
153 * in more detail in the data sheet. The setup sequence puts the the
154 * vishay tranceiver into high speed mode. It will also receive SIR speed
155 * packets but at reduced sensitivity.
156 */
157
158/* 0: OK 1:ERROR */
159static inline int mcs_setup_transceiver_vishay(struct mcs_cb *mcs)
160{
161 int ret = 0;
162 __u16 rval;
163
164 /* mcs_get_reg should read exactly two bytes from the dongle */
165 ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval);
166 if (unlikely(ret != 2)) {
167 ret = -EIO;
168 goto error;
169 }
170
171 /* The MCS_XCVR_CONF bit puts the transceiver into configuration
172 * mode. The MCS_MODE0 bit must start out high (1) and then
173 * transition to low and the MCS_STFIR and MCS_MODE1 bits must
174 * be low.
175 */
176 rval |= (MCS_MODE0 | MCS_XCVR_CONF);
177 rval &= ~MCS_STFIR;
178 rval &= ~MCS_MODE1;
179 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
180 if (unlikely(ret))
181 goto error;
182
183 rval &= ~MCS_MODE0;
184 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
185 if (unlikely(ret))
186 goto error;
187
188 rval &= ~MCS_XCVR_CONF;
189 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
190 if (unlikely(ret))
191 goto error;
192
193 ret = 0;
89473129
AK		 194error:
195 return ret;
c6ae522e
SO		 196}
197
198/* Setup a communication between mcs7780 and agilent chip. */
199static inline int mcs_setup_transceiver_agilent(struct mcs_cb *mcs)
200{
599b1fa9 201 IRDA_WARNING("This transceiver type is not supported yet.\n");
c6ae522e
SO		 202 return 1;
203}
204
205/* Setup a communication between mcs7780 and sharp chip. */
206static inline int mcs_setup_transceiver_sharp(struct mcs_cb *mcs)
207{
599b1fa9 208 IRDA_WARNING("This transceiver type is not supported yet.\n");
c6ae522e
SO		 209 return 1;
210}
211
212/* Common setup for all transceivers */
213static inline int mcs_setup_transceiver(struct mcs_cb *mcs)
214{
215 int ret = 0;
216 __u16 rval;
217 char *msg;
218
219 msg = "Basic transceiver setup error.";
220
221 /* read value of MODE Register, set the DRIVER and RESET bits
222 * and write value back out to MODE Register
223 */
224 ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
225 if(unlikely(ret != 2))
226 goto error;
227 rval |= MCS_DRIVER; /* put the mcs7780 into configuration mode. */
228 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
229 if(unlikely(ret))
230 goto error;
231
232 rval = 0; /* set min pulse width to 0 initially. */
233 ret = mcs_set_reg(mcs, MCS_MINRXPW_REG, rval);
234 if(unlikely(ret))
235 goto error;
236
237 ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
238 if(unlikely(ret != 2))
239 goto error;
240
241 rval &= ~MCS_FIR; /* turn off fir mode. */
242 if(mcs->sir_tweak)
243 rval |= MCS_SIR16US; /* 1.6us pulse width */
244 else
245 rval &= ~MCS_SIR16US; /* 3/16 bit time pulse width */
246
247 /* make sure ask mode and back to back packets are off. */
248 rval &= ~(MCS_BBTG | MCS_ASK);
249
250 rval &= ~MCS_SPEED_MASK;
251 rval |= MCS_SPEED_9600; /* make sure initial speed is 9600. */
252 mcs->speed = 9600;
253 mcs->new_speed = 0; /* new_speed is set to 0 */
254 rval &= ~MCS_PLLPWDN; /* disable power down. */
255
256 /* make sure device determines direction and that the auto send sip
257 * pulse are on.
258 */
259 rval |= MCS_DTD | MCS_SIPEN;
260
261 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
262 if(unlikely(ret))
263 goto error;
264
265 msg = "transceiver model specific setup error.";
266 switch (mcs->transceiver_type) {
267 case MCS_TSC_VISHAY:
268 ret = mcs_setup_transceiver_vishay(mcs);
269 break;
270
271 case MCS_TSC_SHARP:
272 ret = mcs_setup_transceiver_sharp(mcs);
273 break;
274
275 case MCS_TSC_AGILENT:
276 ret = mcs_setup_transceiver_agilent(mcs);
277 break;
278
279 default:
599b1fa9 280 IRDA_WARNING("Unknown transceiver type: %d\n",
c6ae522e
SO		 281 mcs->transceiver_type);
282 ret = 1;
283 }
284 if (unlikely(ret))
285 goto error;
286
287 /* If transceiver is not SHARP, then if receive mode set
288 * on the RXFAST bit in the XCVR Register otherwise unset it
289 */
290 if (mcs->transceiver_type != MCS_TSC_SHARP) {
291
292 ret = mcs_get_reg(mcs, MCS_XCVR_REG, &rval);
293 if (unlikely(ret != 2))
294 goto error;
295 if (mcs->receive_mode)
296 rval |= MCS_RXFAST;
297 else
298 rval &= ~MCS_RXFAST;
299 ret = mcs_set_reg(mcs, MCS_XCVR_REG, rval);
300 if (unlikely(ret))
301 goto error;
302 }
303
304 msg = "transceiver reset.";
305
306 ret = mcs_get_reg(mcs, MCS_MODE_REG, &rval);
307 if (unlikely(ret != 2))
308 goto error;
309
310 /* reset the mcs7780 so all changes take effect. */
311 rval &= ~MCS_RESET;
312 ret = mcs_set_reg(mcs, MCS_MODE_REG, rval);
313 if (unlikely(ret))
314 goto error;
315 else
316 return ret;
317
318error:
599b1fa9 319 IRDA_ERROR("%s\n", msg);
c6ae522e
SO		 320 return ret;
321}
322
323/* Wraps the data in format for SIR */
324static inline int mcs_wrap_sir_skb(struct sk_buff *skb, __u8 * buf)
325{
326 int wraplen;
327
328 /* 2: full frame length, including "the length" */
329 wraplen = async_wrap_skb(skb, buf + 2, 4094);
330
331 wraplen += 2;
332 buf[0] = wraplen & 0xff;
333 buf[1] = (wraplen >> 8) & 0xff;
334
335 return wraplen;
336}
337
338/* Wraps the data in format for FIR */
339static unsigned mcs_wrap_fir_skb(const struct sk_buff *skb, __u8 *buf)
340{
341 unsigned int len = 0;
342 __u32 fcs = ~(crc32_le(~0, skb->data, skb->len));
343
344 /* add 2 bytes for length value and 4 bytes for fcs. */
345 len = skb->len + 6;
346
347 /* The mcs7780 requires that the first two bytes are the packet
348 * length in little endian order. Note: the length value includes
349 * the two bytes for the length value itself.
350 */
351 buf[0] = len & 0xff;
352 buf[1] = (len >> 8) & 0xff;
353 /* copy the data into the tx buffer. */
d626f62b 354 skb_copy_from_linear_data(skb, buf + 2, skb->len);
c6ae522e
SO		 355 /* put the fcs in the last four bytes in little endian order. */
356 buf[len - 4] = fcs & 0xff;
357 buf[len - 3] = (fcs >> 8) & 0xff;
358 buf[len - 2] = (fcs >> 16) & 0xff;
359 buf[len - 1] = (fcs >> 24) & 0xff;
360
361 return len;
362}
363
364/* Wraps the data in format for MIR */
365static unsigned mcs_wrap_mir_skb(const struct sk_buff *skb, __u8 *buf)
366{
367 __u16 fcs = 0;
368 int len = skb->len + 4;
369
370 fcs = ~(irda_calc_crc16(~fcs, skb->data, skb->len));
371 /* put the total packet length in first. Note: packet length
372 * value includes the two bytes that hold the packet length
373 * itself.
374 */
375 buf[0] = len & 0xff;
376 buf[1] = (len >> 8) & 0xff;
377 /* copy the data */
d626f62b 378 skb_copy_from_linear_data(skb, buf + 2, skb->len);
c6ae522e
SO		 379 /* put the fcs in last two bytes in little endian order. */
380 buf[len - 2] = fcs & 0xff;
381 buf[len - 1] = (fcs >> 8) & 0xff;
382
383 return len;
384}
385
386/* Unwrap received packets at MIR speed. A 16 bit crc_ccitt checksum is
387 * used for the fcs. When performed over the entire packet the result
388 * should be GOOD_FCS = 0xf0b8. Hands the unwrapped data off to the IrDA
389 * layer via a sk_buff.
390 */
391static void mcs_unwrap_mir(struct mcs_cb *mcs, __u8 *buf, int len)
392{
393 __u16 fcs;
394 int new_len;
395 struct sk_buff *skb;
396
397 /* Assume that the frames are going to fill a single packet
398 * rather than span multiple packets.
399 */
400
401 new_len = len - 2;
402 if(unlikely(new_len <= 0)) {
403 IRDA_ERROR("%s short frame length %d\n",
404 mcs->netdev->name, new_len);
af049081
SH		 405 ++mcs->netdev->stats.rx_errors;
406 ++mcs->netdev->stats.rx_length_errors;
c6ae522e
SO		 407 return;
408 }
409 fcs = 0;
410 fcs = irda_calc_crc16(~fcs, buf, len);
411
412 if(fcs != GOOD_FCS) {
413 IRDA_ERROR("crc error calc 0x%x len %d\n",
414 fcs, new_len);
af049081
SH		 415 mcs->netdev->stats.rx_errors++;
416 mcs->netdev->stats.rx_crc_errors++;
c6ae522e
SO		 417 return;
418 }
419
420 skb = dev_alloc_skb(new_len + 1);
421 if(unlikely(!skb)) {
af049081 422 ++mcs->netdev->stats.rx_dropped;
c6ae522e
SO		 423 return;
424 }
425
426 skb_reserve(skb, 1);
27d7ff46 427 skb_copy_to_linear_data(skb, buf, new_len);
c6ae522e 428 skb_put(skb, new_len);
459a98ed 429 skb_reset_mac_header(skb);
c6ae522e
SO		 430 skb->protocol = htons(ETH_P_IRDA);
431 skb->dev = mcs->netdev;
432
433 netif_rx(skb);
434
af049081
SH		 435 mcs->netdev->stats.rx_packets++;
436 mcs->netdev->stats.rx_bytes += new_len;
c6ae522e
SO		 437}
438
439/* Unwrap received packets at FIR speed. A 32 bit crc_ccitt checksum is
440 * used for the fcs. Hands the unwrapped data off to the IrDA
441 * layer via a sk_buff.
442 */
443static void mcs_unwrap_fir(struct mcs_cb *mcs, __u8 *buf, int len)
444{
445 __u32 fcs;
446 int new_len;
447 struct sk_buff *skb;
448
449 /* Assume that the frames are going to fill a single packet
450 * rather than span multiple packets. This is most likely a false
451 * assumption.
452 */
453
454 new_len = len - 4;
455 if(unlikely(new_len <= 0)) {
456 IRDA_ERROR("%s short frame length %d\n",
457 mcs->netdev->name, new_len);
af049081
SH		 458 ++mcs->netdev->stats.rx_errors;
459 ++mcs->netdev->stats.rx_length_errors;
c6ae522e
SO		 460 return;
461 }
462
463 fcs = ~(crc32_le(~0, buf, new_len));
6caf52a4 464 if(fcs != get_unaligned_le32(buf + new_len)) {
c6ae522e 465 IRDA_ERROR("crc error calc 0x%x len %d\n", fcs, new_len);
af049081
SH		 466 mcs->netdev->stats.rx_errors++;
467 mcs->netdev->stats.rx_crc_errors++;
c6ae522e
SO		 468 return;
469 }
470
471 skb = dev_alloc_skb(new_len + 1);
472 if(unlikely(!skb)) {
af049081 473 ++mcs->netdev->stats.rx_dropped;
c6ae522e
SO		 474 return;
475 }
476
477 skb_reserve(skb, 1);
27d7ff46 478 skb_copy_to_linear_data(skb, buf, new_len);
c6ae522e 479 skb_put(skb, new_len);
459a98ed 480 skb_reset_mac_header(skb);
c6ae522e
SO		 481 skb->protocol = htons(ETH_P_IRDA);
482 skb->dev = mcs->netdev;
483
484 netif_rx(skb);
485
af049081
SH		 486 mcs->netdev->stats.rx_packets++;
487 mcs->netdev->stats.rx_bytes += new_len;
c6ae522e
SO		 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 */
495static 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);
89473129
AK		 504 if (!mcs->rx_urb) {
505 usb_free_urb(mcs->tx_urb);
506 mcs->tx_urb = NULL;
c6ae522e 507 return 0;
89473129 508 }
c6ae522e
SO		 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 */
517static 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 */
531static 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
c4028958 560static void mcs_speed_work(struct work_struct *work)
c6ae522e 561{
c4028958 562 struct mcs_cb *mcs = container_of(work, struct mcs_cb, work);
c6ae522e
SO		 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 */
572static 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
fb088674 586 if (cnt > 100) {
599b1fa9 587 IRDA_ERROR("unable to change speed\n");
c6ae522e
SO		 588 ret = -EIO;
589 goto error;
590 }
591
592 mcs_get_reg(mcs, MCS_MODE_REG, &rval);
593
25985edc 594 /* MINRXPW values recommended by MosChip */
c6ae522e
SO		 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;
599b1fa9 638 IRDA_WARNING("Unknown transceiver type: %d\n",
c6ae522e
SO		 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;
89473129
AK		 649error:
650 mcs->new_speed = 0;
651 return ret;
c6ae522e
SO		 652}
653
654/* Ioctl calls not supported at this time. Can be an area of future work. */
655static 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" */
670static 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
0ff80434
HK		 678 kfree_skb(mcs->rx_buff.skb);
679
c6ae522e
SO		 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" */
695static 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) {
599b1fa9 735 IRDA_ERROR("mcs7780: irlap_open failed\n");
c6ae522e
SO		 736 goto error2;
737 }
738
739 if (!mcs_setup_urbs(mcs))
9b0f1d85 740 goto error3;
c6ae522e
SO		 741
742 ret = mcs_receive_start(mcs);
743 if (ret)
89473129 744 goto error4;
c6ae522e
SO		 745
746 netif_start_queue(netdev);
747 return 0;
748
89473129
AK		 749error4:
750 usb_free_urb(mcs->rx_urb);
751 usb_free_urb(mcs->tx_urb);
752error3:
753 irlap_close(mcs->irlap);
754error2:
755 kfree_skb(mcs->rx_buff.skb);
756error1:
757 return ret;
c6ae522e
SO		 758}
759
c6ae522e 760/* Receive callback function. */
7d12e780 761static void mcs_receive_irq(struct urb *urb)
c6ae522e
SO		 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) {
af049081 782 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
c6ae522e
SO		 783 &mcs->rx_buff, 0xc0);
784
785 for (i = 0; i < urb->actual_length; i++)
af049081 786 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
c6ae522e
SO		 787 &mcs->rx_buff, bytes[i]);
788
af049081 789 async_unwrap_char(mcs->netdev, &mcs->netdev->stats,
c6ae522e
SO		 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 }
c6ae522e
SO		 802 do_gettimeofday(&mcs->rx_time);
803 }
804
805 ret = usb_submit_urb(urb, GFP_ATOMIC);
806}
807
25985edc 808/* Transmit callback function. */
7d12e780 809static void mcs_send_irq(struct urb *urb)
c6ae522e
SO		 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
25985edc 820/* Transmit callback function. */
6518bbb8
SH		 821static netdev_tx_t mcs_hard_xmit(struct sk_buff *skb,
822 struct net_device *ndev)
c6ae522e
SO		 823{
824 unsigned long flags;
825 struct mcs_cb *mcs;
826 int wraplen;
827 int ret = 0;
828
c6ae522e
SO		 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))) {
599b1fa9 855 IRDA_ERROR("failed tx_urb: %d\n", ret);
c6ae522e
SO		 856 switch (ret) {
857 case -ENODEV:
858 case -EPIPE:
859 break;
860 default:
af049081 861 mcs->netdev->stats.tx_errors++;
c6ae522e
SO		 862 netif_start_queue(ndev);
863 }
864 } else {
af049081
SH		 865 mcs->netdev->stats.tx_packets++;
866 mcs->netdev->stats.tx_bytes += skb->len;
c6ae522e
SO		 867 }
868
869 dev_kfree_skb(skb);
870 spin_unlock_irqrestore(&mcs->lock, flags);
4bd73ae2 871 return NETDEV_TX_OK;
c6ae522e
SO		 872}
873
ddc2a92d
SH		 874static 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
c6ae522e
SO		 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 */
885static 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
599b1fa9 897 IRDA_DEBUG(1, "MCS7780 USB-IrDA bridge found at %d.\n", udev->devnum);
c6ae522e 898
c6ae522e
SO		 899 SET_NETDEV_DEV(ndev, &intf->dev);
900
901 ret = usb_reset_configuration(udev);
902 if (ret != 0) {
599b1fa9 903 IRDA_ERROR("mcs7780: usb reset configuration failed\n");
c6ae522e
SO		 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*/
c4028958 925 INIT_WORK(&mcs->work, mcs_speed_work);
c6ae522e 926
ddc2a92d 927 ndev->netdev_ops = &mcs_netdev_ops;
c6ae522e 928
6734011f
PST		 929 if (!intf->cur_altsetting) {
930 ret = -ENOMEM;
c6ae522e 931 goto error2;
6734011f 932 }
c6ae522e
SO		 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
599b1fa9 945 IRDA_DEBUG(1, "IrDA: Registered MosChip MCS7780 device as %s\n",
c6ae522e
SO		 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
89473129
AK		 955error2:
956 free_netdev(ndev);
c6ae522e 957
89473129
AK		 958error1:
959 return ret;
c6ae522e
SO		 960}
961
962/* The current device is removed, the USB layer tells us to shut down. */
963static void mcs_disconnect(struct usb_interface *intf)
964{
965 struct mcs_cb *mcs = usb_get_intfdata(intf);
966
967 if (!mcs)
968 return;
969
23f333a2 970 cancel_work_sync(&mcs->work);
c6ae522e
SO		 971
972 unregister_netdev(mcs->netdev);
973 free_netdev(mcs->netdev);
974
975 usb_set_intfdata(intf, NULL);
599b1fa9 976 IRDA_DEBUG(0, "MCS7780 now disconnected.\n");
c6ae522e
SO		 977}
978
d632eb1b 979module_usb_driver(mcs_driver);
Ubuntu Eoan Linux kernel mirror