← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/iio/accel/sca3000_core.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/accel/sca3000_core.c
40
40
 * do not actually appear to be available.
41
41
 */
42
42
static const struct sca3000_chip_info sca3000_spi_chip_info_tbl[] = {
43
 
        {
44
 
                .name = "sca3000-d01",
45
 
                .scale = " 0.0073575",
 
43
        [d01] = {
 
44
                .scale = 7357,
46
45
                .temp_output = true,
47
46
                .measurement_mode_freq = 250,
48
47
                .option_mode_1 = SCA3000_OP_MODE_BYPASS,
49
48
                .option_mode_1_freq = 250,
50
 
        }, {
51
 
                .name = "sca3000-e02",
52
 
                .scale = "0.00981",
 
49
                .mot_det_mult_xz = {50, 100, 200, 350, 650, 1300},
 
50
                .mot_det_mult_y = {50, 100, 150, 250, 450, 850, 1750},
 
51
        },
 
52
        [e02] = {
 
53
                .scale = 9810,
53
54
                .measurement_mode_freq = 125,
54
55
                .option_mode_1 = SCA3000_OP_MODE_NARROW,
55
56
                .option_mode_1_freq = 63,
56
 
        }, {
57
 
                .name = "sca3000-e04",
58
 
                .scale = "0.01962",
 
57
                .mot_det_mult_xz = {100, 150, 300, 550, 1050, 2050},
 
58
                .mot_det_mult_y = {50, 100, 200, 350, 700, 1350, 2700},
 
59
        },
 
60
        [e04] = {
 
61
                .scale = 19620,
59
62
                .measurement_mode_freq = 100,
60
63
                .option_mode_1 = SCA3000_OP_MODE_NARROW,
61
64
                .option_mode_1_freq = 50,
62
65
                .option_mode_2 = SCA3000_OP_MODE_WIDE,
63
66
                .option_mode_2_freq = 400,
64
 
        }, {
65
 
                .name = "sca3000-e05",
66
 
                .scale = "0.0613125",
 
67
                .mot_det_mult_xz = {200, 300, 600, 1100, 2100, 4100},
 
68
                .mot_det_mult_y = {100, 200, 400, 7000, 1400, 2700, 54000},
 
69
        },
 
70
        [e05] = {
 
71
                .scale = 61313,
67
72
                .measurement_mode_freq = 200,
68
73
                .option_mode_1 = SCA3000_OP_MODE_NARROW,
69
74
                .option_mode_1_freq = 50,
70
75
                .option_mode_2 = SCA3000_OP_MODE_WIDE,
71
76
                .option_mode_2_freq = 400,
 
77
                .mot_det_mult_xz = {600, 900, 1700, 3200, 6100, 11900},
 
78
                .mot_det_mult_y = {300, 600, 1200, 2000, 4100, 7800, 15600},
72
79
        },
73
80
};
74
81
 
75
 
 
76
82
int sca3000_write_reg(struct sca3000_state *st, u8 address, u8 val)
77
83
{
78
 
        struct spi_transfer xfer = {
79
 
                .bits_per_word = 8,
80
 
                .len = 2,
81
 
                .cs_change = 1,
82
 
                .tx_buf = st->tx,
83
 
        };
84
 
        struct spi_message msg;
85
 
 
86
84
        st->tx[0] = SCA3000_WRITE_REG(address);
87
85
        st->tx[1] = val;
88
 
        spi_message_init(&msg);
89
 
        spi_message_add_tail(&xfer, &msg);
90
 
 
91
 
        return spi_sync(st->us, &msg);
 
86
        return spi_write(st->us, st->tx, 2);
92
87
}
93
88
 
94
 
int sca3000_read_data(struct sca3000_state *st,
95
 
                      uint8_t reg_address_high,
96
 
                      u8 **rx_p,
97
 
                      int len)
 
89
int sca3000_read_data_short(struct sca3000_state *st,
 
90
                            uint8_t reg_address_high,
 
91
                            int len)
98
92
{
99
 
        int ret;
100
93
        struct spi_message msg;
101
 
        struct spi_transfer xfer = {
102
 
                .bits_per_word = 8,
103
 
                .len = len + 1,
104
 
                .cs_change = 1,
105
 
                .tx_buf = st->tx,
 
94
        struct spi_transfer xfer[2] = {
 
95
                {
 
96
                        .len = 1,
 
97
                        .tx_buf = st->tx,
 
98
                }, {
 
99
                        .len = len,
 
100
                        .rx_buf = st->rx,
 
101
                }
106
102
        };
107
 
 
108
 
        *rx_p = kmalloc(len + 1, GFP_KERNEL);
109
 
        if (*rx_p == NULL) {
110
 
                ret = -ENOMEM;
111
 
                goto error_ret;
112
 
        }
113
 
        xfer.rx_buf = *rx_p;
114
103
        st->tx[0] = SCA3000_READ_REG(reg_address_high);
115
104
        spi_message_init(&msg);
116
 
        spi_message_add_tail(&xfer, &msg);
117
 
 
118
 
        ret = spi_sync(st->us, &msg);
119
 
 
120
 
        if (ret) {
121
 
                dev_err(get_device(&st->us->dev), "problem reading register");
122
 
                goto error_free_rx;
123
 
        }
124
 
 
125
 
        return 0;
126
 
error_free_rx:
127
 
        kfree(*rx_p);
128
 
error_ret:
129
 
        return ret;
130
 
 
 
105
        spi_message_add_tail(&xfer[0], &msg);
 
106
        spi_message_add_tail(&xfer[1], &msg);
 
107
 
 
108
        return spi_sync(st->us, &msg);
131
109
}
 
110
 
132
111
/**
133
112
 * sca3000_reg_lock_on() test if the ctrl register lock is on
134
113
 *
136
115
 **/
137
116
static int sca3000_reg_lock_on(struct sca3000_state *st)
138
117
{
139
 
        u8 *rx;
140
118
        int ret;
141
119
 
142
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_STATUS, &rx, 1);
143
 
 
 
120
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_STATUS, 1);
144
121
        if (ret < 0)
145
122
                return ret;
146
 
        ret = !(rx[1] & SCA3000_LOCKED);
147
 
        kfree(rx);
148
123
 
149
 
        return ret;
 
124
        return !(st->rx[0] & SCA3000_LOCKED);
150
125
}
151
126
 
152
127
/**
161
136
        struct spi_message msg;
162
137
        struct spi_transfer xfer[3] = {
163
138
                {
164
 
                        .bits_per_word = 8,
165
139
                        .len = 2,
166
140
                        .cs_change = 1,
167
141
                        .tx_buf = st->tx,
168
142
                }, {
169
 
                        .bits_per_word = 8,
170
143
                        .len = 2,
171
144
                        .cs_change = 1,
172
145
                        .tx_buf = st->tx + 2,
173
146
                }, {
174
 
                        .bits_per_word = 8,
175
147
                        .len = 2,
176
 
                        .cs_change = 1,
177
148
                        .tx_buf = st->tx + 4,
178
149
                },
179
150
        };
236
207
 * Lock must be held.
237
208
 **/
238
209
static int sca3000_read_ctrl_reg(struct sca3000_state *st,
239
 
                                 u8 ctrl_reg,
240
 
                                 u8 **rx_p)
 
210
                                 u8 ctrl_reg)
241
211
{
242
212
        int ret;
243
213
 
253
223
        ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_SEL, ctrl_reg);
254
224
        if (ret)
255
225
                goto error_ret;
256
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_CTRL_DATA, rx_p, 1);
257
 
 
 
226
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_CTRL_DATA, 1);
 
227
        if (ret)
 
228
                goto error_ret;
 
229
        else
 
230
                return st->rx[0];
258
231
error_ret:
259
232
        return ret;
260
233
}
267
240
 **/
268
241
static int sca3000_check_status(struct device *dev)
269
242
{
270
 
        u8 *rx;
271
243
        int ret;
272
244
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
273
245
        struct sca3000_state *st = indio_dev->dev_data;
274
246
 
275
247
        mutex_lock(&st->lock);
276
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_STATUS, &rx, 1);
 
248
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_STATUS, 1);
277
249
        if (ret < 0)
278
250
                goto error_ret;
279
 
        if (rx[1] & SCA3000_EEPROM_CS_ERROR)
 
251
        if (st->rx[0] & SCA3000_EEPROM_CS_ERROR)
280
252
                dev_err(dev, "eeprom error\n");
281
 
        if (rx[1] & SCA3000_SPI_FRAME_ERROR)
 
253
        if (st->rx[0] & SCA3000_SPI_FRAME_ERROR)
282
254
                dev_err(dev, "Previous SPI Frame was corrupt\n");
283
 
        kfree(rx);
284
255
 
285
256
error_ret:
286
257
        mutex_unlock(&st->lock);
288
259
}
289
260
#endif /* SCA3000_DEBUG */
290
261
 
291
 
/**
292
 
 * sca3000_read_13bit_signed() sysfs interface to read 13 bit signed registers
293
 
 *
294
 
 * These are described as signed 12 bit on the data sheet, which appears
295
 
 * to be a conventional 2's complement 13 bit.
296
 
 **/
297
 
static ssize_t sca3000_read_13bit_signed(struct device *dev,
298
 
                                         struct device_attribute *attr,
299
 
                                         char *buf)
300
 
{
301
 
        int len = 0, ret;
302
 
        int val;
303
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
304
 
        u8 *rx;
305
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
306
 
        struct sca3000_state *st = indio_dev->dev_data;
307
 
 
308
 
        mutex_lock(&st->lock);
309
 
        ret = sca3000_read_data(st, this_attr->address, &rx, 2);
310
 
        if (ret < 0)
311
 
                goto error_ret;
312
 
        val = sca3000_13bit_convert(rx[1], rx[2]);
313
 
        len += sprintf(buf + len, "%d\n", val);
314
 
        kfree(rx);
315
 
error_ret:
316
 
        mutex_unlock(&st->lock);
317
 
 
318
 
        return ret ? ret : len;
319
 
}
320
 
 
321
 
static ssize_t sca3000_show_scale(struct device *dev,
322
 
                                  struct device_attribute *attr,
323
 
                                  char *buf)
324
 
{
325
 
        struct iio_dev *dev_info = dev_get_drvdata(dev);
326
 
        struct sca3000_state *st = dev_info->dev_data;
327
 
        return sprintf(buf, "%s\n", st->info->scale);
328
 
}
329
 
 
330
 
static ssize_t sca3000_show_name(struct device *dev,
331
 
                                 struct device_attribute *attr,
332
 
                                 char *buf)
333
 
{
334
 
        struct iio_dev *dev_info = dev_get_drvdata(dev);
335
 
        struct sca3000_state *st = dev_info->dev_data;
336
 
        return sprintf(buf, "%s\n", st->info->name);
337
 
}
 
262
 
338
263
/**
339
264
 * sca3000_show_reg() - sysfs interface to read the chip revision number
340
265
 **/
346
271
        struct iio_dev *dev_info = dev_get_drvdata(dev);
347
272
        struct sca3000_state *st = dev_info->dev_data;
348
273
 
349
 
        u8 *rx;
350
 
 
351
274
        mutex_lock(&st->lock);
352
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_REVID, &rx, 1);
 
275
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_REVID, 1);
353
276
        if (ret < 0)
354
277
                goto error_ret;
355
278
        len += sprintf(buf + len,
356
279
                       "major=%d, minor=%d\n",
357
 
                       rx[1] & SCA3000_REVID_MAJOR_MASK,
358
 
                       rx[1] & SCA3000_REVID_MINOR_MASK);
359
 
        kfree(rx);
360
 
 
 
280
                       st->rx[0] & SCA3000_REVID_MAJOR_MASK,
 
281
                       st->rx[0] & SCA3000_REVID_MINOR_MASK);
361
282
error_ret:
362
283
        mutex_unlock(&st->lock);
363
284
 
410
331
        struct iio_dev *dev_info = dev_get_drvdata(dev);
411
332
        struct sca3000_state *st = dev_info->dev_data;
412
333
        int len = 0, ret;
413
 
        u8 *rx;
414
334
 
415
335
        mutex_lock(&st->lock);
416
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
 
336
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
417
337
        if (ret)
418
338
                goto error_ret;
419
339
        /* mask bottom 2 bits - only ones that are relevant */
420
 
        rx[1] &= 0x03;
421
 
        switch (rx[1]) {
 
340
        st->rx[0] &= 0x03;
 
341
        switch (st->rx[0]) {
422
342
        case SCA3000_MEAS_MODE_NORMAL:
423
343
                len += sprintf(buf + len, "0 - normal mode\n");
424
344
                break;
462
382
        struct iio_dev *dev_info = dev_get_drvdata(dev);
463
383
        struct sca3000_state *st = dev_info->dev_data;
464
384
        int ret;
465
 
        u8 *rx;
466
385
        int mask = 0x03;
467
386
        long val;
468
387
 
470
389
        ret = strict_strtol(buf, 10, &val);
471
390
        if (ret)
472
391
                goto error_ret;
473
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
474
 
        if (ret)
475
 
                goto error_ret;
476
 
        rx[1] &= ~mask;
477
 
        rx[1] |= (val & mask);
478
 
        ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, rx[1]);
479
 
        if (ret)
480
 
                goto error_free_rx;
 
392
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 
393
        if (ret)
 
394
                goto error_ret;
 
395
        st->rx[0] &= ~mask;
 
396
        st->rx[0] |= (val & mask);
 
397
        ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, st->rx[0]);
 
398
        if (ret)
 
399
                goto error_ret;
481
400
        mutex_unlock(&st->lock);
482
401
 
483
402
        return len;
484
403
 
485
 
error_free_rx:
486
 
        kfree(rx);
487
404
error_ret:
488
405
        mutex_unlock(&st->lock);
489
406
 
505
422
 
506
423
/* More standard attributes */
507
424
 
508
 
static IIO_DEV_ATTR_NAME(sca3000_show_name);
509
425
static IIO_DEV_ATTR_REV(sca3000_show_rev);
510
 
static IIO_DEVICE_ATTR(accel_scale, S_IRUGO, sca3000_show_scale,
511
 
                       NULL, 0);
512
 
 
513
 
static IIO_DEV_ATTR_ACCEL_X(sca3000_read_13bit_signed,
514
 
                            SCA3000_REG_ADDR_X_MSB);
515
 
static IIO_DEV_ATTR_ACCEL_Y(sca3000_read_13bit_signed,
516
 
                            SCA3000_REG_ADDR_Y_MSB);
517
 
static IIO_DEV_ATTR_ACCEL_Z(sca3000_read_13bit_signed,
518
 
                            SCA3000_REG_ADDR_Z_MSB);
519
 
 
 
426
 
 
427
#define SCA3000_INFO_MASK                       \
 
428
        (1 << IIO_CHAN_INFO_SCALE_SHARED)
 
429
#define SCA3000_EVENT_MASK                                      \
 
430
        (IIO_EV_BIT(IIO_EV_TYPE_MAG, IIO_EV_DIR_RISING))
 
431
 
 
432
static struct iio_chan_spec sca3000_channels[] = {
 
433
        IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X, SCA3000_INFO_MASK,
 
434
                 0, 0, IIO_ST('s', 11, 16, 5), SCA3000_EVENT_MASK),
 
435
        IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y, SCA3000_INFO_MASK,
 
436
                 1, 1, IIO_ST('s', 11, 16, 5), SCA3000_EVENT_MASK),
 
437
        IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Z, SCA3000_INFO_MASK,
 
438
                 2, 2, IIO_ST('s', 11, 16, 5), SCA3000_EVENT_MASK),
 
439
};
 
440
 
 
441
static u8 sca3000_addresses[3][3] = {
 
442
        [0] = {SCA3000_REG_ADDR_X_MSB, SCA3000_REG_CTRL_SEL_MD_X_TH,
 
443
               SCA3000_MD_CTRL_OR_X},
 
444
        [1] = {SCA3000_REG_ADDR_Y_MSB, SCA3000_REG_CTRL_SEL_MD_Y_TH,
 
445
               SCA3000_MD_CTRL_OR_Y},
 
446
        [2] = {SCA3000_REG_ADDR_Z_MSB, SCA3000_REG_CTRL_SEL_MD_Z_TH,
 
447
               SCA3000_MD_CTRL_OR_Z},
 
448
};
 
449
 
 
450
static int sca3000_read_raw(struct iio_dev *indio_dev,
 
451
                            struct iio_chan_spec const *chan,
 
452
                            int *val,
 
453
                            int *val2,
 
454
                            long mask)
 
455
{
 
456
        struct sca3000_state *st = indio_dev->dev_data;
 
457
        int ret;
 
458
        u8 address;
 
459
 
 
460
        switch (mask) {
 
461
        case 0:
 
462
                mutex_lock(&st->lock);
 
463
                if (st->mo_det_use_count) {
 
464
                        mutex_unlock(&st->lock);
 
465
                        return -EBUSY;
 
466
                }
 
467
                address = sca3000_addresses[chan->address][0];
 
468
                ret = sca3000_read_data_short(st, address, 2);
 
469
                if (ret < 0) {
 
470
                        mutex_unlock(&st->lock);
 
471
                        return ret;
 
472
                }
 
473
                *val = (be16_to_cpup((__be16 *)st->rx) >> 3) & 0x1FFF;
 
474
                *val = ((*val) << (sizeof(*val)*8 - 13)) >>
 
475
                        (sizeof(*val)*8 - 13);
 
476
                mutex_unlock(&st->lock);
 
477
                return IIO_VAL_INT;
 
478
        case (1 << IIO_CHAN_INFO_SCALE_SHARED):
 
479
                *val = 0;
 
480
                if (chan->type == IIO_ACCEL)
 
481
                        *val2 = st->info->scale;
 
482
                else /* temperature */
 
483
                        *val2 = 555556;
 
484
                return IIO_VAL_INT_PLUS_MICRO;
 
485
        default:
 
486
                return -EINVAL;
 
487
        }
 
488
}
520
489
 
521
490
/**
522
491
 * sca3000_read_av_freq() sysfs function to get available frequencies
532
501
{
533
502
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
534
503
        struct sca3000_state *st = indio_dev->dev_data;
535
 
        int len = 0, ret;
536
 
        u8 *rx;
 
504
        int len = 0, ret, val;
 
505
 
537
506
        mutex_lock(&st->lock);
538
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
 
507
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 
508
        val = st->rx[0];
539
509
        mutex_unlock(&st->lock);
540
510
        if (ret)
541
511
                goto error_ret;
542
 
        rx[1] &= 0x03;
543
 
        switch (rx[1]) {
 
512
 
 
513
        switch (val & 0x03) {
544
514
        case SCA3000_MEAS_MODE_NORMAL:
545
515
                len += sprintf(buf + len, "%d %d %d\n",
546
516
                               st->info->measurement_mode_freq,
560
530
                               st->info->option_mode_2_freq/4);
561
531
                break;
562
532
        }
563
 
        kfree(rx);
564
533
        return len;
565
534
error_ret:
566
535
        return ret;
575
544
                                          int *base_freq)
576
545
{
577
546
        int ret;
578
 
        u8 *rx;
579
547
 
580
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
 
548
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
581
549
        if (ret)
582
550
                goto error_ret;
583
 
        switch (0x03 & rx[1]) {
 
551
        switch (0x03 & st->rx[0]) {
584
552
        case SCA3000_MEAS_MODE_NORMAL:
585
553
                *base_freq = info->measurement_mode_freq;
586
554
                break;
591
559
                *base_freq = info->option_mode_2_freq;
592
560
                break;
593
561
        }
594
 
        kfree(rx);
595
562
error_ret:
596
563
        return ret;
597
564
}
605
572
{
606
573
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
607
574
        struct sca3000_state *st = indio_dev->dev_data;
608
 
        int ret, len = 0, base_freq = 0;
609
 
        u8 *rx;
 
575
        int ret, len = 0, base_freq = 0, val;
 
576
 
610
577
        mutex_lock(&st->lock);
611
578
        ret = __sca3000_get_base_freq(st, st->info, &base_freq);
612
579
        if (ret)
613
580
                goto error_ret_mut;
614
 
        ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, &rx);
 
581
        ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
615
582
        mutex_unlock(&st->lock);
616
583
        if (ret)
617
584
                goto error_ret;
 
585
        val = ret;
618
586
        if (base_freq > 0)
619
 
                switch (rx[1]&0x03) {
 
587
                switch (val & 0x03) {
620
588
                case 0x00:
621
589
                case 0x03:
622
590
                        len = sprintf(buf, "%d\n", base_freq);
628
596
                        len = sprintf(buf, "%d\n", base_freq/4);
629
597
                        break;
630
598
        }
631
 
        kfree(rx);
 
599
 
632
600
        return len;
633
601
error_ret_mut:
634
602
        mutex_unlock(&st->lock);
647
615
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
648
616
        struct sca3000_state *st = indio_dev->dev_data;
649
617
        int ret, base_freq = 0;
650
 
        u8 *rx;
 
618
        int ctrlval;
651
619
        long val;
652
620
 
653
621
        ret = strict_strtol(buf, 10, &val);
660
628
        if (ret)
661
629
                goto error_free_lock;
662
630
 
663
 
        ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, &rx);
664
 
        if (ret)
 
631
        ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 
632
        if (ret < 0)
665
633
                goto error_free_lock;
 
634
        ctrlval = ret;
666
635
        /* clear the bits */
667
 
        rx[1] &= ~0x03;
 
636
        ctrlval &= ~0x03;
668
637
 
669
638
        if (val == base_freq/2) {
670
 
                rx[1] |= SCA3000_OUT_CTRL_BUF_DIV_2;
 
639
                ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_2;
671
640
        } else if (val == base_freq/4) {
672
 
                rx[1] |= SCA3000_OUT_CTRL_BUF_DIV_4;
 
641
                ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_4;
673
642
        } else if (val != base_freq) {
674
643
                ret = -EINVAL;
675
644
                goto error_free_lock;
676
645
        }
677
 
        ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, rx[1]);
 
646
        ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
 
647
                                     ctrlval);
678
648
error_free_lock:
679
649
        mutex_unlock(&st->lock);
680
650
 
704
674
{
705
675
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
706
676
        struct sca3000_state *st = indio_dev->dev_data;
707
 
        int len = 0, ret;
 
677
        int ret;
708
678
        int val;
709
 
        u8 *rx;
710
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_TEMP_MSB, &rx, 2);
 
679
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_TEMP_MSB, 2);
711
680
        if (ret < 0)
712
681
                goto error_ret;
713
 
        val = ((rx[1]&0x3F) << 3) | ((rx[2] & 0xE0) >> 5);
714
 
        len += sprintf(buf + len, "%d\n", val);
715
 
        kfree(rx);
 
682
        val = ((st->rx[0] & 0x3F) << 3) | ((st->rx[1] & 0xE0) >> 5);
716
683
 
717
 
        return len;
 
684
        return sprintf(buf, "%d\n", val);
718
685
 
719
686
error_ret:
720
687
        return ret;
725
692
static IIO_CONST_ATTR_TEMP_OFFSET("-214.6");
726
693
 
727
694
/**
728
 
 * sca3000_show_thresh() sysfs query of a threshold
 
695
 * sca3000_read_thresh() - query of a threshold
729
696
 **/
730
 
static ssize_t sca3000_show_thresh(struct device *dev,
731
 
                                   struct device_attribute *attr,
732
 
                                   char *buf)
 
697
static int sca3000_read_thresh(struct iio_dev *indio_dev,
 
698
                               int e,
 
699
                               int *val)
733
700
{
734
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
701
        int ret, i;
735
702
        struct sca3000_state *st = indio_dev->dev_data;
736
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
737
 
        int len = 0, ret;
738
 
        u8 *rx;
739
 
 
 
703
        int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e);
740
704
        mutex_lock(&st->lock);
741
 
        ret = sca3000_read_ctrl_reg(st,
742
 
                                    this_attr->address,
743
 
                                    &rx);
 
705
        ret = sca3000_read_ctrl_reg(st, sca3000_addresses[num][1]);
744
706
        mutex_unlock(&st->lock);
745
 
        if (ret)
 
707
        if (ret < 0)
746
708
                return ret;
747
 
        len += sprintf(buf + len, "%d\n", rx[1]);
748
 
        kfree(rx);
 
709
        *val = 0;
 
710
        if (num == 1)
 
711
                for_each_set_bit(i, (unsigned long *)&ret,
 
712
                                 ARRAY_SIZE(st->info->mot_det_mult_y))
 
713
                        *val += st->info->mot_det_mult_y[i];
 
714
        else
 
715
                for_each_set_bit(i, (unsigned long *)&ret,
 
716
                                 ARRAY_SIZE(st->info->mot_det_mult_xz))
 
717
                        *val += st->info->mot_det_mult_xz[i];
749
718
 
750
 
        return len;
 
719
        return 0;
751
720
}
752
721
 
753
722
/**
754
 
 * sca3000_write_thresh() sysfs control of threshold
 
723
 * sca3000_write_thresh() control of threshold
755
724
 **/
756
 
static ssize_t sca3000_write_thresh(struct device *dev,
757
 
                                    struct device_attribute *attr,
758
 
                                    const char *buf,
759
 
                                    size_t len)
 
725
static int sca3000_write_thresh(struct iio_dev *indio_dev,
 
726
                                    int e,
 
727
                                    int val)
760
728
{
761
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
762
729
        struct sca3000_state *st = indio_dev->dev_data;
763
 
        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 
730
        int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e);
764
731
        int ret;
765
 
        long val;
766
 
 
767
 
        ret = strict_strtol(buf, 10, &val);
768
 
        if (ret)
769
 
                return ret;
 
732
        int i;
 
733
        u8 nonlinear = 0;
 
734
 
 
735
        if (num == 1) {
 
736
                i = ARRAY_SIZE(st->info->mot_det_mult_y);
 
737
                while (i > 0)
 
738
                        if (val >= st->info->mot_det_mult_y[--i]) {
 
739
                                nonlinear |= (1 << i);
 
740
                                val -= st->info->mot_det_mult_y[i];
 
741
                        }
 
742
        } else {
 
743
                i = ARRAY_SIZE(st->info->mot_det_mult_xz);
 
744
                while (i > 0)
 
745
                        if (val >= st->info->mot_det_mult_xz[--i]) {
 
746
                                nonlinear |= (1 << i);
 
747
                                val -= st->info->mot_det_mult_xz[i];
 
748
                        }
 
749
        }
 
750
 
770
751
        mutex_lock(&st->lock);
771
 
        ret = sca3000_write_ctrl_reg(st, this_attr->address, val);
 
752
        ret = sca3000_write_ctrl_reg(st, sca3000_addresses[num][1], nonlinear);
772
753
        mutex_unlock(&st->lock);
773
754
 
774
 
        return ret ? ret : len;
 
755
        return ret;
775
756
}
776
757
 
777
 
static IIO_DEVICE_ATTR(accel_x_raw_mag_rising_value,
778
 
                S_IRUGO | S_IWUSR,
779
 
                sca3000_show_thresh,
780
 
                sca3000_write_thresh,
781
 
                SCA3000_REG_CTRL_SEL_MD_X_TH);
782
 
 
783
 
static IIO_DEVICE_ATTR(accel_y_raw_mag_rising_value,
784
 
                S_IRUGO | S_IWUSR,
785
 
                sca3000_show_thresh,
786
 
                sca3000_write_thresh,
787
 
                SCA3000_REG_CTRL_SEL_MD_Y_TH);
788
 
 
789
 
static IIO_DEVICE_ATTR(accel_z_raw_mag_rising_value,
790
 
                S_IRUGO | S_IWUSR,
791
 
                sca3000_show_thresh,
792
 
                sca3000_write_thresh,
793
 
                SCA3000_REG_CTRL_SEL_MD_Z_TH);
794
 
 
795
758
static struct attribute *sca3000_attributes[] = {
796
 
        &iio_dev_attr_name.dev_attr.attr,
797
759
        &iio_dev_attr_revision.dev_attr.attr,
798
 
        &iio_dev_attr_accel_scale.dev_attr.attr,
799
 
        &iio_dev_attr_accel_x_raw.dev_attr.attr,
800
 
        &iio_dev_attr_accel_y_raw.dev_attr.attr,
801
 
        &iio_dev_attr_accel_z_raw.dev_attr.attr,
802
760
        &iio_dev_attr_measurement_mode_available.dev_attr.attr,
803
761
        &iio_dev_attr_measurement_mode.dev_attr.attr,
804
762
        &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
807
765
};
808
766
 
809
767
static struct attribute *sca3000_attributes_with_temp[] = {
810
 
        &iio_dev_attr_name.dev_attr.attr,
811
768
        &iio_dev_attr_revision.dev_attr.attr,
812
 
        &iio_dev_attr_accel_scale.dev_attr.attr,
813
 
        &iio_dev_attr_accel_x_raw.dev_attr.attr,
814
 
        &iio_dev_attr_accel_y_raw.dev_attr.attr,
815
 
        &iio_dev_attr_accel_z_raw.dev_attr.attr,
816
769
        &iio_dev_attr_measurement_mode_available.dev_attr.attr,
817
770
        &iio_dev_attr_measurement_mode.dev_attr.attr,
818
771
        &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
836
789
/* depending on event, push to the ring buffer event chrdev or the event one */
837
790
 
838
791
/**
839
 
 * sca3000_interrupt_handler_bh() - handling ring and non ring events
 
792
 * sca3000_event_handler() - handling ring and non ring events
840
793
 *
841
794
 * This function is complicated by the fact that the devices can signify ring
842
795
 * and non ring events via the same interrupt line and they can only
843
796
 * be distinguished via a read of the relevant status register.
844
797
 **/
845
 
static void sca3000_interrupt_handler_bh(struct work_struct *work_s)
 
798
static irqreturn_t sca3000_event_handler(int irq, void *private)
846
799
{
847
 
        struct sca3000_state *st
848
 
                = container_of(work_s, struct sca3000_state,
849
 
                               interrupt_handler_ws);
850
 
        u8 *rx;
851
 
        int ret;
 
800
        struct iio_dev *indio_dev = private;
 
801
        struct sca3000_state *st;
 
802
        int ret, val;
 
803
        s64 last_timestamp = iio_get_time_ns();
852
804
 
 
805
        st = indio_dev->dev_data;
853
806
        /* Could lead if badly timed to an extra read of status reg,
854
807
         * but ensures no interrupt is missed.
855
808
         */
856
 
        enable_irq(st->us->irq);
857
809
        mutex_lock(&st->lock);
858
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_STATUS,
859
 
                                &rx, 1);
 
810
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
 
811
        val = st->rx[0];
860
812
        mutex_unlock(&st->lock);
861
813
        if (ret)
862
814
                goto done;
863
815
 
864
 
        sca3000_ring_int_process(rx[1], st->indio_dev->ring);
 
816
        sca3000_ring_int_process(val, st->indio_dev->ring);
865
817
 
866
 
        if (rx[1] & SCA3000_INT_STATUS_FREE_FALL)
 
818
        if (val & SCA3000_INT_STATUS_FREE_FALL)
867
819
                iio_push_event(st->indio_dev, 0,
868
820
                               IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL,
869
821
                                                  0,
870
822
                                                  IIO_EV_MOD_X_AND_Y_AND_Z,
871
823
                                                  IIO_EV_TYPE_MAG,
872
824
                                                  IIO_EV_DIR_FALLING),
873
 
                               st->last_timestamp);
 
825
                               last_timestamp);
874
826
 
875
 
        if (rx[1] & SCA3000_INT_STATUS_Y_TRIGGER)
 
827
        if (val & SCA3000_INT_STATUS_Y_TRIGGER)
876
828
                iio_push_event(st->indio_dev, 0,
877
829
                               IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL,
878
830
                                                  0,
879
831
                                                  IIO_EV_MOD_Y,
880
832
                                                  IIO_EV_TYPE_MAG,
881
833
                                                  IIO_EV_DIR_RISING),
882
 
                               st->last_timestamp);
 
834
                               last_timestamp);
883
835
 
884
 
        if (rx[1] & SCA3000_INT_STATUS_X_TRIGGER)
 
836
        if (val & SCA3000_INT_STATUS_X_TRIGGER)
885
837
                iio_push_event(st->indio_dev, 0,
886
838
                               IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL,
887
839
                                                  0,
888
840
                                                  IIO_EV_MOD_X,
889
841
                                                  IIO_EV_TYPE_MAG,
890
842
                                                  IIO_EV_DIR_RISING),
891
 
                               st->last_timestamp);
 
843
                               last_timestamp);
892
844
 
893
 
        if (rx[1] & SCA3000_INT_STATUS_Z_TRIGGER)
 
845
        if (val & SCA3000_INT_STATUS_Z_TRIGGER)
894
846
                iio_push_event(st->indio_dev, 0,
895
847
                               IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL,
896
848
                                                  0,
897
849
                                                  IIO_EV_MOD_Z,
898
850
                                                  IIO_EV_TYPE_MAG,
899
851
                                                  IIO_EV_DIR_RISING),
900
 
                               st->last_timestamp);
 
852
                               last_timestamp);
901
853
 
902
854
done:
903
 
        kfree(rx);
904
 
        return;
905
 
}
906
 
 
907
 
/**
908
 
 * sca3000_handler_th() handles all interrupt events from device
909
 
 *
910
 
 * These devices deploy unified interrupt status registers meaning
911
 
 * all interrupts must be handled together
912
 
 **/
913
 
static int sca3000_handler_th(struct iio_dev *dev_info,
914
 
                              int index,
915
 
                              s64 timestamp,
916
 
                              int no_test)
917
 
{
918
 
        struct sca3000_state *st = dev_info->dev_data;
919
 
 
920
 
        st->last_timestamp = timestamp;
921
 
        schedule_work(&st->interrupt_handler_ws);
922
 
 
923
 
        return 0;
924
 
}
925
 
 
926
 
/**
927
 
 * sca3000_query_mo_det() is motion detection enabled for this axis
928
 
 *
929
 
 * First queries if motion detection is enabled and then if this axis is
930
 
 * on.
931
 
 **/
932
 
static ssize_t sca3000_query_mo_det(struct device *dev,
933
 
                                    struct device_attribute *attr,
934
 
                                    char *buf)
935
 
{
936
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev->parent);
 
855
        return IRQ_HANDLED;
 
856
}
 
857
 
 
858
/**
 
859
 * sca3000_read_event_config() what events are enabled
 
860
 **/
 
861
static int sca3000_read_event_config(struct iio_dev *indio_dev,
 
862
                                     int e)
 
863
{
937
864
        struct sca3000_state *st = indio_dev->dev_data;
938
 
        struct iio_event_attr *this_attr = to_iio_event_attr(attr);
939
 
        int ret, len = 0;
940
 
        u8 *rx;
 
865
        int ret;
941
866
        u8 protect_mask = 0x03;
 
867
        int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e);
942
868
 
943
869
        /* read current value of mode register */
944
870
        mutex_lock(&st->lock);
945
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
 
871
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
946
872
        if (ret)
947
873
                goto error_ret;
948
874
 
949
 
        if ((rx[1]&protect_mask) != SCA3000_MEAS_MODE_MOT_DET)
950
 
                len += sprintf(buf + len, "0\n");
 
875
        if ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET)
 
876
                ret = 0;
951
877
        else {
952
 
                kfree(rx);
953
 
                ret = sca3000_read_ctrl_reg(st,
954
 
                                            SCA3000_REG_CTRL_SEL_MD_CTRL,
955
 
                                            &rx);
956
 
                if (ret)
 
878
                ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 
879
                if (ret < 0)
957
880
                        goto error_ret;
958
881
                /* only supporting logical or's for now */
959
 
                len += sprintf(buf + len, "%d\n",
960
 
                               (rx[1] & this_attr->mask) ? 1 : 0);
 
882
                ret = !!(ret & sca3000_addresses[num][2]);
961
883
        }
962
 
        kfree(rx);
963
884
error_ret:
964
885
        mutex_unlock(&st->lock);
965
886
 
966
 
        return ret ? ret : len;
 
887
        return ret;
967
888
}
968
889
/**
969
890
 * sca3000_query_free_fall_mode() is free fall mode enabled
973
894
                                            char *buf)
974
895
{
975
896
        int ret, len;
976
 
        u8 *rx;
977
897
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
978
898
        struct sca3000_state *st = indio_dev->dev_data;
 
899
        int val;
979
900
 
980
901
        mutex_lock(&st->lock);
981
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
 
902
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
 
903
        val = st->rx[0];
982
904
        mutex_unlock(&st->lock);
983
 
        if (ret)
 
905
        if (ret < 0)
984
906
                return ret;
985
907
        len = sprintf(buf, "%d\n",
986
 
                      !!(rx[1] & SCA3000_FREE_FALL_DETECT));
987
 
        kfree(rx);
988
 
 
989
 
        return len;
990
 
}
991
 
/**
992
 
 * sca3000_query_ring_int() is the hardware ring status interrupt enabled
993
 
 **/
994
 
static ssize_t sca3000_query_ring_int(struct device *dev,
995
 
                                      struct device_attribute *attr,
996
 
                                      char *buf)
997
 
{
998
 
        struct iio_event_attr *this_attr = to_iio_event_attr(attr);
999
 
        int ret, len;
1000
 
        u8 *rx;
1001
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev->parent);
1002
 
        struct sca3000_state *st = indio_dev->dev_data;
1003
 
        mutex_lock(&st->lock);
1004
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_MASK, &rx, 1);
1005
 
        mutex_unlock(&st->lock);
1006
 
        if (ret)
1007
 
                return ret;
1008
 
        len = sprintf(buf, "%d\n", (rx[1] & this_attr->mask) ? 1 : 0);
1009
 
        kfree(rx);
1010
 
 
1011
 
        return len;
1012
 
}
1013
 
/**
1014
 
 * sca3000_set_ring_int() set state of ring status interrupt
1015
 
 **/
1016
 
static ssize_t sca3000_set_ring_int(struct device *dev,
1017
 
                                      struct device_attribute *attr,
1018
 
                                      const char *buf,
1019
 
                                      size_t len)
1020
 
{
1021
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev->parent);
1022
 
        struct sca3000_state *st = indio_dev->dev_data;
1023
 
        struct iio_event_attr *this_attr = to_iio_event_attr(attr);
1024
 
 
1025
 
        long val;
1026
 
        int ret;
1027
 
        u8 *rx;
1028
 
 
1029
 
        mutex_lock(&st->lock);
1030
 
        ret = strict_strtol(buf, 10, &val);
1031
 
        if (ret)
1032
 
                goto error_ret;
1033
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_MASK, &rx, 1);
1034
 
        if (ret)
1035
 
                goto error_ret;
1036
 
        if (val)
1037
 
                ret = sca3000_write_reg(st,
1038
 
                                        SCA3000_REG_ADDR_INT_MASK,
1039
 
                                        rx[1] | this_attr->mask);
1040
 
        else
1041
 
                ret = sca3000_write_reg(st,
1042
 
                                        SCA3000_REG_ADDR_INT_MASK,
1043
 
                                        rx[1] & ~this_attr->mask);
1044
 
        kfree(rx);
1045
 
error_ret:
1046
 
        mutex_unlock(&st->lock);
1047
 
 
1048
 
        return ret ? ret : len;
 
908
                      !!(val & SCA3000_FREE_FALL_DETECT));
 
909
        return len;
1049
910
}
1050
911
 
1051
912
/**
1065
926
        struct sca3000_state *st = indio_dev->dev_data;
1066
927
        long val;
1067
928
        int ret;
1068
 
        u8 *rx;
1069
929
        u8 protect_mask = SCA3000_FREE_FALL_DETECT;
1070
930
 
1071
931
        mutex_lock(&st->lock);
1074
934
                goto error_ret;
1075
935
 
1076
936
        /* read current value of mode register */
1077
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
 
937
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
1078
938
        if (ret)
1079
939
                goto error_ret;
1080
940
 
1081
941
        /*if off and should be on*/
1082
 
        if (val && !(rx[1] & protect_mask))
 
942
        if (val && !(st->rx[0] & protect_mask))
1083
943
                ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1084
 
                                        (rx[1] | SCA3000_FREE_FALL_DETECT));
 
944
                                        (st->rx[0] | SCA3000_FREE_FALL_DETECT));
1085
945
        /* if on and should be off */
1086
 
        else if (!val && (rx[1]&protect_mask))
 
946
        else if (!val && (st->rx[0] & protect_mask))
1087
947
                ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1088
 
                                        (rx[1] & ~protect_mask));
1089
 
 
1090
 
        kfree(rx);
 
948
                                        (st->rx[0] & ~protect_mask));
1091
949
error_ret:
1092
950
        mutex_unlock(&st->lock);
1093
951
 
1103
961
 * There is a complexity in knowing which mode to return to when
1104
962
 * this mode is disabled.  Currently normal mode is assumed.
1105
963
 **/
1106
 
static ssize_t sca3000_set_mo_det(struct device *dev,
1107
 
                                  struct device_attribute *attr,
1108
 
                                  const char *buf,
1109
 
                                  size_t len)
 
964
static int sca3000_write_event_config(struct iio_dev *indio_dev,
 
965
                                      int e,
 
966
                                      int state)
1110
967
{
1111
 
        struct iio_dev *indio_dev = dev_get_drvdata(dev->parent);
1112
968
        struct sca3000_state *st = indio_dev->dev_data;
1113
 
        struct iio_event_attr *this_attr = to_iio_event_attr(attr);
1114
 
        long val;
1115
 
        int ret;
1116
 
        u8 *rx;
 
969
        int ret, ctrlval;
1117
970
        u8 protect_mask = 0x03;
1118
 
        ret = strict_strtol(buf, 10, &val);
1119
 
        if (ret)
1120
 
                return ret;
 
971
        int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e);
1121
972
 
1122
973
        mutex_lock(&st->lock);
1123
974
        /* First read the motion detector config to find out if
1124
975
         * this axis is on*/
1125
 
        ret = sca3000_read_ctrl_reg(st,
1126
 
                                    SCA3000_REG_CTRL_SEL_MD_CTRL,
1127
 
                                    &rx);
1128
 
        if (ret)
 
976
        ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 
977
        if (ret < 0)
1129
978
                goto exit_point;
 
979
        ctrlval = ret;
1130
980
        /* Off and should be on */
1131
 
        if (val && !(rx[1] & this_attr->mask)) {
 
981
        if (state && !(ctrlval & sca3000_addresses[num][2])) {
1132
982
                ret = sca3000_write_ctrl_reg(st,
1133
983
                                             SCA3000_REG_CTRL_SEL_MD_CTRL,
1134
 
                                             rx[1] | this_attr->mask);
 
984
                                             ctrlval |
 
985
                                             sca3000_addresses[num][2]);
1135
986
                if (ret)
1136
 
                        goto exit_point_free_rx;
 
987
                        goto exit_point;
1137
988
                st->mo_det_use_count++;
1138
 
        } else if (!val && (rx[1]&this_attr->mask)) {
 
989
        } else if (!state && (ctrlval & sca3000_addresses[num][2])) {
1139
990
                ret = sca3000_write_ctrl_reg(st,
1140
991
                                             SCA3000_REG_CTRL_SEL_MD_CTRL,
1141
 
                                             rx[1] & ~(this_attr->mask));
 
992
                                             ctrlval &
 
993
                                             ~(sca3000_addresses[num][2]));
1142
994
                if (ret)
1143
 
                        goto exit_point_free_rx;
 
995
                        goto exit_point;
1144
996
                st->mo_det_use_count--;
1145
 
        } else /* relies on clean state for device on boot */
1146
 
                goto exit_point_free_rx;
1147
 
        kfree(rx);
 
997
        }
 
998
 
1148
999
        /* read current value of mode register */
1149
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1);
 
1000
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
1150
1001
        if (ret)
1151
1002
                goto exit_point;
1152
1003
        /*if off and should be on*/
1153
1004
        if ((st->mo_det_use_count)
1154
 
            && ((rx[1]&protect_mask) != SCA3000_MEAS_MODE_MOT_DET))
 
1005
            && ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET))
1155
1006
                ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1156
 
                                        (rx[1] & ~protect_mask)
 
1007
                                        (st->rx[0] & ~protect_mask)
1157
1008
                                        | SCA3000_MEAS_MODE_MOT_DET);
1158
1009
        /* if on and should be off */
1159
1010
        else if (!(st->mo_det_use_count)
1160
 
                 && ((rx[1]&protect_mask) == SCA3000_MEAS_MODE_MOT_DET))
 
1011
                 && ((st->rx[0] & protect_mask) == SCA3000_MEAS_MODE_MOT_DET))
1161
1012
                ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
1162
 
                                        (rx[1] & ~protect_mask));
1163
 
exit_point_free_rx:
1164
 
        kfree(rx);
 
1013
                                        (st->rx[0] & ~protect_mask));
1165
1014
exit_point:
1166
1015
        mutex_unlock(&st->lock);
1167
1016
 
1168
 
        return ret ? ret : len;
 
1017
        return ret;
1169
1018
}
1170
1019
 
1171
 
/* Shared event handler for all events as single event status register */
1172
 
IIO_EVENT_SH(all, &sca3000_handler_th);
1173
 
 
1174
1020
/* Free fall detector related event attribute */
1175
 
IIO_EVENT_ATTR_NAMED_SH(accel_xayaz_mag_falling_en,
1176
 
                        accel_x&y&z_mag_falling_en,
1177
 
                        iio_event_all,
1178
 
                        sca3000_query_free_fall_mode,
1179
 
                        sca3000_set_free_fall_mode,
1180
 
                        0);
1181
 
 
1182
 
IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period,
1183
 
                     accel_x&y&z_mag_falling_period,
1184
 
                     "0.226");
1185
 
 
1186
 
/* Motion detector related event attributes */
1187
 
IIO_EVENT_ATTR_SH(accel_x_mag_rising_en,
1188
 
                  iio_event_all,
1189
 
                  sca3000_query_mo_det,
1190
 
                  sca3000_set_mo_det,
1191
 
                  SCA3000_MD_CTRL_OR_X);
1192
 
 
1193
 
IIO_EVENT_ATTR_SH(accel_y_mag_rising_en,
1194
 
                  iio_event_all,
1195
 
                  sca3000_query_mo_det,
1196
 
                  sca3000_set_mo_det,
1197
 
                  SCA3000_MD_CTRL_OR_Y);
1198
 
 
1199
 
IIO_EVENT_ATTR_SH(accel_z_mag_rising_en,
1200
 
                  iio_event_all,
1201
 
                  sca3000_query_mo_det,
1202
 
                  sca3000_set_mo_det,
1203
 
                  SCA3000_MD_CTRL_OR_Z);
1204
 
 
1205
 
/* Hardware ring buffer related event attributes */
1206
 
IIO_EVENT_ATTR_RING_50_FULL_SH(iio_event_all,
1207
 
                               sca3000_query_ring_int,
1208
 
                               sca3000_set_ring_int,
1209
 
                               SCA3000_INT_MASK_RING_HALF);
1210
 
 
1211
 
IIO_EVENT_ATTR_RING_75_FULL_SH(iio_event_all,
1212
 
                               sca3000_query_ring_int,
1213
 
                               sca3000_set_ring_int,
1214
 
                               SCA3000_INT_MASK_RING_THREE_QUARTER);
 
1021
static IIO_DEVICE_ATTR_NAMED(accel_xayaz_mag_falling_en,
 
1022
                             accel_x&y&z_mag_falling_en,
 
1023
                             S_IRUGO | S_IWUSR,
 
1024
                             sca3000_query_free_fall_mode,
 
1025
                             sca3000_set_free_fall_mode,
 
1026
                             0);
 
1027
 
 
1028
static IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period,
 
1029
                            accel_x&y&z_mag_falling_period,
 
1030
                            "0.226");
1215
1031
 
1216
1032
static struct attribute *sca3000_event_attributes[] = {
1217
 
        &iio_event_attr_accel_xayaz_mag_falling_en.dev_attr.attr,
 
1033
        &iio_dev_attr_accel_xayaz_mag_falling_en.dev_attr.attr,
1218
1034
        &iio_const_attr_accel_xayaz_mag_falling_period.dev_attr.attr,
1219
 
        &iio_event_attr_accel_x_mag_rising_en.dev_attr.attr,
1220
 
        &iio_dev_attr_accel_x_raw_mag_rising_value.dev_attr.attr,
1221
 
        &iio_event_attr_accel_y_mag_rising_en.dev_attr.attr,
1222
 
        &iio_dev_attr_accel_y_raw_mag_rising_value.dev_attr.attr,
1223
 
        &iio_event_attr_accel_z_mag_rising_en.dev_attr.attr,
1224
 
        &iio_dev_attr_accel_z_raw_mag_rising_value.dev_attr.attr,
1225
 
        &iio_event_attr_ring_50_full.dev_attr.attr,
1226
 
        &iio_event_attr_ring_75_full.dev_attr.attr,
1227
1035
        NULL,
1228
1036
};
1229
1037
 
1241
1049
static int sca3000_clean_setup(struct sca3000_state *st)
1242
1050
{
1243
1051
        int ret;
1244
 
        u8 *rx;
1245
1052
 
1246
1053
        mutex_lock(&st->lock);
1247
1054
        /* Ensure all interrupts have been acknowledged */
1248
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_STATUS, &rx, 1);
 
1055
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1);
1249
1056
        if (ret)
1250
1057
                goto error_ret;
1251
 
        kfree(rx);
1252
1058
 
1253
1059
        /* Turn off all motion detection channels */
1254
 
        ret = sca3000_read_ctrl_reg(st,
1255
 
                                    SCA3000_REG_CTRL_SEL_MD_CTRL,
1256
 
                                    &rx);
1257
 
        if (ret)
 
1060
        ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL);
 
1061
        if (ret < 0)
1258
1062
                goto error_ret;
1259
 
        ret = sca3000_write_ctrl_reg(st,
1260
 
                                     SCA3000_REG_CTRL_SEL_MD_CTRL,
1261
 
                                     rx[1] & SCA3000_MD_CTRL_PROT_MASK);
1262
 
        kfree(rx);
 
1063
        ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL,
 
1064
                                     ret & SCA3000_MD_CTRL_PROT_MASK);
1263
1065
        if (ret)
1264
1066
                goto error_ret;
1265
1067
 
1266
1068
        /* Disable ring buffer */
1267
 
        sca3000_read_ctrl_reg(st,
1268
 
                              SCA3000_REG_CTRL_SEL_OUT_CTRL,
1269
 
                              &rx);
1270
 
        /* Frequency of ring buffer sampling deliberately restricted to make
1271
 
         * debugging easier - add control of this later */
1272
 
        ret = sca3000_write_ctrl_reg(st,
1273
 
                                     SCA3000_REG_CTRL_SEL_OUT_CTRL,
1274
 
                                     (rx[1] & SCA3000_OUT_CTRL_PROT_MASK)
 
1069
        ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL);
 
1070
        ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL,
 
1071
                                     (ret & SCA3000_OUT_CTRL_PROT_MASK)
1275
1072
                                     | SCA3000_OUT_CTRL_BUF_X_EN
1276
1073
                                     | SCA3000_OUT_CTRL_BUF_Y_EN
1277
1074
                                     | SCA3000_OUT_CTRL_BUF_Z_EN
1278
1075
                                     | SCA3000_OUT_CTRL_BUF_DIV_4);
1279
 
        kfree(rx);
1280
 
 
1281
1076
        if (ret)
1282
1077
                goto error_ret;
1283
1078
        /* Enable interrupts, relevant to mode and set up as active low */
1284
 
        ret = sca3000_read_data(st,
1285
 
                          SCA3000_REG_ADDR_INT_MASK,
1286
 
                          &rx, 1);
 
1079
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1287
1080
        if (ret)
1288
1081
                goto error_ret;
1289
1082
        ret = sca3000_write_reg(st,
1290
1083
                                SCA3000_REG_ADDR_INT_MASK,
1291
 
                                (rx[1] & SCA3000_INT_MASK_PROT_MASK)
 
1084
                                (ret & SCA3000_INT_MASK_PROT_MASK)
1292
1085
                                | SCA3000_INT_MASK_ACTIVE_LOW);
1293
 
        kfree(rx);
1294
1086
        if (ret)
1295
1087
                goto error_ret;
1296
1088
        /* Select normal measurement mode, free fall off, ring off */
1297
1089
        /* Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5
1298
1090
         * as that occurs in one of the example on the datasheet */
1299
 
        ret = sca3000_read_data(st,
1300
 
                          SCA3000_REG_ADDR_MODE,
1301
 
                          &rx, 1);
 
1091
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
1302
1092
        if (ret)
1303
1093
                goto error_ret;
1304
 
        ret = sca3000_write_reg(st,
1305
 
                                SCA3000_REG_ADDR_MODE,
1306
 
                                (rx[1] & SCA3000_MODE_PROT_MASK));
1307
 
        kfree(rx);
 
1094
        ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE,
 
1095
                                (st->rx[0] & SCA3000_MODE_PROT_MASK));
1308
1096
        st->bpse = 11;
1309
1097
 
1310
1098
error_ret:
1312
1100
        return ret;
1313
1101
}
1314
1102
 
1315
 
static int __devinit __sca3000_probe(struct spi_device *spi,
1316
 
                                     enum sca3000_variant variant)
 
1103
static const struct iio_info sca3000_info = {
 
1104
        .attrs = &sca3000_attribute_group,
 
1105
        .read_raw = &sca3000_read_raw,
 
1106
        .num_interrupt_lines = 1,
 
1107
        .event_attrs = &sca3000_event_attribute_group,
 
1108
        .read_event_value = &sca3000_read_thresh,
 
1109
        .write_event_value = &sca3000_write_thresh,
 
1110
        .read_event_config = &sca3000_read_event_config,
 
1111
        .write_event_config = &sca3000_write_event_config,
 
1112
        .driver_module = THIS_MODULE,
 
1113
};
 
1114
 
 
1115
static const struct iio_info sca3000_info_with_temp = {
 
1116
        .attrs = &sca3000_attribute_group_with_temp,
 
1117
        .read_raw = &sca3000_read_raw,
 
1118
        .read_event_value = &sca3000_read_thresh,
 
1119
        .write_event_value = &sca3000_write_thresh,
 
1120
        .read_event_config = &sca3000_read_event_config,
 
1121
        .write_event_config = &sca3000_write_event_config,
 
1122
        .driver_module = THIS_MODULE,
 
1123
};
 
1124
 
 
1125
static int __devinit sca3000_probe(struct spi_device *spi)
1317
1126
{
1318
1127
        int ret, regdone = 0;
1319
1128
        struct sca3000_state *st;
1325
1134
        }
1326
1135
        spi_set_drvdata(spi, st);
1327
1136
 
1328
 
        st->tx = kmalloc(sizeof(*st->tx)*6, GFP_KERNEL);
1329
 
        if (st->tx == NULL) {
1330
 
                ret = -ENOMEM;
1331
 
                goto error_clear_st;
1332
 
        }
1333
 
        st->rx = kmalloc(sizeof(*st->rx)*3, GFP_KERNEL);
1334
 
        if (st->rx == NULL) {
1335
 
                ret = -ENOMEM;
1336
 
                goto error_free_tx;
1337
 
        }
1338
1137
        st->us = spi;
1339
1138
        mutex_init(&st->lock);
1340
 
        st->info = &sca3000_spi_chip_info_tbl[variant];
 
1139
        st->info = &sca3000_spi_chip_info_tbl[spi_get_device_id(spi)
 
1140
                                              ->driver_data];
1341
1141
 
1342
 
        st->indio_dev = iio_allocate_device();
 
1142
        st->indio_dev = iio_allocate_device(0);
1343
1143
        if (st->indio_dev == NULL) {
1344
1144
                ret = -ENOMEM;
1345
 
                goto error_free_rx;
 
1145
                goto error_clear_st;
1346
1146
        }
1347
 
 
1348
1147
        st->indio_dev->dev.parent = &spi->dev;
1349
 
        st->indio_dev->num_interrupt_lines = 1;
1350
 
        st->indio_dev->event_attrs = &sca3000_event_attribute_group;
 
1148
        st->indio_dev->name = spi_get_device_id(spi)->name;
1351
1149
        if (st->info->temp_output)
1352
 
                st->indio_dev->attrs = &sca3000_attribute_group_with_temp;
1353
 
        else
1354
 
                st->indio_dev->attrs = &sca3000_attribute_group;
 
1150
                st->indio_dev->info = &sca3000_info_with_temp;
 
1151
        else {
 
1152
                st->indio_dev->info = &sca3000_info;
 
1153
                st->indio_dev->channels = sca3000_channels;
 
1154
                st->indio_dev->num_channels = ARRAY_SIZE(sca3000_channels);
 
1155
        }
1355
1156
        st->indio_dev->dev_data = (void *)(st);
1356
1157
        st->indio_dev->modes = INDIO_DIRECT_MODE;
1357
1158
 
1358
1159
        sca3000_configure_ring(st->indio_dev);
1359
 
 
1360
1160
        ret = iio_device_register(st->indio_dev);
1361
1161
        if (ret < 0)
1362
1162
                goto error_free_dev;
1363
1163
        regdone = 1;
1364
 
        ret = iio_ring_buffer_register(st->indio_dev->ring, 0);
 
1164
        ret = iio_ring_buffer_register_ex(st->indio_dev->ring, 0,
 
1165
                                          sca3000_channels,
 
1166
                                          ARRAY_SIZE(sca3000_channels));
1365
1167
        if (ret < 0)
1366
1168
                goto error_unregister_dev;
1367
1169
        if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) {
1368
 
                INIT_WORK(&st->interrupt_handler_ws,
1369
 
                          sca3000_interrupt_handler_bh);
1370
 
                ret = iio_register_interrupt_line(spi->irq,
1371
 
                                                  st->indio_dev,
1372
 
                                                  0,
1373
 
                                                  IRQF_TRIGGER_FALLING,
1374
 
                                                  "sca3000");
 
1170
                ret = request_threaded_irq(spi->irq,
 
1171
                                           NULL,
 
1172
                                           &sca3000_event_handler,
 
1173
                                           IRQF_TRIGGER_FALLING,
 
1174
                                           "sca3000",
 
1175
                                           st->indio_dev);
1375
1176
                if (ret)
1376
1177
                        goto error_unregister_ring;
1377
 
                /* RFC
1378
 
                 * Probably a common situation.  All interrupts need an ack
1379
 
                 * and there is only one handler so the complicated list system
1380
 
                 * is overkill.  At very least a simpler registration method
1381
 
                 * might be worthwhile.
1382
 
                 */
1383
 
                iio_add_event_to_list(
1384
 
                        iio_event_attr_accel_z_mag_rising_en.listel,
1385
 
                        &st->indio_dev
1386
 
                        ->interrupts[0]->ev_list);
1387
1178
        }
1388
1179
        sca3000_register_ring_funcs(st->indio_dev);
1389
1180
        ret = sca3000_clean_setup(st);
1390
1181
        if (ret)
1391
 
                goto error_unregister_interrupt_line;
 
1182
                goto error_free_irq;
1392
1183
        return 0;
1393
1184
 
1394
 
error_unregister_interrupt_line:
 
1185
error_free_irq:
1395
1186
        if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0)
1396
 
                iio_unregister_interrupt_line(st->indio_dev, 0);
 
1187
                free_irq(spi->irq, st->indio_dev);
1397
1188
error_unregister_ring:
1398
1189
        iio_ring_buffer_unregister(st->indio_dev->ring);
1399
1190
error_unregister_dev:
1402
1193
                iio_device_unregister(st->indio_dev);
1403
1194
        else
1404
1195
                iio_free_device(st->indio_dev);
1405
 
error_free_rx:
1406
 
        kfree(st->rx);
1407
 
error_free_tx:
1408
 
        kfree(st->tx);
1409
1196
error_clear_st:
1410
1197
        kfree(st);
1411
1198
error_ret:
1415
1202
static int sca3000_stop_all_interrupts(struct sca3000_state *st)
1416
1203
{
1417
1204
        int ret;
1418
 
        u8 *rx;
1419
1205
 
1420
1206
        mutex_lock(&st->lock);
1421
 
        ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_MASK, &rx, 1);
 
1207
        ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
1422
1208
        if (ret)
1423
1209
                goto error_ret;
1424
1210
        ret = sca3000_write_reg(st, SCA3000_REG_ADDR_INT_MASK,
1425
 
                                (rx[1] & ~(SCA3000_INT_MASK_RING_THREE_QUARTER
1426
 
                                           | SCA3000_INT_MASK_RING_HALF
1427
 
                                           | SCA3000_INT_MASK_ALL_INTS)));
 
1211
                                (st->rx[0] &
 
1212
                                 ~(SCA3000_INT_MASK_RING_THREE_QUARTER |
 
1213
                                   SCA3000_INT_MASK_RING_HALF |
 
1214
                                   SCA3000_INT_MASK_ALL_INTS)));
1428
1215
error_ret:
1429
 
        kfree(rx);
 
1216
        mutex_unlock(&st->lock);
1430
1217
        return ret;
1431
 
 
1432
1218
}
1433
1219
 
1434
1220
static int sca3000_remove(struct spi_device *spi)
1441
1227
        if (ret)
1442
1228
                return ret;
1443
1229
        if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0)
1444
 
                iio_unregister_interrupt_line(indio_dev, 0);
 
1230
                free_irq(spi->irq, indio_dev);
1445
1231
        iio_ring_buffer_unregister(indio_dev->ring);
1446
1232
        sca3000_unconfigure_ring(indio_dev);
1447
1233
        iio_device_unregister(indio_dev);
1448
1234
 
1449
 
        kfree(st->tx);
1450
 
        kfree(st->rx);
1451
1235
        kfree(st);
1452
1236
 
1453
1237
        return 0;
1454
1238
}
1455
1239
 
1456
 
/* These macros save on an awful lot of repeated code */
1457
 
#define SCA3000_VARIANT_PROBE(_name)                            \
1458
 
        static int __devinit                                    \
1459
 
        sca3000_##_name##_probe(struct spi_device *spi)         \
1460
 
        {                                                       \
1461
 
                return __sca3000_probe(spi, _name);             \
1462
 
        }
1463
 
 
1464
 
#define SCA3000_VARIANT_SPI_DRIVER(_name)                       \
1465
 
        struct spi_driver sca3000_##_name##_driver = {          \
1466
 
                .driver = {                                     \
1467
 
                        .name = "sca3000_" #_name,              \
1468
 
                        .owner = THIS_MODULE,                   \
1469
 
                },                                              \
1470
 
                .probe = sca3000_##_name##_probe,               \
1471
 
                .remove = __devexit_p(sca3000_remove),          \
1472
 
        }
1473
 
 
1474
 
SCA3000_VARIANT_PROBE(d01);
1475
 
static SCA3000_VARIANT_SPI_DRIVER(d01);
1476
 
 
1477
 
SCA3000_VARIANT_PROBE(e02);
1478
 
static SCA3000_VARIANT_SPI_DRIVER(e02);
1479
 
 
1480
 
SCA3000_VARIANT_PROBE(e04);
1481
 
static SCA3000_VARIANT_SPI_DRIVER(e04);
1482
 
 
1483
 
SCA3000_VARIANT_PROBE(e05);
1484
 
static SCA3000_VARIANT_SPI_DRIVER(e05);
 
1240
static const struct spi_device_id sca3000_id[] = {
 
1241
        {"sca3000_d01", d01},
 
1242
        {"sca3000_e02", e02},
 
1243
        {"sca3000_e04", e04},
 
1244
        {"sca3000_e05", e05},
 
1245
        {}
 
1246
};
 
1247
 
 
1248
static struct spi_driver sca3000_driver = {
 
1249
        .driver = {
 
1250
                .name = "sca3000",
 
1251
                .owner = THIS_MODULE,
 
1252
        },
 
1253
        .probe = sca3000_probe,
 
1254
        .remove = __devexit_p(sca3000_remove),
 
1255
        .id_table = sca3000_id,
 
1256
};
1485
1257
 
1486
1258
static __init int sca3000_init(void)
1487
1259
{
1488
 
        int ret;
1489
 
 
1490
 
        ret = spi_register_driver(&sca3000_d01_driver);
1491
 
        if (ret)
1492
 
                goto error_ret;
1493
 
        ret = spi_register_driver(&sca3000_e02_driver);
1494
 
        if (ret)
1495
 
                goto error_unreg_d01;
1496
 
        ret = spi_register_driver(&sca3000_e04_driver);
1497
 
        if (ret)
1498
 
                goto error_unreg_e02;
1499
 
        ret = spi_register_driver(&sca3000_e05_driver);
1500
 
        if (ret)
1501
 
                goto error_unreg_e04;
1502
 
 
1503
 
        return 0;
1504
 
 
1505
 
error_unreg_e04:
1506
 
        spi_unregister_driver(&sca3000_e04_driver);
1507
 
error_unreg_e02:
1508
 
        spi_unregister_driver(&sca3000_e02_driver);
1509
 
error_unreg_d01:
1510
 
        spi_unregister_driver(&sca3000_d01_driver);
1511
 
error_ret:
1512
 
 
1513
 
        return ret;
 
1260
        return spi_register_driver(&sca3000_driver);
1514
1261
}
 
1262
module_init(sca3000_init);
1515
1263
 
1516
1264
static __exit void sca3000_exit(void)
1517
1265
{
1518
 
        spi_unregister_driver(&sca3000_e05_driver);
1519
 
        spi_unregister_driver(&sca3000_e04_driver);
1520
 
        spi_unregister_driver(&sca3000_e02_driver);
1521
 
        spi_unregister_driver(&sca3000_d01_driver);
 
1266
        spi_unregister_driver(&sca3000_driver);
1522
1267
}
1523
 
 
1524
 
module_init(sca3000_init);
1525
1268
module_exit(sca3000_exit);
1526
1269
 
1527
1270
MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");