← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

Viewing changes to drivers/staging/iio/imu/adis16400_ring.c

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/iio/imu/adis16400_ring.c
9
9
#include <linux/slab.h>
10
10
#include <linux/sysfs.h>
11
11
#include <linux/list.h>
 
12
#include <linux/bitops.h>
12
13
 
13
14
#include "../iio.h"
14
15
#include "../sysfs.h"
17
18
#include "../trigger.h"
18
19
#include "adis16400.h"
19
20
 
20
 
static IIO_SCAN_EL_C(in0_supply, ADIS16400_SCAN_SUPPLY,
21
 
                     ADIS16400_SUPPLY_OUT, NULL);
22
 
static IIO_CONST_ATTR_SCAN_EL_TYPE(in0_supply, u, 14, 16);
23
 
 
24
 
static IIO_SCAN_EL_C(gyro_x, ADIS16400_SCAN_GYRO_X, ADIS16400_XGYRO_OUT, NULL);
25
 
static IIO_SCAN_EL_C(gyro_y, ADIS16400_SCAN_GYRO_Y, ADIS16400_YGYRO_OUT, NULL);
26
 
static IIO_SCAN_EL_C(gyro_z, ADIS16400_SCAN_GYRO_Z, ADIS16400_ZGYRO_OUT, NULL);
27
 
static IIO_CONST_ATTR_SCAN_EL_TYPE(gyro, s, 14, 16);
28
 
 
29
 
static IIO_SCAN_EL_C(accel_x, ADIS16400_SCAN_ACC_X, ADIS16400_XACCL_OUT, NULL);
30
 
static IIO_SCAN_EL_C(accel_y, ADIS16400_SCAN_ACC_Y, ADIS16400_YACCL_OUT, NULL);
31
 
static IIO_SCAN_EL_C(accel_z, ADIS16400_SCAN_ACC_Z, ADIS16400_ZACCL_OUT, NULL);
32
 
static IIO_CONST_ATTR_SCAN_EL_TYPE(accel, s, 14, 16);
33
 
 
34
 
static IIO_SCAN_EL_C(magn_x, ADIS16400_SCAN_MAGN_X, ADIS16400_XMAGN_OUT, NULL);
35
 
static IIO_SCAN_EL_C(magn_y, ADIS16400_SCAN_MAGN_Y, ADIS16400_YMAGN_OUT, NULL);
36
 
static IIO_SCAN_EL_C(magn_z, ADIS16400_SCAN_MAGN_Z, ADIS16400_ZMAGN_OUT, NULL);
37
 
static IIO_CONST_ATTR_SCAN_EL_TYPE(magn, s, 14, 16);
38
 
 
39
 
static IIO_SCAN_EL_C(temp, ADIS16400_SCAN_TEMP, ADIS16400_TEMP_OUT, NULL);
40
 
static IIO_CONST_ATTR_SCAN_EL_TYPE(temp, s, 12, 16);
41
 
 
42
 
static IIO_SCAN_EL_C(in1, ADIS16400_SCAN_ADC_0, ADIS16400_AUX_ADC, NULL);
43
 
static IIO_CONST_ATTR_SCAN_EL_TYPE(in1, u, 12, 16);
44
 
 
45
 
static IIO_SCAN_EL_TIMESTAMP(12);
46
 
static IIO_CONST_ATTR_SCAN_EL_TYPE(timestamp, s, 64, 64);
47
 
 
48
 
static struct attribute *adis16400_scan_el_attrs[] = {
49
 
        &iio_scan_el_in0_supply.dev_attr.attr,
50
 
        &iio_const_attr_in0_supply_index.dev_attr.attr,
51
 
        &iio_const_attr_in0_supply_type.dev_attr.attr,
52
 
        &iio_scan_el_gyro_x.dev_attr.attr,
53
 
        &iio_const_attr_gyro_x_index.dev_attr.attr,
54
 
        &iio_scan_el_gyro_y.dev_attr.attr,
55
 
        &iio_const_attr_gyro_y_index.dev_attr.attr,
56
 
        &iio_scan_el_gyro_z.dev_attr.attr,
57
 
        &iio_const_attr_gyro_z_index.dev_attr.attr,
58
 
        &iio_const_attr_gyro_type.dev_attr.attr,
59
 
        &iio_scan_el_accel_x.dev_attr.attr,
60
 
        &iio_const_attr_accel_x_index.dev_attr.attr,
61
 
        &iio_scan_el_accel_y.dev_attr.attr,
62
 
        &iio_const_attr_accel_y_index.dev_attr.attr,
63
 
        &iio_scan_el_accel_z.dev_attr.attr,
64
 
        &iio_const_attr_accel_z_index.dev_attr.attr,
65
 
        &iio_const_attr_accel_type.dev_attr.attr,
66
 
        &iio_scan_el_magn_x.dev_attr.attr,
67
 
        &iio_const_attr_magn_x_index.dev_attr.attr,
68
 
        &iio_scan_el_magn_y.dev_attr.attr,
69
 
        &iio_const_attr_magn_y_index.dev_attr.attr,
70
 
        &iio_scan_el_magn_z.dev_attr.attr,
71
 
        &iio_const_attr_magn_z_index.dev_attr.attr,
72
 
        &iio_const_attr_magn_type.dev_attr.attr,
73
 
        &iio_scan_el_temp.dev_attr.attr,
74
 
        &iio_const_attr_temp_index.dev_attr.attr,
75
 
        &iio_const_attr_temp_type.dev_attr.attr,
76
 
        &iio_scan_el_in1.dev_attr.attr,
77
 
        &iio_const_attr_in1_index.dev_attr.attr,
78
 
        &iio_const_attr_in1_type.dev_attr.attr,
79
 
        &iio_scan_el_timestamp.dev_attr.attr,
80
 
        &iio_const_attr_timestamp_index.dev_attr.attr,
81
 
        &iio_const_attr_timestamp_type.dev_attr.attr,
82
 
        NULL,
83
 
};
84
 
 
85
 
static struct attribute_group adis16400_scan_el_group = {
86
 
        .attrs = adis16400_scan_el_attrs,
87
 
        .name = "scan_elements",
88
 
};
89
 
 
90
 
/**
91
 
 * adis16400_poll_func_th() top half interrupt handler called by trigger
92
 
 * @private_data:       iio_dev
93
 
 **/
94
 
static void adis16400_poll_func_th(struct iio_dev *indio_dev, s64 time)
95
 
{
96
 
        struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
97
 
        st->last_timestamp = time;
98
 
        schedule_work(&st->work_trigger_to_ring);
99
 
        /* Indicate that this interrupt is being handled */
100
 
 
101
 
        /* Technically this is trigger related, but without this
102
 
         * handler running there is currently no way for the interrupt
103
 
         * to clear.
104
 
         */
105
 
}
106
 
 
107
21
/**
108
22
 * adis16400_spi_read_burst() - read all data registers
109
23
 * @dev: device associated with child of actual device (iio_dev or iio_trig)
113
27
{
114
28
        struct spi_message msg;
115
29
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
116
 
        struct adis16400_state *st = iio_dev_get_devdata(indio_dev);
 
30
        struct adis16400_state *st = iio_priv(indio_dev);
117
31
        u32 old_speed_hz = st->us->max_speed_hz;
118
32
        int ret;
119
33
 
150
64
        return ret;
151
65
}
152
66
 
 
67
static const u16 read_all_tx_array[] = {
 
68
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_SUPPLY_OUT)),
 
69
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_XGYRO_OUT)),
 
70
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_YGYRO_OUT)),
 
71
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_ZGYRO_OUT)),
 
72
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_XACCL_OUT)),
 
73
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_YACCL_OUT)),
 
74
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_ZACCL_OUT)),
 
75
        cpu_to_be16(ADIS16400_READ_REG(ADIS16350_XTEMP_OUT)),
 
76
        cpu_to_be16(ADIS16400_READ_REG(ADIS16350_YTEMP_OUT)),
 
77
        cpu_to_be16(ADIS16400_READ_REG(ADIS16350_ZTEMP_OUT)),
 
78
        cpu_to_be16(ADIS16400_READ_REG(ADIS16400_AUX_ADC)),
 
79
};
 
80
 
 
81
static int adis16350_spi_read_all(struct device *dev, u8 *rx)
 
82
{
 
83
        struct iio_dev *indio_dev = dev_get_drvdata(dev);
 
84
        struct adis16400_state *st = iio_priv(indio_dev);
 
85
 
 
86
        struct spi_message msg;
 
87
        int i, j = 0, ret;
 
88
        struct spi_transfer *xfers;
 
89
 
 
90
        xfers = kzalloc(sizeof(*xfers)*indio_dev->ring->scan_count + 1,
 
91
                        GFP_KERNEL);
 
92
        if (xfers == NULL)
 
93
                return -ENOMEM;
 
94
 
 
95
        for (i = 0; i < ARRAY_SIZE(read_all_tx_array); i++)
 
96
                if (indio_dev->ring->scan_mask & (1 << i)) {
 
97
                        xfers[j].tx_buf = &read_all_tx_array[i];
 
98
                        xfers[j].bits_per_word = 16;
 
99
                        xfers[j].len = 2;
 
100
                        xfers[j + 1].rx_buf = rx + j*2;
 
101
                        j++;
 
102
                }
 
103
        xfers[j].bits_per_word = 16;
 
104
        xfers[j].len = 2;
 
105
 
 
106
        spi_message_init(&msg);
 
107
        for (j = 0; j < indio_dev->ring->scan_count + 1; j++)
 
108
                spi_message_add_tail(&xfers[j], &msg);
 
109
 
 
110
        ret = spi_sync(st->us, &msg);
 
111
        kfree(xfers);
 
112
 
 
113
        return ret;
 
114
}
 
115
 
153
116
/* Whilst this makes a lot of calls to iio_sw_ring functions - it is to device
154
117
 * specific to be rolled into the core.
155
118
 */
156
 
static void adis16400_trigger_bh_to_ring(struct work_struct *work_s)
 
119
static irqreturn_t adis16400_trigger_handler(int irq, void *p)
157
120
{
158
 
        struct adis16400_state *st
159
 
                = container_of(work_s, struct adis16400_state,
160
 
                               work_trigger_to_ring);
161
 
        struct iio_ring_buffer *ring = st->indio_dev->ring;
162
 
 
163
 
        int i = 0, j;
 
121
        struct iio_poll_func *pf = p;
 
122
        struct iio_dev *indio_dev = pf->private_data;
 
123
        struct adis16400_state *st = iio_priv(indio_dev);
 
124
        struct iio_ring_buffer *ring = indio_dev->ring;
 
125
        int i = 0, j, ret = 0;
164
126
        s16 *data;
165
 
        size_t datasize = ring->access.get_bytes_per_datum(ring);
 
127
        size_t datasize = ring->access->get_bytes_per_datum(ring);
166
128
        unsigned long mask = ring->scan_mask;
167
129
 
168
130
        data = kmalloc(datasize , GFP_KERNEL);
169
131
        if (data == NULL) {
170
132
                dev_err(&st->us->dev, "memory alloc failed in ring bh");
171
 
                return;
 
133
                return -ENOMEM;
172
134
        }
173
135
 
174
 
        if (ring->scan_count)
175
 
                if (adis16400_spi_read_burst(&st->indio_dev->dev, st->rx) >= 0)
176
 
                        for (; i < ring->scan_count; i++) {
 
136
        if (ring->scan_count) {
 
137
                if (st->variant->flags & ADIS16400_NO_BURST) {
 
138
                        ret = adis16350_spi_read_all(&indio_dev->dev, st->rx);
 
139
                        if (ret < 0)
 
140
                                goto err;
 
141
                        for (; i < ring->scan_count; i++)
 
142
                                data[i] = *(s16 *)(st->rx + i*2);
 
143
                } else {
 
144
                        ret = adis16400_spi_read_burst(&indio_dev->dev, st->rx);
 
145
                        if (ret < 0)
 
146
                                goto err;
 
147
                        for (; i < indio_dev->ring->scan_count; i++) {
177
148
                                j = __ffs(mask);
178
149
                                mask &= ~(1 << j);
179
 
                                data[i] = be16_to_cpup(
 
150
                                data[i] = be16_to_cpup(
180
151
                                        (__be16 *)&(st->rx[j*2]));
181
152
                        }
182
 
 
 
153
                }
 
154
        }
183
155
        /* Guaranteed to be aligned with 8 byte boundary */
184
156
        if (ring->scan_timestamp)
185
 
                *((s64 *)(data + ((i + 3)/4)*4)) = st->last_timestamp;
186
 
 
187
 
        ring->access.store_to(ring,
188
 
                        (u8 *) data,
189
 
                        st->last_timestamp);
190
 
 
191
 
        iio_trigger_notify_done(st->indio_dev->trig);
192
 
        kfree(data);
193
 
 
194
 
        return;
 
157
                *((s64 *)(data + ((i + 3)/4)*4)) = pf->timestamp;
 
158
        ring->access->store_to(indio_dev->ring, (u8 *) data, pf->timestamp);
 
159
 
 
160
        iio_trigger_notify_done(indio_dev->trig);
 
161
 
 
162
        kfree(data);
 
163
        return IRQ_HANDLED;
 
164
 
 
165
err:
 
166
        kfree(data);
 
167
        return ret;
195
168
}
196
169
 
197
170
void adis16400_unconfigure_ring(struct iio_dev *indio_dev)
198
171
{
199
 
        kfree(indio_dev->pollfunc);
 
172
        iio_dealloc_pollfunc(indio_dev->pollfunc);
200
173
        iio_sw_rb_free(indio_dev->ring);
201
174
}
202
175
 
 
176
static const struct iio_ring_setup_ops adis16400_ring_setup_ops = {
 
177
        .preenable = &iio_sw_ring_preenable,
 
178
        .postenable = &iio_triggered_ring_postenable,
 
179
        .predisable = &iio_triggered_ring_predisable,
 
180
};
 
181
 
203
182
int adis16400_configure_ring(struct iio_dev *indio_dev)
204
183
{
205
184
        int ret = 0;
206
 
        struct adis16400_state *st = indio_dev->dev_data;
 
185
        struct adis16400_state *st = iio_priv(indio_dev);
207
186
        struct iio_ring_buffer *ring;
208
 
        INIT_WORK(&st->work_trigger_to_ring, adis16400_trigger_bh_to_ring);
209
187
 
210
188
        ring = iio_sw_rb_allocate(indio_dev);
211
189
        if (!ring) {
214
192
        }
215
193
        indio_dev->ring = ring;
216
194
        /* Effectively select the ring buffer implementation */
217
 
        iio_ring_sw_register_funcs(&ring->access);
 
195
        ring->access = &ring_sw_access_funcs;
218
196
        ring->bpe = 2;
219
 
        ring->scan_el_attrs = &adis16400_scan_el_group;
220
197
        ring->scan_timestamp = true;
221
 
        ring->preenable = &iio_sw_ring_preenable;
222
 
        ring->postenable = &iio_triggered_ring_postenable;
223
 
        ring->predisable = &iio_triggered_ring_predisable;
 
198
        ring->setup_ops = &adis16400_ring_setup_ops;
224
199
        ring->owner = THIS_MODULE;
225
 
 
226
200
        /* Set default scan mode */
227
 
        iio_scan_mask_set(ring, iio_scan_el_in0_supply.number);
228
 
        iio_scan_mask_set(ring, iio_scan_el_gyro_x.number);
229
 
        iio_scan_mask_set(ring, iio_scan_el_gyro_y.number);
230
 
        iio_scan_mask_set(ring, iio_scan_el_gyro_z.number);
231
 
        iio_scan_mask_set(ring, iio_scan_el_accel_x.number);
232
 
        iio_scan_mask_set(ring, iio_scan_el_accel_y.number);
233
 
        iio_scan_mask_set(ring, iio_scan_el_accel_z.number);
234
 
        iio_scan_mask_set(ring, iio_scan_el_magn_x.number);
235
 
        iio_scan_mask_set(ring, iio_scan_el_magn_y.number);
236
 
        iio_scan_mask_set(ring, iio_scan_el_magn_z.number);
237
 
        iio_scan_mask_set(ring, iio_scan_el_temp.number);
238
 
        iio_scan_mask_set(ring, iio_scan_el_in1.number);
 
201
        ring->scan_mask = st->variant->default_scan_mask;
 
202
        ring->scan_count = hweight_long(st->variant->default_scan_mask);
239
203
 
240
 
        ret = iio_alloc_pollfunc(indio_dev, NULL, &adis16400_poll_func_th);
241
 
        if (ret)
 
204
        indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
 
205
                                                 &adis16400_trigger_handler,
 
206
                                                 IRQF_ONESHOT,
 
207
                                                 indio_dev,
 
208
                                                 "%s_consumer%d",
 
209
                                                 indio_dev->name,
 
210
                                                 indio_dev->id);
 
211
        if (indio_dev->pollfunc == NULL) {
 
212
                ret = -ENOMEM;
242
213
                goto error_iio_sw_rb_free;
 
214
        }
243
215
 
244
216
        indio_dev->modes |= INDIO_RING_TRIGGERED;
245
217
        return 0;
246
 
 
247
218
error_iio_sw_rb_free:
248
219
        iio_sw_rb_free(indio_dev->ring);
249
220
        return ret;