← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-backports-modules-3.5.0/quantal-updates

« back to all changes in this revision

Viewing changes to updates/cw-3.6/compat/compat-3.4.c

  • Committer: Package Import Robot
  • Author(s): Leann Ogasawara
  • Date: 2012-10-10 22:28:55 UTC
  • Revision ID: package-import@ubuntu.com-20121010222855-qepocc61xktv6gs9
Tags: 3.5.0-17.1
https://launchpad.net/bugs/1066123
* Open Quantal LBM
* Add compat-wireless 3.6
  -LP: #1066123

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/cw-3.6/compat/compat-3.4.c
 
1
/*
 
2
 * Copyright 2012  Luis R. Rodriguez <mcgrof@frijolero.org>
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License version 2 as
 
6
 * published by the Free Software Foundation.
 
7
 *
 
8
 * Compatibility file for Linux wireless for kernels 3.4.
 
9
 */
 
10
 
 
11
#include <linux/fs.h>
 
12
#include <linux/module.h>
 
13
#include <linux/wait.h>
 
14
 
 
15
/* __wake_up_common was declared as part of the wait.h until
 
16
 * 2.6.31 in which they made it private to the scheduler. Prefix it with
 
17
 * compat to avoid double declaration issues.
 
18
 */
 
19
static void compat_wake_up_common(wait_queue_head_t *q, unsigned int mode,
 
20
                        int nr_exclusive, int wake_flags, void *key)
 
21
{
 
22
        wait_queue_t *curr, *next;
 
23
 
 
24
        list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
 
25
                unsigned flags = curr->flags;
 
26
 
 
27
                if (curr->func(curr, mode, wake_flags, key) &&
 
28
                                (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
 
29
                        break;
 
30
        }
 
31
}
 
32
 
 
33
/* The last 'nr' parameter was added to the __wake_up_locked() function
 
34
 * in 3.4 kernel. Define a new one prefixed with compat_ for the new API.
 
35
 */
 
36
void compat_wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr)
 
37
{
 
38
        compat_wake_up_common(q, mode, nr, 0, NULL);
 
39
}
 
40
EXPORT_SYMBOL_GPL(compat_wake_up_locked);
 
41
 
 
42
 
 
43
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,34))
 
44
#include <linux/i2c.h>
 
45
#include <linux/i2c-algo-bit.h>
 
46
#include <linux/delay.h>
 
47
 
 
48
#define setsda(adap, val)       adap->setsda(adap->data, val)
 
49
#define setscl(adap, val)       adap->setscl(adap->data, val)
 
50
#define getsda(adap)            adap->getsda(adap->data)
 
51
#define getscl(adap)            adap->getscl(adap->data)
 
52
 
 
53
#define bit_dbg(level, dev, format, args...) \
 
54
        do {} while (0)
 
55
 
 
56
static inline void sdalo(struct i2c_algo_bit_data *adap)
 
57
{
 
58
        setsda(adap, 0);
 
59
        udelay((adap->udelay + 1) / 2);
 
60
}
 
61
 
 
62
static inline void sdahi(struct i2c_algo_bit_data *adap)
 
63
{
 
64
        setsda(adap, 1);
 
65
        udelay((adap->udelay + 1) / 2);
 
66
}
 
67
 
 
68
static inline void scllo(struct i2c_algo_bit_data *adap)
 
69
{
 
70
        setscl(adap, 0);
 
71
        udelay(adap->udelay / 2);
 
72
}
 
73
 
 
74
static int sclhi(struct i2c_algo_bit_data *adap)
 
75
{
 
76
        unsigned long start;
 
77
 
 
78
        setscl(adap, 1);
 
79
 
 
80
        /* Not all adapters have scl sense line... */
 
81
        if (!adap->getscl)
 
82
                goto done;
 
83
 
 
84
        start = jiffies;
 
85
        while (!getscl(adap)) {
 
86
                /* This hw knows how to read the clock line, so we wait
 
87
                 * until it actually gets high.  This is safer as some
 
88
                 * chips may hold it low ("clock stretching") while they
 
89
                 * are processing data internally.
 
90
                 */
 
91
                if (time_after(jiffies, start + adap->timeout)) {
 
92
                        /* Test one last time, as we may have been preempted
 
93
                         * between last check and timeout test.
 
94
                         */
 
95
                        if (getscl(adap))
 
96
                                break;
 
97
                        return -ETIMEDOUT;
 
98
                }
 
99
                cpu_relax();
 
100
        }
 
101
#ifdef DEBUG
 
102
        if (jiffies != start && i2c_debug >= 3)
 
103
                pr_debug("i2c-algo-bit: needed %ld jiffies for SCL to go "
 
104
                         "high\n", jiffies - start);
 
105
#endif
 
106
 
 
107
done:
 
108
        udelay(adap->udelay);
 
109
        return 0;
 
110
}
 
111
 
 
112
static void i2c_start(struct i2c_algo_bit_data *adap)
 
113
{
 
114
        /* assert: scl, sda are high */
 
115
        setsda(adap, 0);
 
116
        udelay(adap->udelay);
 
117
        scllo(adap);
 
118
}
 
119
 
 
120
static void i2c_repstart(struct i2c_algo_bit_data *adap)
 
121
{
 
122
        /* assert: scl is low */
 
123
        sdahi(adap);
 
124
        sclhi(adap);
 
125
        setsda(adap, 0);
 
126
        udelay(adap->udelay);
 
127
        scllo(adap);
 
128
}
 
129
 
 
130
 
 
131
static void i2c_stop(struct i2c_algo_bit_data *adap)
 
132
{
 
133
        /* assert: scl is low */
 
134
        sdalo(adap);
 
135
        sclhi(adap);
 
136
        setsda(adap, 1);
 
137
        udelay(adap->udelay);
 
138
}
 
139
 
 
140
static int i2c_outb(struct i2c_adapter *i2c_adap, unsigned char c)
 
141
{
 
142
        int i;
 
143
        int sb;
 
144
        int ack;
 
145
        struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 
146
 
 
147
        /* assert: scl is low */
 
148
        for (i = 7; i >= 0; i--) {
 
149
                sb = (c >> i) & 1;
 
150
                setsda(adap, sb);
 
151
                udelay((adap->udelay + 1) / 2);
 
152
                if (sclhi(adap) < 0) { /* timed out */
 
153
                        bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
 
154
                                "timeout at bit #%d\n", (int)c, i);
 
155
                        return -ETIMEDOUT;
 
156
                }
 
157
                /* FIXME do arbitration here:
 
158
                 * if (sb && !getsda(adap)) -> ouch! Get out of here.
 
159
                 *
 
160
                 * Report a unique code, so higher level code can retry
 
161
                 * the whole (combined) message and *NOT* issue STOP.
 
162
                 */
 
163
                scllo(adap);
 
164
        }
 
165
        sdahi(adap);
 
166
        if (sclhi(adap) < 0) { /* timeout */
 
167
                bit_dbg(1, &i2c_adap->dev, "i2c_outb: 0x%02x, "
 
168
                        "timeout at ack\n", (int)c);
 
169
                return -ETIMEDOUT;
 
170
        }
 
171
 
 
172
        /* read ack: SDA should be pulled down by slave, or it may
 
173
         * NAK (usually to report problems with the data we wrote).
 
174
         */
 
175
        ack = !getsda(adap);    /* ack: sda is pulled low -> success */
 
176
        bit_dbg(2, &i2c_adap->dev, "i2c_outb: 0x%02x %s\n", (int)c,
 
177
                ack ? "A" : "NA");
 
178
 
 
179
        scllo(adap);
 
180
        return ack;
 
181
        /* assert: scl is low (sda undef) */
 
182
}
 
183
 
 
184
static int i2c_inb(struct i2c_adapter *i2c_adap)
 
185
{
 
186
        /* read byte via i2c port, without start/stop sequence  */
 
187
        /* acknowledge is sent in i2c_read.                     */
 
188
        int i;
 
189
        unsigned char indata = 0;
 
190
        struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 
191
 
 
192
        /* assert: scl is low */
 
193
        sdahi(adap);
 
194
        for (i = 0; i < 8; i++) {
 
195
                if (sclhi(adap) < 0) { /* timeout */
 
196
                        bit_dbg(1, &i2c_adap->dev, "i2c_inb: timeout at bit "
 
197
                                "#%d\n", 7 - i);
 
198
                        return -ETIMEDOUT;
 
199
                }
 
200
                indata *= 2;
 
201
                if (getsda(adap))
 
202
                        indata |= 0x01;
 
203
                setscl(adap, 0);
 
204
                udelay(i == 7 ? adap->udelay / 2 : adap->udelay);
 
205
        }
 
206
        /* assert: scl is low */
 
207
        return indata;
 
208
}
 
209
 
 
210
static int try_address(struct i2c_adapter *i2c_adap,
 
211
                       unsigned char addr, int retries)
 
212
{
 
213
        struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 
214
        int i, ret = 0;
 
215
 
 
216
        for (i = 0; i <= retries; i++) {
 
217
                ret = i2c_outb(i2c_adap, addr);
 
218
                if (ret == 1 || i == retries)
 
219
                        break;
 
220
                bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
 
221
                i2c_stop(adap);
 
222
                udelay(adap->udelay);
 
223
                yield();
 
224
                bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
 
225
                i2c_start(adap);
 
226
        }
 
227
        if (i && ret)
 
228
                bit_dbg(1, &i2c_adap->dev, "Used %d tries to %s client at "
 
229
                        "0x%02x: %s\n", i + 1,
 
230
                        addr & 1 ? "read from" : "write to", addr >> 1,
 
231
                        ret == 1 ? "success" : "failed, timeout?");
 
232
        return ret;
 
233
}
 
234
 
 
235
static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
 
236
{
 
237
        unsigned short flags = msg->flags;
 
238
        unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
 
239
        struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 
240
 
 
241
        unsigned char addr;
 
242
        int ret, retries;
 
243
 
 
244
        retries = nak_ok ? 0 : i2c_adap->retries;
 
245
 
 
246
        if (flags & I2C_M_TEN) {
 
247
                /* a ten bit address */
 
248
                addr = 0xf0 | ((msg->addr >> 7) & 0x06);
 
249
                bit_dbg(2, &i2c_adap->dev, "addr0: %d\n", addr);
 
250
                /* try extended address code...*/
 
251
                ret = try_address(i2c_adap, addr, retries);
 
252
                if ((ret != 1) && !nak_ok)  {
 
253
                        dev_err(&i2c_adap->dev,
 
254
                                "died at extended address code\n");
 
255
                        return -ENXIO;
 
256
                }
 
257
                /* the remaining 8 bit address */
 
258
                ret = i2c_outb(i2c_adap, msg->addr & 0xff);
 
259
                if ((ret != 1) && !nak_ok) {
 
260
                        /* the chip did not ack / xmission error occurred */
 
261
                        dev_err(&i2c_adap->dev, "died at 2nd address code\n");
 
262
                        return -ENXIO;
 
263
                }
 
264
                if (flags & I2C_M_RD) {
 
265
                        bit_dbg(3, &i2c_adap->dev, "emitting repeated "
 
266
                                "start condition\n");
 
267
                        i2c_repstart(adap);
 
268
                        /* okay, now switch into reading mode */
 
269
                        addr |= 0x01;
 
270
                        ret = try_address(i2c_adap, addr, retries);
 
271
                        if ((ret != 1) && !nak_ok) {
 
272
                                dev_err(&i2c_adap->dev,
 
273
                                        "died at repeated address code\n");
 
274
                                return -EIO;
 
275
                        }
 
276
                }
 
277
        } else {                /* normal 7bit address  */
 
278
                addr = msg->addr << 1;
 
279
                if (flags & I2C_M_RD)
 
280
                        addr |= 1;
 
281
                if (flags & I2C_M_REV_DIR_ADDR)
 
282
                        addr ^= 1;
 
283
                ret = try_address(i2c_adap, addr, retries);
 
284
                if ((ret != 1) && !nak_ok)
 
285
                        return -ENXIO;
 
286
        }
 
287
 
 
288
        return 0;
 
289
}
 
290
 
 
291
static int sendbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
 
292
{
 
293
        const unsigned char *temp = msg->buf;
 
294
        int count = msg->len;
 
295
        unsigned short nak_ok = msg->flags & I2C_M_IGNORE_NAK;
 
296
        int retval;
 
297
        int wrcount = 0;
 
298
 
 
299
        while (count > 0) {
 
300
                retval = i2c_outb(i2c_adap, *temp);
 
301
 
 
302
                /* OK/ACK; or ignored NAK */
 
303
                if ((retval > 0) || (nak_ok && (retval == 0))) {
 
304
                        count--;
 
305
                        temp++;
 
306
                        wrcount++;
 
307
 
 
308
                /* A slave NAKing the master means the slave didn't like
 
309
                 * something about the data it saw.  For example, maybe
 
310
                 * the SMBus PEC was wrong.
 
311
                 */
 
312
                } else if (retval == 0) {
 
313
                        dev_err(&i2c_adap->dev, "sendbytes: NAK bailout.\n");
 
314
                        return -EIO;
 
315
 
 
316
                /* Timeout; or (someday) lost arbitration
 
317
                 *
 
318
                 * FIXME Lost ARB implies retrying the transaction from
 
319
                 * the first message, after the "winning" master issues
 
320
                 * its STOP.  As a rule, upper layer code has no reason
 
321
                 * to know or care about this ... it is *NOT* an error.
 
322
                 */
 
323
                } else {
 
324
                        dev_err(&i2c_adap->dev, "sendbytes: error %d\n",
 
325
                                        retval);
 
326
                        return retval;
 
327
                }
 
328
        }
 
329
        return wrcount;
 
330
}
 
331
 
 
332
static int acknak(struct i2c_adapter *i2c_adap, int is_ack)
 
333
{
 
334
        struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 
335
 
 
336
        /* assert: sda is high */
 
337
        if (is_ack)             /* send ack */
 
338
                setsda(adap, 0);
 
339
        udelay((adap->udelay + 1) / 2);
 
340
        if (sclhi(adap) < 0) {  /* timeout */
 
341
                dev_err(&i2c_adap->dev, "readbytes: ack/nak timeout\n");
 
342
                return -ETIMEDOUT;
 
343
        }
 
344
        scllo(adap);
 
345
        return 0;
 
346
}
 
347
 
 
348
static int readbytes(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
 
349
{
 
350
        int inval;
 
351
        int rdcount = 0;        /* counts bytes read */
 
352
        unsigned char *temp = msg->buf;
 
353
        int count = msg->len;
 
354
        const unsigned flags = msg->flags;
 
355
 
 
356
        while (count > 0) {
 
357
                inval = i2c_inb(i2c_adap);
 
358
                if (inval >= 0) {
 
359
                        *temp = inval;
 
360
                        rdcount++;
 
361
                } else {   /* read timed out */
 
362
                        break;
 
363
                }
 
364
 
 
365
                temp++;
 
366
                count--;
 
367
 
 
368
                /* Some SMBus transactions require that we receive the
 
369
                   transaction length as the first read byte. */
 
370
                if (rdcount == 1 && (flags & I2C_M_RECV_LEN)) {
 
371
                        if (inval <= 0 || inval > I2C_SMBUS_BLOCK_MAX) {
 
372
                                if (!(flags & I2C_M_NO_RD_ACK))
 
373
                                        acknak(i2c_adap, 0);
 
374
                                dev_err(&i2c_adap->dev, "readbytes: invalid "
 
375
                                        "block length (%d)\n", inval);
 
376
                                return -EPROTO;
 
377
                        }
 
378
                        /* The original count value accounts for the extra
 
379
                           bytes, that is, either 1 for a regular transaction,
 
380
                           or 2 for a PEC transaction. */
 
381
                        count += inval;
 
382
                        msg->len += inval;
 
383
                }
 
384
 
 
385
                bit_dbg(2, &i2c_adap->dev, "readbytes: 0x%02x %s\n",
 
386
                        inval,
 
387
                        (flags & I2C_M_NO_RD_ACK)
 
388
                                ? "(no ack/nak)"
 
389
                                : (count ? "A" : "NA"));
 
390
 
 
391
                if (!(flags & I2C_M_NO_RD_ACK)) {
 
392
                        inval = acknak(i2c_adap, count);
 
393
                        if (inval < 0)
 
394
                                return inval;
 
395
                }
 
396
        }
 
397
        return rdcount;
 
398
}
 
399
 
 
400
 
 
401
static u32 bit_func(struct i2c_adapter *adap)
 
402
{
 
403
        return I2C_FUNC_I2C | I2C_FUNC_NOSTART | I2C_FUNC_SMBUS_EMUL |
 
404
               I2C_FUNC_SMBUS_READ_BLOCK_DATA |
 
405
               I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
 
406
               I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING;
 
407
}
 
408
 
 
409
static int bit_xfer(struct i2c_adapter *i2c_adap,
 
410
                    struct i2c_msg msgs[], int num)
 
411
{
 
412
        struct i2c_msg *pmsg;
 
413
        struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
 
414
        int i, ret;
 
415
        unsigned short nak_ok;
 
416
 
 
417
        if (adap->pre_xfer) {
 
418
                ret = adap->pre_xfer(i2c_adap);
 
419
                if (ret < 0)
 
420
                        return ret;
 
421
        }
 
422
 
 
423
        bit_dbg(3, &i2c_adap->dev, "emitting start condition\n");
 
424
        i2c_start(adap);
 
425
        for (i = 0; i < num; i++) {
 
426
                pmsg = &msgs[i];
 
427
                nak_ok = pmsg->flags & I2C_M_IGNORE_NAK;
 
428
                if (!(pmsg->flags & I2C_M_NOSTART)) {
 
429
                        if (i) {
 
430
                                bit_dbg(3, &i2c_adap->dev, "emitting "
 
431
                                        "repeated start condition\n");
 
432
                                i2c_repstart(adap);
 
433
                        }
 
434
                        ret = bit_doAddress(i2c_adap, pmsg);
 
435
                        if ((ret != 0) && !nak_ok) {
 
436
                                bit_dbg(1, &i2c_adap->dev, "NAK from "
 
437
                                        "device addr 0x%02x msg #%d\n",
 
438
                                        msgs[i].addr, i);
 
439
                                goto bailout;
 
440
                        }
 
441
                }
 
442
                if (pmsg->flags & I2C_M_RD) {
 
443
                        /* read bytes into buffer*/
 
444
                        ret = readbytes(i2c_adap, pmsg);
 
445
                        if (ret >= 1)
 
446
                                bit_dbg(2, &i2c_adap->dev, "read %d byte%s\n",
 
447
                                        ret, ret == 1 ? "" : "s");
 
448
                        if (ret < pmsg->len) {
 
449
                                if (ret >= 0)
 
450
                                        ret = -EIO;
 
451
                                goto bailout;
 
452
                        }
 
453
                } else {
 
454
                        /* write bytes from buffer */
 
455
                        ret = sendbytes(i2c_adap, pmsg);
 
456
                        if (ret >= 1)
 
457
                                bit_dbg(2, &i2c_adap->dev, "wrote %d byte%s\n",
 
458
                                        ret, ret == 1 ? "" : "s");
 
459
                        if (ret < pmsg->len) {
 
460
                                if (ret >= 0)
 
461
                                        ret = -EIO;
 
462
                                goto bailout;
 
463
                        }
 
464
                }
 
465
        }
 
466
        ret = i;
 
467
 
 
468
bailout:
 
469
        bit_dbg(3, &i2c_adap->dev, "emitting stop condition\n");
 
470
        i2c_stop(adap);
 
471
 
 
472
        if (adap->post_xfer)
 
473
                adap->post_xfer(i2c_adap);
 
474
        return ret;
 
475
}
 
476
 
 
477
 
 
478
const struct i2c_algorithm i2c_bit_algo = {
 
479
        .master_xfer    = bit_xfer,
 
480
        .functionality  = bit_func,
 
481
};
 
482
EXPORT_SYMBOL(i2c_bit_algo);
 
483
#endif
 
484
 
 
485
int simple_open(struct inode *inode, struct file *file)
 
486
{
 
487
        if (inode->i_private)
 
488
                file->private_data = inode->i_private;
 
489
        return 0;
 
490
}
 
491
EXPORT_SYMBOL_GPL(simple_open);