← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/net/irda/stir4200.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/irda/stir4200.c
 
1
/*****************************************************************************
 
2
*
 
3
* Filename:      stir4200.c
 
4
* Version:       0.4
 
5
* Description:   Irda SigmaTel USB Dongle
 
6
* Status:        Experimental
 
7
* Author:        Stephen Hemminger <shemminger@osdl.org>
 
8
*
 
9
*       Based on earlier driver by Paul Stewart <stewart@parc.com>
 
10
*
 
11
*       Copyright (C) 2000, Roman Weissgaerber <weissg@vienna.at>
 
12
*       Copyright (C) 2001, Dag Brattli <dag@brattli.net>
 
13
*       Copyright (C) 2001, Jean Tourrilhes <jt@hpl.hp.com>
 
14
*       Copyright (C) 2004, Stephen Hemminger <shemminger@osdl.org>
 
15
*
 
16
*       This program is free software; you can redistribute it and/or modify
 
17
*       it under the terms of the GNU General Public License as published by
 
18
*       the Free Software Foundation; either version 2 of the License.
 
19
*
 
20
*       This program is distributed in the hope that it will be useful,
 
21
*       but WITHOUT ANY WARRANTY; without even the implied warranty of
 
22
*       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
23
*       GNU General Public License for more details.
 
24
*
 
25
*       You should have received a copy of the GNU General Public License
 
26
*       along with this program; if not, write to the Free Software
 
27
*       Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
28
*
 
29
*****************************************************************************/
 
30
 
 
31
/*
 
32
 * This dongle does no framing, and requires polling to receive the
 
33
 * data.  The STIr4200 has bulk in and out endpoints just like
 
34
 * usr-irda devices, but the data it sends and receives is raw; like
 
35
 * irtty, it needs to call the wrap and unwrap functions to add and
 
36
 * remove SOF/BOF and escape characters to/from the frame.
 
37
 */
 
38
 
 
39
#include <linux/module.h>
 
40
#include <linux/moduleparam.h>
 
41
 
 
42
#include <linux/kernel.h>
 
43
#include <linux/types.h>
 
44
#include <linux/init.h>
 
45
#include <linux/time.h>
 
46
#include <linux/skbuff.h>
 
47
#include <linux/netdevice.h>
 
48
#include <linux/slab.h>
 
49
#include <linux/delay.h>
 
50
#include <linux/usb.h>
 
51
#include <linux/crc32.h>
 
52
#include <linux/kthread.h>
 
53
#include <linux/freezer.h>
 
54
#include <net/irda/irda.h>
 
55
#include <net/irda/irda_device.h>
 
56
#include <net/irda/wrapper.h>
 
57
#include <net/irda/crc.h>
 
58
#include <asm/byteorder.h>
 
59
#include <asm/unaligned.h>
 
60
 
 
61
MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
 
62
MODULE_DESCRIPTION("IrDA-USB Dongle Driver for SigmaTel STIr4200");
 
63
MODULE_LICENSE("GPL");
 
64
 
 
65
static int qos_mtt_bits = 0x07; /* 1 ms or more */
 
66
module_param(qos_mtt_bits, int, 0);
 
67
MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time");
 
68
 
 
69
static int rx_sensitivity = 1;  /* FIR 0..4, SIR 0..6 */
 
70
module_param(rx_sensitivity, int, 0);
 
71
MODULE_PARM_DESC(rx_sensitivity, "Set Receiver sensitivity (0-6, 0 is most sensitive)");
 
72
 
 
73
static int tx_power = 0;        /* 0 = highest ... 3 = lowest */
 
74
module_param(tx_power, int, 0);
 
75
MODULE_PARM_DESC(tx_power, "Set Transmitter power (0-3, 0 is highest power)");
 
76
 
 
77
#define STIR_IRDA_HEADER        4
 
78
#define CTRL_TIMEOUT            100        /* milliseconds */
 
79
#define TRANSMIT_TIMEOUT        200        /* milliseconds */
 
80
#define STIR_FIFO_SIZE          4096
 
81
#define FIFO_REGS_SIZE          3
 
82
 
 
83
enum FirChars {
 
84
        FIR_CE   = 0x7d,
 
85
        FIR_XBOF = 0x7f,
 
86
        FIR_EOF  = 0x7e,
 
87
};
 
88
 
 
89
enum StirRequests {
 
90
        REQ_WRITE_REG =         0x00,
 
91
        REQ_READ_REG =          0x01,
 
92
        REQ_READ_ROM =          0x02,
 
93
        REQ_WRITE_SINGLE =      0x03,
 
94
};
 
95
 
 
96
/* Register offsets */
 
97
enum StirRegs {
 
98
        REG_RSVD=0,
 
99
        REG_MODE,
 
100
        REG_PDCLK,
 
101
        REG_CTRL1,
 
102
        REG_CTRL2,
 
103
        REG_FIFOCTL,
 
104
        REG_FIFOLSB,
 
105
        REG_FIFOMSB,
 
106
        REG_DPLL,
 
107
        REG_IRDIG,
 
108
        REG_TEST=15,
 
109
};
 
110
 
 
111
enum StirModeMask {
 
112
        MODE_FIR = 0x80,
 
113
        MODE_SIR = 0x20,
 
114
        MODE_ASK = 0x10,
 
115
        MODE_FASTRX = 0x08,
 
116
        MODE_FFRSTEN = 0x04,
 
117
        MODE_NRESET = 0x02,
 
118
        MODE_2400 = 0x01,
 
119
};
 
120
 
 
121
enum StirPdclkMask {
 
122
        PDCLK_4000000 = 0x02,
 
123
        PDCLK_115200 = 0x09,
 
124
        PDCLK_57600 = 0x13,
 
125
        PDCLK_38400 = 0x1D,
 
126
        PDCLK_19200 = 0x3B,
 
127
        PDCLK_9600 = 0x77,
 
128
        PDCLK_2400 = 0xDF,
 
129
};
 
130
 
 
131
enum StirCtrl1Mask {
 
132
        CTRL1_SDMODE = 0x80,
 
133
        CTRL1_RXSLOW = 0x40,
 
134
        CTRL1_TXPWD = 0x10,
 
135
        CTRL1_RXPWD = 0x08,
 
136
        CTRL1_SRESET = 0x01,
 
137
};
 
138
 
 
139
enum StirCtrl2Mask {
 
140
        CTRL2_SPWIDTH = 0x08,
 
141
        CTRL2_REVID = 0x03,
 
142
};
 
143
 
 
144
enum StirFifoCtlMask {
 
145
        FIFOCTL_DIR = 0x10,
 
146
        FIFOCTL_CLR = 0x08,
 
147
        FIFOCTL_EMPTY = 0x04,
 
148
};
 
149
 
 
150
enum StirDiagMask {
 
151
        IRDIG_RXHIGH = 0x80,
 
152
        IRDIG_RXLOW = 0x40,
 
153
};
 
154
 
 
155
enum StirTestMask {
 
156
        TEST_PLLDOWN = 0x80,
 
157
        TEST_LOOPIR = 0x40,
 
158
        TEST_LOOPUSB = 0x20,
 
159
        TEST_TSTENA = 0x10,
 
160
        TEST_TSTOSC = 0x0F,
 
161
};
 
162
 
 
163
struct stir_cb {
 
164
        struct usb_device *usbdev;      /* init: probe_irda */
 
165
        struct net_device *netdev;      /* network layer */
 
166
        struct irlap_cb   *irlap;       /* The link layer we are binded to */
 
167
 
 
168
        struct qos_info   qos;
 
169
        unsigned          speed;        /* Current speed */
 
170
 
 
171
        struct task_struct *thread;     /* transmit thread */
 
172
 
 
173
        struct sk_buff    *tx_pending;
 
174
        void              *io_buf;      /* transmit/receive buffer */
 
175
        __u8              *fifo_status;
 
176
 
 
177
        iobuff_t          rx_buff;      /* receive unwrap state machine */
 
178
        struct timeval    rx_time;
 
179
        int               receiving;
 
180
        struct urb       *rx_urb;
 
181
};
 
182
 
 
183
 
 
184
/* These are the currently known USB ids */
 
185
static struct usb_device_id dongles[] = {
 
186
    /* SigmaTel, Inc,  STIr4200 IrDA/USB Bridge */
 
187
    { USB_DEVICE(0x066f, 0x4200) },
 
188
    { }
 
189
};
 
190
 
 
191
MODULE_DEVICE_TABLE(usb, dongles);
 
192
 
 
193
/* Send control message to set dongle register */
 
194
static int write_reg(struct stir_cb *stir, __u16 reg, __u8 value)
 
195
{
 
196
        struct usb_device *dev = stir->usbdev;
 
197
 
 
198
        pr_debug("%s: write reg %d = 0x%x\n",
 
199
                 stir->netdev->name, reg, value);
 
200
        return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 
201
                               REQ_WRITE_SINGLE,
 
202
                               USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE,
 
203
                               value, reg, NULL, 0,
 
204
                               CTRL_TIMEOUT);
 
205
}
 
206
 
 
207
/* Send control message to read multiple registers */
 
208
static inline int read_reg(struct stir_cb *stir, __u16 reg,
 
209
                    __u8 *data, __u16 count)
 
210
{
 
211
        struct usb_device *dev = stir->usbdev;
 
212
 
 
213
        return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 
214
                               REQ_READ_REG,
 
215
                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 
216
                               0, reg, data, count,
 
217
                               CTRL_TIMEOUT);
 
218
}
 
219
 
 
220
static inline int isfir(u32 speed)
 
221
{
 
222
        return speed == 4000000;
 
223
}
 
224
 
 
225
/*
 
226
 * Prepare a FIR IrDA frame for transmission to the USB dongle.  The
 
227
 * FIR transmit frame is documented in the datasheet.  It consists of
 
228
 * a two byte 0x55 0xAA sequence, two little-endian length bytes, a
 
229
 * sequence of exactly 16 XBOF bytes of 0x7E, two BOF bytes of 0x7E,
 
230
 * then the data escaped as follows:
 
231
 *
 
232
 *    0x7D -> 0x7D 0x5D
 
233
 *    0x7E -> 0x7D 0x5E
 
234
 *    0x7F -> 0x7D 0x5F
 
235
 *
 
236
 * Then, 4 bytes of little endian (stuffed) FCS follow, then two
 
237
 * trailing EOF bytes of 0x7E.
 
238
 */
 
239
static inline __u8 *stuff_fir(__u8 *p, __u8 c)
 
240
{
 
241
        switch(c) {
 
242
        case 0x7d:
 
243
        case 0x7e:
 
244
        case 0x7f:
 
245
                *p++ = 0x7d;
 
246
                c ^= IRDA_TRANS;
 
247
                /* fall through */
 
248
        default:
 
249
                *p++ = c;
 
250
        }
 
251
        return p;
 
252
}
 
253
 
 
254
/* Take raw data in skb and put it wrapped into buf */
 
255
static unsigned wrap_fir_skb(const struct sk_buff *skb, __u8 *buf)
 
256
{
 
257
        __u8 *ptr = buf;
 
258
        __u32 fcs = ~(crc32_le(~0, skb->data, skb->len));
 
259
        __u16 wraplen;
 
260
        int i;
 
261
 
 
262
        /* Header */
 
263
        buf[0] = 0x55;
 
264
        buf[1] = 0xAA;
 
265
 
 
266
        ptr = buf + STIR_IRDA_HEADER;
 
267
        memset(ptr, 0x7f, 16);
 
268
        ptr += 16;
 
269
 
 
270
        /* BOF */
 
271
        *ptr++  = 0x7e;
 
272
        *ptr++  = 0x7e;
 
273
 
 
274
        /* Address / Control / Information */
 
275
        for (i = 0; i < skb->len; i++)
 
276
                ptr = stuff_fir(ptr, skb->data[i]);
 
277
 
 
278
        /* FCS */
 
279
        ptr = stuff_fir(ptr, fcs & 0xff);
 
280
        ptr = stuff_fir(ptr, (fcs >> 8) & 0xff);
 
281
        ptr = stuff_fir(ptr, (fcs >> 16) & 0xff);
 
282
        ptr = stuff_fir(ptr, (fcs >> 24) & 0xff);
 
283
 
 
284
        /* EOFs */
 
285
        *ptr++ = 0x7e;
 
286
        *ptr++ = 0x7e;
 
287
 
 
288
        /* Total length, minus the header */
 
289
        wraplen = (ptr - buf) - STIR_IRDA_HEADER;
 
290
        buf[2] = wraplen & 0xff;
 
291
        buf[3] = (wraplen >> 8) & 0xff;
 
292
 
 
293
        return wraplen + STIR_IRDA_HEADER;
 
294
}
 
295
 
 
296
static unsigned wrap_sir_skb(struct sk_buff *skb, __u8 *buf)
 
297
{
 
298
        __u16 wraplen;
 
299
 
 
300
        wraplen = async_wrap_skb(skb, buf + STIR_IRDA_HEADER,
 
301
                                 STIR_FIFO_SIZE - STIR_IRDA_HEADER);
 
302
        buf[0] = 0x55;
 
303
        buf[1] = 0xAA;
 
304
        buf[2] = wraplen & 0xff;
 
305
        buf[3] = (wraplen >> 8) & 0xff;
 
306
 
 
307
        return wraplen + STIR_IRDA_HEADER;
 
308
}
 
309
 
 
310
/*
 
311
 * Frame is fully formed in the rx_buff so check crc
 
312
 * and pass up to irlap
 
313
 * setup for next receive
 
314
 */
 
315
static void fir_eof(struct stir_cb *stir)
 
316
{
 
317
        iobuff_t *rx_buff = &stir->rx_buff;
 
318
        int len = rx_buff->len - 4;
 
319
        struct sk_buff *skb, *nskb;
 
320
        __u32 fcs;
 
321
 
 
322
        if (unlikely(len <= 0)) {
 
323
                pr_debug("%s: short frame len %d\n",
 
324
                         stir->netdev->name, len);
 
325
 
 
326
                ++stir->netdev->stats.rx_errors;
 
327
                ++stir->netdev->stats.rx_length_errors;
 
328
                return;
 
329
        }
 
330
 
 
331
        fcs = ~(crc32_le(~0, rx_buff->data, len));
 
332
        if (fcs != get_unaligned_le32(rx_buff->data + len)) {
 
333
                pr_debug("crc error calc 0x%x len %d\n", fcs, len);
 
334
                stir->netdev->stats.rx_errors++;
 
335
                stir->netdev->stats.rx_crc_errors++;
 
336
                return;
 
337
        }
 
338
 
 
339
        /* if frame is short then just copy it */
 
340
        if (len < IRDA_RX_COPY_THRESHOLD) {
 
341
                nskb = dev_alloc_skb(len + 1);
 
342
                if (unlikely(!nskb)) {
 
343
                        ++stir->netdev->stats.rx_dropped;
 
344
                        return;
 
345
                }
 
346
                skb_reserve(nskb, 1);
 
347
                skb = nskb;
 
348
                skb_copy_to_linear_data(nskb, rx_buff->data, len);
 
349
        } else {
 
350
                nskb = dev_alloc_skb(rx_buff->truesize);
 
351
                if (unlikely(!nskb)) {
 
352
                        ++stir->netdev->stats.rx_dropped;
 
353
                        return;
 
354
                }
 
355
                skb_reserve(nskb, 1);
 
356
                skb = rx_buff->skb;
 
357
                rx_buff->skb = nskb;
 
358
                rx_buff->head = nskb->data;
 
359
        }
 
360
 
 
361
        skb_put(skb, len);
 
362
 
 
363
        skb_reset_mac_header(skb);
 
364
        skb->protocol = htons(ETH_P_IRDA);
 
365
        skb->dev = stir->netdev;
 
366
 
 
367
        netif_rx(skb);
 
368
 
 
369
        stir->netdev->stats.rx_packets++;
 
370
        stir->netdev->stats.rx_bytes += len;
 
371
 
 
372
        rx_buff->data = rx_buff->head;
 
373
        rx_buff->len = 0;
 
374
}
 
375
 
 
376
/* Unwrap FIR stuffed data and bump it to IrLAP */
 
377
static void stir_fir_chars(struct stir_cb *stir,
 
378
                            const __u8 *bytes, int len)
 
379
{
 
380
        iobuff_t *rx_buff = &stir->rx_buff;
 
381
        int     i;
 
382
 
 
383
        for (i = 0; i < len; i++) {
 
384
                __u8    byte = bytes[i];
 
385
 
 
386
                switch(rx_buff->state) {
 
387
                case OUTSIDE_FRAME:
 
388
                        /* ignore garbage till start of frame */
 
389
                        if (unlikely(byte != FIR_EOF))
 
390
                                continue;
 
391
                        /* Now receiving frame */
 
392
                        rx_buff->state = BEGIN_FRAME;
 
393
 
 
394
                        /* Time to initialize receive buffer */
 
395
                        rx_buff->data = rx_buff->head;
 
396
                        rx_buff->len = 0;
 
397
                        continue;
 
398
 
 
399
                case LINK_ESCAPE:
 
400
                        if (byte == FIR_EOF) {
 
401
                                pr_debug("%s: got EOF after escape\n",
 
402
                                         stir->netdev->name);
 
403
                                goto frame_error;
 
404
                        }
 
405
                        rx_buff->state = INSIDE_FRAME;
 
406
                        byte ^= IRDA_TRANS;
 
407
                        break;
 
408
 
 
409
                case BEGIN_FRAME:
 
410
                        /* ignore multiple BOF/EOF */
 
411
                        if (byte == FIR_EOF)
 
412
                                continue;
 
413
                        rx_buff->state = INSIDE_FRAME;
 
414
                        rx_buff->in_frame = TRUE;
 
415
 
 
416
                        /* fall through */
 
417
                case INSIDE_FRAME:
 
418
                        switch(byte) {
 
419
                        case FIR_CE:
 
420
                                rx_buff->state = LINK_ESCAPE;
 
421
                                continue;
 
422
                        case FIR_XBOF:
 
423
                                /* 0x7f is not used in this framing */
 
424
                                pr_debug("%s: got XBOF without escape\n",
 
425
                                         stir->netdev->name);
 
426
                                goto frame_error;
 
427
                        case FIR_EOF:
 
428
                                rx_buff->state = OUTSIDE_FRAME;
 
429
                                rx_buff->in_frame = FALSE;
 
430
                                fir_eof(stir);
 
431
                                continue;
 
432
                        }
 
433
                        break;
 
434
                }
 
435
 
 
436
                /* add byte to rx buffer */
 
437
                if (unlikely(rx_buff->len >= rx_buff->truesize)) {
 
438
                        pr_debug("%s: fir frame exceeds %d\n",
 
439
                                 stir->netdev->name, rx_buff->truesize);
 
440
                        ++stir->netdev->stats.rx_over_errors;
 
441
                        goto error_recovery;
 
442
                }
 
443
 
 
444
                rx_buff->data[rx_buff->len++] = byte;
 
445
                continue;
 
446
 
 
447
        frame_error:
 
448
                ++stir->netdev->stats.rx_frame_errors;
 
449
 
 
450
        error_recovery:
 
451
                ++stir->netdev->stats.rx_errors;
 
452
                rx_buff->state = OUTSIDE_FRAME;
 
453
                rx_buff->in_frame = FALSE;
 
454
        }
 
455
}
 
456
 
 
457
/* Unwrap SIR stuffed data and bump it up to IrLAP */
 
458
static void stir_sir_chars(struct stir_cb *stir,
 
459
                            const __u8 *bytes, int len)
 
460
{
 
461
        int i;
 
462
 
 
463
        for (i = 0; i < len; i++)
 
464
                async_unwrap_char(stir->netdev, &stir->netdev->stats,
 
465
                                  &stir->rx_buff, bytes[i]);
 
466
}
 
467
 
 
468
static inline void unwrap_chars(struct stir_cb *stir,
 
469
                                const __u8 *bytes, int length)
 
470
{
 
471
        if (isfir(stir->speed))
 
472
                stir_fir_chars(stir, bytes, length);
 
473
        else
 
474
                stir_sir_chars(stir, bytes, length);
 
475
}
 
476
 
 
477
/* Mode parameters for each speed */
 
478
static const struct {
 
479
        unsigned speed;
 
480
        __u8 pdclk;
 
481
} stir_modes[] = {
 
482
        { 2400,    PDCLK_2400 },
 
483
        { 9600,    PDCLK_9600 },
 
484
        { 19200,   PDCLK_19200 },
 
485
        { 38400,   PDCLK_38400 },
 
486
        { 57600,   PDCLK_57600 },
 
487
        { 115200,  PDCLK_115200 },
 
488
        { 4000000, PDCLK_4000000 },
 
489
};
 
490
 
 
491
 
 
492
/*
 
493
 * Setup chip for speed.
 
494
 *  Called at startup to initialize the chip
 
495
 *  and on speed changes.
 
496
 *
 
497
 * Note: Write multiple registers doesn't appear to work
 
498
 */
 
499
static int change_speed(struct stir_cb *stir, unsigned speed)
 
500
{
 
501
        int i, err;
 
502
        __u8 mode;
 
503
 
 
504
        for (i = 0; i < ARRAY_SIZE(stir_modes); ++i) {
 
505
                if (speed == stir_modes[i].speed)
 
506
                        goto found;
 
507
        }
 
508
 
 
509
        dev_warn(&stir->netdev->dev, "invalid speed %d\n", speed);
 
510
        return -EINVAL;
 
511
 
 
512
 found:
 
513
        pr_debug("speed change from %d to %d\n", stir->speed, speed);
 
514
 
 
515
        /* Reset modulator */
 
516
        err = write_reg(stir, REG_CTRL1, CTRL1_SRESET);
 
517
        if (err)
 
518
                goto out;
 
519
 
 
520
        /* Undocumented magic to tweak the DPLL */
 
521
        err = write_reg(stir, REG_DPLL, 0x15);
 
522
        if (err)
 
523
                goto out;
 
524
 
 
525
        /* Set clock */
 
526
        err = write_reg(stir, REG_PDCLK, stir_modes[i].pdclk);
 
527
        if (err)
 
528
                goto out;
 
529
 
 
530
        mode = MODE_NRESET | MODE_FASTRX;
 
531
        if (isfir(speed))
 
532
                mode |= MODE_FIR | MODE_FFRSTEN;
 
533
        else
 
534
                mode |= MODE_SIR;
 
535
 
 
536
        if (speed == 2400)
 
537
                mode |= MODE_2400;
 
538
 
 
539
        err = write_reg(stir, REG_MODE, mode);
 
540
        if (err)
 
541
                goto out;
 
542
 
 
543
        /* This resets TEMIC style transceiver if any. */
 
544
        err = write_reg(stir, REG_CTRL1,
 
545
                        CTRL1_SDMODE | (tx_power & 3) << 1);
 
546
        if (err)
 
547
                goto out;
 
548
 
 
549
        err = write_reg(stir, REG_CTRL1, (tx_power & 3) << 1);
 
550
        if (err)
 
551
                goto out;
 
552
 
 
553
        /* Reset sensitivity */
 
554
        err = write_reg(stir, REG_CTRL2, (rx_sensitivity & 7) << 5);
 
555
 out:
 
556
        stir->speed = speed;
 
557
        return err;
 
558
}
 
559
 
 
560
/*
 
561
 * Called from net/core when new frame is available.
 
562
 */
 
563
static netdev_tx_t stir_hard_xmit(struct sk_buff *skb,
 
564
                                        struct net_device *netdev)
 
565
{
 
566
        struct stir_cb *stir = netdev_priv(netdev);
 
567
 
 
568
        netif_stop_queue(netdev);
 
569
 
 
570
        /* the IRDA wrapping routines don't deal with non linear skb */
 
571
        SKB_LINEAR_ASSERT(skb);
 
572
 
 
573
        skb = xchg(&stir->tx_pending, skb);
 
574
        wake_up_process(stir->thread);
 
575
        
 
576
        /* this should never happen unless stop/wakeup problem */
 
577
        if (unlikely(skb)) {
 
578
                WARN_ON(1);
 
579
                dev_kfree_skb(skb);
 
580
        }
 
581
 
 
582
        return NETDEV_TX_OK;
 
583
}
 
584
 
 
585
/*
 
586
 * Wait for the transmit FIFO to have space for next data
 
587
 *
 
588
 * If space < 0 then wait till FIFO completely drains.
 
589
 * FYI: can take up to 13 seconds at 2400baud.
 
590
 */
 
591
static int fifo_txwait(struct stir_cb *stir, int space)
 
592
{
 
593
        int err;
 
594
        unsigned long count, status;
 
595
        unsigned long prev_count = 0x1fff;
 
596
 
 
597
        /* Read FIFO status and count */
 
598
        for (;; prev_count = count) {
 
599
                err = read_reg(stir, REG_FIFOCTL, stir->fifo_status, 
 
600
                                   FIFO_REGS_SIZE);
 
601
                if (unlikely(err != FIFO_REGS_SIZE)) {
 
602
                        dev_warn(&stir->netdev->dev,
 
603
                                 "FIFO register read error: %d\n", err);
 
604
 
 
605
                        return err;
 
606
                }
 
607
 
 
608
                status = stir->fifo_status[0];
 
609
                count = (unsigned)(stir->fifo_status[2] & 0x1f) << 8 
 
610
                        | stir->fifo_status[1];
 
611
 
 
612
                pr_debug("fifo status 0x%lx count %lu\n", status, count);
 
613
 
 
614
                /* is fifo receiving already, or empty */
 
615
                if (!(status & FIFOCTL_DIR) ||
 
616
                    (status & FIFOCTL_EMPTY))
 
617
                        return 0;
 
618
 
 
619
                if (signal_pending(current))
 
620
                        return -EINTR;
 
621
 
 
622
                /* shutting down? */
 
623
                if (!netif_running(stir->netdev) ||
 
624
                    !netif_device_present(stir->netdev))
 
625
                        return -ESHUTDOWN;
 
626
 
 
627
                /* only waiting for some space */
 
628
                if (space >= 0 && STIR_FIFO_SIZE - 4 > space + count)
 
629
                        return 0;
 
630
 
 
631
                /* queue confused */
 
632
                if (prev_count < count)
 
633
                        break;
 
634
 
 
635
                /* estimate transfer time for remaining chars */
 
636
                msleep((count * 8000) / stir->speed);
 
637
        }
 
638
                        
 
639
        err = write_reg(stir, REG_FIFOCTL, FIFOCTL_CLR);
 
640
        if (err) 
 
641
                return err;
 
642
        err = write_reg(stir, REG_FIFOCTL, 0);
 
643
        if (err)
 
644
                return err;
 
645
 
 
646
        return 0;
 
647
}
 
648
 
 
649
 
 
650
/* Wait for turnaround delay before starting transmit.  */
 
651
static void turnaround_delay(const struct stir_cb *stir, long us)
 
652
{
 
653
        long ticks;
 
654
        struct timeval now;
 
655
 
 
656
        if (us <= 0)
 
657
                return;
 
658
 
 
659
        do_gettimeofday(&now);
 
660
        if (now.tv_sec - stir->rx_time.tv_sec > 0)
 
661
                us -= USEC_PER_SEC;
 
662
        us -= now.tv_usec - stir->rx_time.tv_usec;
 
663
        if (us < 10)
 
664
                return;
 
665
 
 
666
        ticks = us / (1000000 / HZ);
 
667
        if (ticks > 0)
 
668
                schedule_timeout_interruptible(1 + ticks);
 
669
        else
 
670
                udelay(us);
 
671
}
 
672
 
 
673
/*
 
674
 * Start receiver by submitting a request to the receive pipe.
 
675
 * If nothing is available it will return after rx_interval.
 
676
 */
 
677
static int receive_start(struct stir_cb *stir)
 
678
{
 
679
        /* reset state */
 
680
        stir->receiving = 1;
 
681
 
 
682
        stir->rx_buff.in_frame = FALSE;
 
683
        stir->rx_buff.state = OUTSIDE_FRAME;
 
684
 
 
685
        stir->rx_urb->status = 0;
 
686
        return usb_submit_urb(stir->rx_urb, GFP_KERNEL);
 
687
}
 
688
 
 
689
/* Stop all pending receive Urb's */
 
690
static void receive_stop(struct stir_cb *stir)
 
691
{
 
692
        stir->receiving = 0;
 
693
        usb_kill_urb(stir->rx_urb);
 
694
 
 
695
        if (stir->rx_buff.in_frame) 
 
696
                stir->netdev->stats.collisions++;
 
697
}
 
698
/*
 
699
 * Wrap data in socket buffer and send it.
 
700
 */
 
701
static void stir_send(struct stir_cb *stir, struct sk_buff *skb)
 
702
{
 
703
        unsigned wraplen;
 
704
        int first_frame = 0;
 
705
 
 
706
        /* if receiving, need to turnaround */
 
707
        if (stir->receiving) {
 
708
                receive_stop(stir);
 
709
                turnaround_delay(stir, irda_get_mtt(skb));
 
710
                first_frame = 1;
 
711
        }
 
712
 
 
713
        if (isfir(stir->speed))
 
714
                wraplen = wrap_fir_skb(skb, stir->io_buf);
 
715
        else
 
716
                wraplen = wrap_sir_skb(skb, stir->io_buf);
 
717
                
 
718
        /* check for space available in fifo */
 
719
        if (!first_frame)
 
720
                fifo_txwait(stir, wraplen);
 
721
 
 
722
        stir->netdev->stats.tx_packets++;
 
723
        stir->netdev->stats.tx_bytes += skb->len;
 
724
        stir->netdev->trans_start = jiffies;
 
725
        pr_debug("send %d (%d)\n", skb->len, wraplen);
 
726
 
 
727
        if (usb_bulk_msg(stir->usbdev, usb_sndbulkpipe(stir->usbdev, 1),
 
728
                         stir->io_buf, wraplen,
 
729
                         NULL, TRANSMIT_TIMEOUT))
 
730
                stir->netdev->stats.tx_errors++;
 
731
}
 
732
 
 
733
/*
 
734
 * Transmit state machine thread
 
735
 */
 
736
static int stir_transmit_thread(void *arg)
 
737
{
 
738
        struct stir_cb *stir = arg;
 
739
        struct net_device *dev = stir->netdev;
 
740
        struct sk_buff *skb;
 
741
 
 
742
        while (!kthread_should_stop()) {
 
743
#ifdef CONFIG_PM
 
744
                /* if suspending, then power off and wait */
 
745
                if (unlikely(freezing(current))) {
 
746
                        if (stir->receiving)
 
747
                                receive_stop(stir);
 
748
                        else
 
749
                                fifo_txwait(stir, -1);
 
750
 
 
751
                        write_reg(stir, REG_CTRL1, CTRL1_TXPWD|CTRL1_RXPWD);
 
752
 
 
753
                        refrigerator();
 
754
 
 
755
                        if (change_speed(stir, stir->speed))
 
756
                                break;
 
757
                }
 
758
#endif
 
759
 
 
760
                /* if something to send? */
 
761
                skb = xchg(&stir->tx_pending, NULL);
 
762
                if (skb) {
 
763
                        unsigned new_speed = irda_get_next_speed(skb);
 
764
                        netif_wake_queue(dev);
 
765
 
 
766
                        if (skb->len > 0)
 
767
                                stir_send(stir, skb);
 
768
                        dev_kfree_skb(skb);
 
769
 
 
770
                        if ((new_speed != -1) && (stir->speed != new_speed)) {
 
771
                                if (fifo_txwait(stir, -1) ||
 
772
                                    change_speed(stir, new_speed))
 
773
                                        break;
 
774
                        }
 
775
                        continue;
 
776
                }
 
777
 
 
778
                /* nothing to send? start receiving */
 
779
                if (!stir->receiving &&
 
780
                    irda_device_txqueue_empty(dev)) {
 
781
                        /* Wait otherwise chip gets confused. */
 
782
                        if (fifo_txwait(stir, -1))
 
783
                                break;
 
784
 
 
785
                        if (unlikely(receive_start(stir))) {
 
786
                                if (net_ratelimit())
 
787
                                        dev_info(&dev->dev,
 
788
                                                 "%s: receive usb submit failed\n",
 
789
                                                 stir->netdev->name);
 
790
                                stir->receiving = 0;
 
791
                                msleep(10);
 
792
                                continue;
 
793
                        }
 
794
                }
 
795
 
 
796
                /* sleep if nothing to send */
 
797
                set_current_state(TASK_INTERRUPTIBLE);
 
798
                schedule();
 
799
 
 
800
        }
 
801
        return 0;
 
802
}
 
803
 
 
804
 
 
805
/*
 
806
 * USB bulk receive completion callback.
 
807
 * Wakes up every ms (usb round trip) with wrapped 
 
808
 * data.
 
809
 */
 
810
static void stir_rcv_irq(struct urb *urb)
 
811
{
 
812
        struct stir_cb *stir = urb->context;
 
813
        int err;
 
814
 
 
815
        /* in process of stopping, just drop data */
 
816
        if (!netif_running(stir->netdev))
 
817
                return;
 
818
 
 
819
        /* unlink, shutdown, unplug, other nasties */
 
820
        if (urb->status != 0) 
 
821
                return;
 
822
 
 
823
        if (urb->actual_length > 0) {
 
824
                pr_debug("receive %d\n", urb->actual_length);
 
825
                unwrap_chars(stir, urb->transfer_buffer,
 
826
                             urb->actual_length);
 
827
                
 
828
                do_gettimeofday(&stir->rx_time);
 
829
        }
 
830
 
 
831
        /* kernel thread is stopping receiver don't resubmit */
 
832
        if (!stir->receiving)
 
833
                return;
 
834
 
 
835
        /* resubmit existing urb */
 
836
        err = usb_submit_urb(urb, GFP_ATOMIC);
 
837
 
 
838
        /* in case of error, the kernel thread will restart us */
 
839
        if (err) {
 
840
                dev_warn(&stir->netdev->dev, "usb receive submit error: %d\n",
 
841
                         err);
 
842
                stir->receiving = 0;
 
843
                wake_up_process(stir->thread);
 
844
        }
 
845
}
 
846
 
 
847
/*
 
848
 * Function stir_net_open (dev)
 
849
 *
 
850
 *    Network device is taken up. Usually this is done by "ifconfig irda0 up"
 
851
 */
 
852
static int stir_net_open(struct net_device *netdev)
 
853
{
 
854
        struct stir_cb *stir = netdev_priv(netdev);
 
855
        int err;
 
856
        char hwname[16];
 
857
 
 
858
        err = usb_clear_halt(stir->usbdev, usb_sndbulkpipe(stir->usbdev, 1));
 
859
        if (err)
 
860
                goto err_out1;
 
861
        err = usb_clear_halt(stir->usbdev, usb_rcvbulkpipe(stir->usbdev, 2));
 
862
        if (err)
 
863
                goto err_out1;
 
864
 
 
865
        err = change_speed(stir, 9600);
 
866
        if (err)
 
867
                goto err_out1;
 
868
 
 
869
        err = -ENOMEM;
 
870
 
 
871
        /* Initialize for SIR/FIR to copy data directly into skb.  */
 
872
        stir->receiving = 0;
 
873
        stir->rx_buff.truesize = IRDA_SKB_MAX_MTU;
 
874
        stir->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
 
875
        if (!stir->rx_buff.skb) 
 
876
                goto err_out1;
 
877
 
 
878
        skb_reserve(stir->rx_buff.skb, 1);
 
879
        stir->rx_buff.head = stir->rx_buff.skb->data;
 
880
        do_gettimeofday(&stir->rx_time);
 
881
 
 
882
        stir->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
 
883
        if (!stir->rx_urb) 
 
884
                goto err_out2;
 
885
 
 
886
        stir->io_buf = kmalloc(STIR_FIFO_SIZE, GFP_KERNEL);
 
887
        if (!stir->io_buf)
 
888
                goto err_out3;
 
889
 
 
890
        usb_fill_bulk_urb(stir->rx_urb, stir->usbdev,
 
891
                          usb_rcvbulkpipe(stir->usbdev, 2),
 
892
                          stir->io_buf, STIR_FIFO_SIZE,
 
893
                          stir_rcv_irq, stir);
 
894
 
 
895
        stir->fifo_status = kmalloc(FIFO_REGS_SIZE, GFP_KERNEL);
 
896
        if (!stir->fifo_status) 
 
897
                goto err_out4;
 
898
                
 
899
        /*
 
900
         * Now that everything should be initialized properly,
 
901
         * Open new IrLAP layer instance to take care of us...
 
902
         * Note : will send immediately a speed change...
 
903
         */
 
904
        sprintf(hwname, "usb#%d", stir->usbdev->devnum);
 
905
        stir->irlap = irlap_open(netdev, &stir->qos, hwname);
 
906
        if (!stir->irlap) {
 
907
                err("stir4200: irlap_open failed");
 
908
                goto err_out5;
 
909
        }
 
910
 
 
911
        /** Start kernel thread for transmit.  */
 
912
        stir->thread = kthread_run(stir_transmit_thread, stir,
 
913
                                   "%s", stir->netdev->name);
 
914
        if (IS_ERR(stir->thread)) {
 
915
                err = PTR_ERR(stir->thread);
 
916
                err("stir4200: unable to start kernel thread");
 
917
                goto err_out6;
 
918
        }
 
919
 
 
920
        netif_start_queue(netdev);
 
921
 
 
922
        return 0;
 
923
 
 
924
 err_out6:
 
925
        irlap_close(stir->irlap);
 
926
 err_out5:
 
927
        kfree(stir->fifo_status);
 
928
 err_out4:
 
929
        kfree(stir->io_buf);
 
930
 err_out3:
 
931
        usb_free_urb(stir->rx_urb);
 
932
 err_out2:
 
933
        kfree_skb(stir->rx_buff.skb);
 
934
 err_out1:
 
935
        return err;
 
936
}
 
937
 
 
938
/*
 
939
 * Function stir_net_close (stir)
 
940
 *
 
941
 *    Network device is taken down. Usually this is done by
 
942
 *    "ifconfig irda0 down"
 
943
 */
 
944
static int stir_net_close(struct net_device *netdev)
 
945
{
 
946
        struct stir_cb *stir = netdev_priv(netdev);
 
947
 
 
948
        /* Stop transmit processing */
 
949
        netif_stop_queue(netdev);
 
950
 
 
951
        /* Kill transmit thread */
 
952
        kthread_stop(stir->thread);
 
953
        kfree(stir->fifo_status);
 
954
 
 
955
        /* Mop up receive urb's */
 
956
        usb_kill_urb(stir->rx_urb);
 
957
        
 
958
        kfree(stir->io_buf);
 
959
        usb_free_urb(stir->rx_urb);
 
960
        kfree_skb(stir->rx_buff.skb);
 
961
 
 
962
        /* Stop and remove instance of IrLAP */
 
963
        if (stir->irlap)
 
964
                irlap_close(stir->irlap);
 
965
 
 
966
        stir->irlap = NULL;
 
967
 
 
968
        return 0;
 
969
}
 
970
 
 
971
/*
 
972
 * IOCTLs : Extra out-of-band network commands...
 
973
 */
 
974
static int stir_net_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 
975
{
 
976
        struct if_irda_req *irq = (struct if_irda_req *) rq;
 
977
        struct stir_cb *stir = netdev_priv(netdev);
 
978
        int ret = 0;
 
979
 
 
980
        switch (cmd) {
 
981
        case SIOCSBANDWIDTH: /* Set bandwidth */
 
982
                if (!capable(CAP_NET_ADMIN))
 
983
                        return -EPERM;
 
984
 
 
985
                /* Check if the device is still there */
 
986
                if (netif_device_present(stir->netdev))
 
987
                        ret = change_speed(stir, irq->ifr_baudrate);
 
988
                break;
 
989
 
 
990
        case SIOCSMEDIABUSY: /* Set media busy */
 
991
                if (!capable(CAP_NET_ADMIN))
 
992
                        return -EPERM;
 
993
 
 
994
                /* Check if the IrDA stack is still there */
 
995
                if (netif_running(stir->netdev))
 
996
                        irda_device_set_media_busy(stir->netdev, TRUE);
 
997
                break;
 
998
 
 
999
        case SIOCGRECEIVING:
 
1000
                /* Only approximately true */
 
1001
                irq->ifr_receiving = stir->receiving;
 
1002
                break;
 
1003
 
 
1004
        default:
 
1005
                ret = -EOPNOTSUPP;
 
1006
        }
 
1007
 
 
1008
        return ret;
 
1009
}
 
1010
 
 
1011
static const struct net_device_ops stir_netdev_ops = {
 
1012
        .ndo_open       = stir_net_open,
 
1013
        .ndo_stop       = stir_net_close,
 
1014
        .ndo_start_xmit = stir_hard_xmit,
 
1015
        .ndo_do_ioctl   = stir_net_ioctl,
 
1016
};
 
1017
 
 
1018
/*
 
1019
 * This routine is called by the USB subsystem for each new device
 
1020
 * in the system. We need to check if the device is ours, and in
 
1021
 * this case start handling it.
 
1022
 * Note : it might be worth protecting this function by a global
 
1023
 * spinlock... Or not, because maybe USB already deal with that...
 
1024
 */
 
1025
static int stir_probe(struct usb_interface *intf,
 
1026
                      const struct usb_device_id *id)
 
1027
{
 
1028
        struct usb_device *dev = interface_to_usbdev(intf);
 
1029
        struct stir_cb *stir = NULL;
 
1030
        struct net_device *net;
 
1031
        int ret = -ENOMEM;
 
1032
 
 
1033
        /* Allocate network device container. */
 
1034
        net = alloc_irdadev(sizeof(*stir));
 
1035
        if(!net)
 
1036
                goto err_out1;
 
1037
 
 
1038
        SET_NETDEV_DEV(net, &intf->dev);
 
1039
        stir = netdev_priv(net);
 
1040
        stir->netdev = net;
 
1041
        stir->usbdev = dev;
 
1042
 
 
1043
        ret = usb_reset_configuration(dev);
 
1044
        if (ret != 0) {
 
1045
                err("stir4200: usb reset configuration failed");
 
1046
                goto err_out2;
 
1047
        }
 
1048
 
 
1049
        printk(KERN_INFO "SigmaTel STIr4200 IRDA/USB found at address %d, "
 
1050
                "Vendor: %x, Product: %x\n",
 
1051
               dev->devnum, le16_to_cpu(dev->descriptor.idVendor),
 
1052
               le16_to_cpu(dev->descriptor.idProduct));
 
1053
 
 
1054
        /* Initialize QoS for this device */
 
1055
        irda_init_max_qos_capabilies(&stir->qos);
 
1056
 
 
1057
        /* That's the Rx capability. */
 
1058
        stir->qos.baud_rate.bits       &= IR_2400 | IR_9600 | IR_19200 |
 
1059
                                         IR_38400 | IR_57600 | IR_115200 |
 
1060
                                         (IR_4000000 << 8);
 
1061
        stir->qos.min_turn_time.bits   &= qos_mtt_bits;
 
1062
        irda_qos_bits_to_value(&stir->qos);
 
1063
 
 
1064
        /* Override the network functions we need to use */
 
1065
        net->netdev_ops = &stir_netdev_ops;
 
1066
 
 
1067
        ret = register_netdev(net);
 
1068
        if (ret != 0)
 
1069
                goto err_out2;
 
1070
 
 
1071
        dev_info(&intf->dev, "IrDA: Registered SigmaTel device %s\n",
 
1072
                 net->name);
 
1073
 
 
1074
        usb_set_intfdata(intf, stir);
 
1075
 
 
1076
        return 0;
 
1077
 
 
1078
err_out2:
 
1079
        free_netdev(net);
 
1080
err_out1:
 
1081
        return ret;
 
1082
}
 
1083
 
 
1084
/*
 
1085
 * The current device is removed, the USB layer tell us to shut it down...
 
1086
 */
 
1087
static void stir_disconnect(struct usb_interface *intf)
 
1088
{
 
1089
        struct stir_cb *stir = usb_get_intfdata(intf);
 
1090
 
 
1091
        if (!stir)
 
1092
                return;
 
1093
 
 
1094
        unregister_netdev(stir->netdev);
 
1095
        free_netdev(stir->netdev);
 
1096
 
 
1097
        usb_set_intfdata(intf, NULL);
 
1098
}
 
1099
 
 
1100
#ifdef CONFIG_PM
 
1101
/* USB suspend, so power off the transmitter/receiver */
 
1102
static int stir_suspend(struct usb_interface *intf, pm_message_t message)
 
1103
{
 
1104
        struct stir_cb *stir = usb_get_intfdata(intf);
 
1105
 
 
1106
        netif_device_detach(stir->netdev);
 
1107
        return 0;
 
1108
}
 
1109
 
 
1110
/* Coming out of suspend, so reset hardware */
 
1111
static int stir_resume(struct usb_interface *intf)
 
1112
{
 
1113
        struct stir_cb *stir = usb_get_intfdata(intf);
 
1114
 
 
1115
        netif_device_attach(stir->netdev);
 
1116
 
 
1117
        /* receiver restarted when send thread wakes up */
 
1118
        return 0;
 
1119
}
 
1120
#endif
 
1121
 
 
1122
/*
 
1123
 * USB device callbacks
 
1124
 */
 
1125
static struct usb_driver irda_driver = {
 
1126
        .name           = "stir4200",
 
1127
        .probe          = stir_probe,
 
1128
        .disconnect     = stir_disconnect,
 
1129
        .id_table       = dongles,
 
1130
#ifdef CONFIG_PM
 
1131
        .suspend        = stir_suspend,
 
1132
        .resume         = stir_resume,
 
1133
#endif
 
1134
};
 
1135
 
 
1136
/*
 
1137
 * Module insertion
 
1138
 */
 
1139
static int __init stir_init(void)
 
1140
{
 
1141
        return usb_register(&irda_driver);
 
1142
}
 
1143
module_init(stir_init);
 
1144
 
 
1145
/*
 
1146
 * Module removal
 
1147
 */
 
1148
static void __exit stir_cleanup(void)
 
1149
{
 
1150
        /* Deregister the driver and remove all pending instances */
 
1151
        usb_deregister(&irda_driver);
 
1152
}
 
1153
module_exit(stir_cleanup);