diff options
author | Jonathan Cameron <jic23@cam.ac.uk> | 2011-05-18 09:41:01 -0400 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@suse.de> | 2011-05-19 19:06:13 -0400 |
commit | 25888dc51163a566f8c8f18a84c100851d12738c (patch) | |
tree | 4fad20bf110b3423d96fe968979a04e3cf1a736a /drivers/staging/iio/accel | |
parent | 1e3345bc2c118c43f7f8a6db5d71c06e02b989da (diff) |
staging:iio:sca3000 extract old event handling and move to poll for events from buffer
Fairly substantial rewrite as the code had bitrotted.
A rethink is needed for how to handle variable types in the new chan_spec world.
This patch restores sca3000 buffer usage to a working state.
V3: Rebase fixups.
V2: Move to new version of IIO_CHAN macro
Signed-off-by: Jonathan Cameron <jic23@cam.ac.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/staging/iio/accel')
-rw-r--r-- | drivers/staging/iio/accel/sca3000.h | 76 | ||||
-rw-r--r-- | drivers/staging/iio/accel/sca3000_core.c | 891 | ||||
-rw-r--r-- | drivers/staging/iio/accel/sca3000_ring.c | 252 |
3 files changed, 510 insertions, 709 deletions
diff --git a/drivers/staging/iio/accel/sca3000.h b/drivers/staging/iio/accel/sca3000.h index db710334b99..f77eb74ba19 100644 --- a/drivers/staging/iio/accel/sca3000.h +++ b/drivers/staging/iio/accel/sca3000.h | |||
@@ -158,17 +158,17 @@ | |||
158 | 158 | ||
159 | /** | 159 | /** |
160 | * struct sca3000_state - device instance state information | 160 | * struct sca3000_state - device instance state information |
161 | * @us: the associated spi device | 161 | * @us: the associated spi device |
162 | * @info: chip variant information | 162 | * @info: chip variant information |
163 | * @indio_dev: device information used by the IIO core | 163 | * @indio_dev: device information used by the IIO core |
164 | * @interrupt_handler_ws: event interrupt handler for all events | 164 | * @interrupt_handler_ws: event interrupt handler for all events |
165 | * @last_timestamp: the timestamp of the last event | 165 | * @last_timestamp: the timestamp of the last event |
166 | * @mo_det_use_count: reference counter for the motion detection unit | 166 | * @mo_det_use_count: reference counter for the motion detection unit |
167 | * @lock: lock used to protect elements of sca3000_state | 167 | * @lock: lock used to protect elements of sca3000_state |
168 | * and the underlying device state. | 168 | * and the underlying device state. |
169 | * @bpse: number of bits per scan element | 169 | * @bpse: number of bits per scan element |
170 | * @tx: dma-able transmit buffer | 170 | * @tx: dma-able transmit buffer |
171 | * @rx: dma-able receive buffer | 171 | * @rx: dma-able receive buffer |
172 | **/ | 172 | **/ |
173 | struct sca3000_state { | 173 | struct sca3000_state { |
174 | struct spi_device *us; | 174 | struct spi_device *us; |
@@ -179,15 +179,15 @@ struct sca3000_state { | |||
179 | int mo_det_use_count; | 179 | int mo_det_use_count; |
180 | struct mutex lock; | 180 | struct mutex lock; |
181 | int bpse; | 181 | int bpse; |
182 | u8 *tx; | 182 | /* Can these share a cacheline ? */ |
183 | /* not used during a ring buffer read */ | 183 | u8 rx[2] ____cacheline_aligned; |
184 | u8 *rx; | 184 | u8 tx[6] ____cacheline_aligned; |
185 | }; | 185 | }; |
186 | 186 | ||
187 | /** | 187 | /** |
188 | * struct sca3000_chip_info - model dependent parameters | 188 | * struct sca3000_chip_info - model dependent parameters |
189 | * @name: model identification | 189 | * @name: model identification |
190 | * @scale: string containing floating point scale factor | 190 | * @scale: scale * 10^-6 |
191 | * @temp_output: some devices have temperature sensors. | 191 | * @temp_output: some devices have temperature sensors. |
192 | * @measurement_mode_freq: normal mode sampling frequency | 192 | * @measurement_mode_freq: normal mode sampling frequency |
193 | * @option_mode_1: first optional mode. Not all models have one | 193 | * @option_mode_1: first optional mode. Not all models have one |
@@ -200,29 +200,20 @@ struct sca3000_state { | |||
200 | **/ | 200 | **/ |
201 | struct sca3000_chip_info { | 201 | struct sca3000_chip_info { |
202 | const char *name; | 202 | const char *name; |
203 | const char *scale; | 203 | unsigned int scale; |
204 | bool temp_output; | 204 | bool temp_output; |
205 | int measurement_mode_freq; | 205 | int measurement_mode_freq; |
206 | int option_mode_1; | 206 | int option_mode_1; |
207 | int option_mode_1_freq; | 207 | int option_mode_1_freq; |
208 | int option_mode_2; | 208 | int option_mode_2; |
209 | int option_mode_2_freq; | 209 | int option_mode_2_freq; |
210 | int mot_det_mult_xz[6]; | ||
211 | int mot_det_mult_y[7]; | ||
210 | }; | 212 | }; |
211 | 213 | ||
212 | /** | 214 | int sca3000_read_data_short(struct sca3000_state *st, |
213 | * sca3000_read_data() read a series of values from the device | 215 | u8 reg_address_high, |
214 | * @dev: device | 216 | int len); |
215 | * @reg_address_high: start address (decremented read) | ||
216 | * @rx: pointer where received data is placed. Callee | ||
217 | * responsible for freeing this. | ||
218 | * @len: number of bytes to read | ||
219 | * | ||
220 | * The main lock must be held. | ||
221 | **/ | ||
222 | int sca3000_read_data(struct sca3000_state *st, | ||
223 | u8 reg_address_high, | ||
224 | u8 **rx_p, | ||
225 | int len); | ||
226 | 217 | ||
227 | /** | 218 | /** |
228 | * sca3000_write_reg() write a single register | 219 | * sca3000_write_reg() write a single register |
@@ -233,29 +224,6 @@ int sca3000_read_data(struct sca3000_state *st, | |||
233 | **/ | 224 | **/ |
234 | int sca3000_write_reg(struct sca3000_state *st, u8 address, u8 val); | 225 | int sca3000_write_reg(struct sca3000_state *st, u8 address, u8 val); |
235 | 226 | ||
236 | /* Conversion function for use with the ring buffer when in 11bit mode */ | ||
237 | static inline int sca3000_11bit_convert(uint8_t msb, uint8_t lsb) | ||
238 | { | ||
239 | int16_t val; | ||
240 | |||
241 | val = ((lsb >> 3) & 0x1C) | (msb << 5); | ||
242 | val |= (val & (1 << 12)) ? 0xE000 : 0; | ||
243 | |||
244 | return val; | ||
245 | } | ||
246 | |||
247 | static inline int sca3000_13bit_convert(uint8_t msb, uint8_t lsb) | ||
248 | { | ||
249 | s16 val; | ||
250 | |||
251 | val = ((lsb >> 3) & 0x1F) | (msb << 5); | ||
252 | /* sign fill */ | ||
253 | val |= (val & (1 << 12)) ? 0xE000 : 0; | ||
254 | |||
255 | return val; | ||
256 | } | ||
257 | |||
258 | |||
259 | #ifdef CONFIG_IIO_RING_BUFFER | 227 | #ifdef CONFIG_IIO_RING_BUFFER |
260 | /** | 228 | /** |
261 | * sca3000_register_ring_funcs() setup the ring state change functions | 229 | * sca3000_register_ring_funcs() setup the ring state change functions |
diff --git a/drivers/staging/iio/accel/sca3000_core.c b/drivers/staging/iio/accel/sca3000_core.c index 6abf2b7e306..00704a5269f 100644 --- a/drivers/staging/iio/accel/sca3000_core.c +++ b/drivers/staging/iio/accel/sca3000_core.c | |||
@@ -42,93 +42,73 @@ enum sca3000_variant { | |||
42 | static const struct sca3000_chip_info sca3000_spi_chip_info_tbl[] = { | 42 | static const struct sca3000_chip_info sca3000_spi_chip_info_tbl[] = { |
43 | { | 43 | { |
44 | .name = "sca3000-d01", | 44 | .name = "sca3000-d01", |
45 | .scale = " 0.0073575", | 45 | .scale = 7357, |
46 | .temp_output = true, | 46 | .temp_output = true, |
47 | .measurement_mode_freq = 250, | 47 | .measurement_mode_freq = 250, |
48 | .option_mode_1 = SCA3000_OP_MODE_BYPASS, | 48 | .option_mode_1 = SCA3000_OP_MODE_BYPASS, |
49 | .option_mode_1_freq = 250, | 49 | .option_mode_1_freq = 250, |
50 | .mot_det_mult_xz = {50, 100, 200, 350, 650, 1300}, | ||
51 | .mot_det_mult_y = {50, 100, 150, 250, 450, 850, 1750}, | ||
50 | }, { | 52 | }, { |
51 | .name = "sca3000-e02", | 53 | .name = "sca3000-e02", |
52 | .scale = "0.00981", | 54 | .scale = 9810, |
53 | .measurement_mode_freq = 125, | 55 | .measurement_mode_freq = 125, |
54 | .option_mode_1 = SCA3000_OP_MODE_NARROW, | 56 | .option_mode_1 = SCA3000_OP_MODE_NARROW, |
55 | .option_mode_1_freq = 63, | 57 | .option_mode_1_freq = 63, |
58 | .mot_det_mult_xz = {100, 150, 300, 550, 1050, 2050}, | ||
59 | .mot_det_mult_y = {50, 100, 200, 350, 700, 1350, 2700}, | ||
56 | }, { | 60 | }, { |
57 | .name = "sca3000-e04", | 61 | .name = "sca3000-e04", |
58 | .scale = "0.01962", | 62 | .scale = 19620, |
59 | .measurement_mode_freq = 100, | 63 | .measurement_mode_freq = 100, |
60 | .option_mode_1 = SCA3000_OP_MODE_NARROW, | 64 | .option_mode_1 = SCA3000_OP_MODE_NARROW, |
61 | .option_mode_1_freq = 50, | 65 | .option_mode_1_freq = 50, |
62 | .option_mode_2 = SCA3000_OP_MODE_WIDE, | 66 | .option_mode_2 = SCA3000_OP_MODE_WIDE, |
63 | .option_mode_2_freq = 400, | 67 | .option_mode_2_freq = 400, |
68 | .mot_det_mult_xz = {200, 300, 600, 1100, 2100, 4100}, | ||
69 | .mot_det_mult_y = {100, 200, 400, 7000, 1400, 2700, 54000}, | ||
64 | }, { | 70 | }, { |
65 | .name = "sca3000-e05", | 71 | .name = "sca3000-e05", |
66 | .scale = "0.0613125", | 72 | .scale = 61313, |
67 | .measurement_mode_freq = 200, | 73 | .measurement_mode_freq = 200, |
68 | .option_mode_1 = SCA3000_OP_MODE_NARROW, | 74 | .option_mode_1 = SCA3000_OP_MODE_NARROW, |
69 | .option_mode_1_freq = 50, | 75 | .option_mode_1_freq = 50, |
70 | .option_mode_2 = SCA3000_OP_MODE_WIDE, | 76 | .option_mode_2 = SCA3000_OP_MODE_WIDE, |
71 | .option_mode_2_freq = 400, | 77 | .option_mode_2_freq = 400, |
78 | .mot_det_mult_xz = {600, 900, 1700, 3200, 6100, 11900}, | ||
79 | .mot_det_mult_y = {300, 600, 1200, 2000, 4100, 7800, 15600}, | ||
72 | }, | 80 | }, |
73 | }; | 81 | }; |
74 | 82 | ||
75 | |||
76 | int sca3000_write_reg(struct sca3000_state *st, u8 address, u8 val) | 83 | int sca3000_write_reg(struct sca3000_state *st, u8 address, u8 val) |
77 | { | 84 | { |
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 | st->tx[0] = SCA3000_WRITE_REG(address); | 85 | st->tx[0] = SCA3000_WRITE_REG(address); |
87 | st->tx[1] = val; | 86 | st->tx[1] = val; |
88 | spi_message_init(&msg); | 87 | return spi_write(st->us, st->tx, 2); |
89 | spi_message_add_tail(&xfer, &msg); | ||
90 | |||
91 | return spi_sync(st->us, &msg); | ||
92 | } | 88 | } |
93 | 89 | ||
94 | int sca3000_read_data(struct sca3000_state *st, | 90 | int sca3000_read_data_short(struct sca3000_state *st, |
95 | uint8_t reg_address_high, | 91 | uint8_t reg_address_high, |
96 | u8 **rx_p, | 92 | int len) |
97 | int len) | ||
98 | { | 93 | { |
99 | int ret; | ||
100 | struct spi_message msg; | 94 | struct spi_message msg; |
101 | struct spi_transfer xfer = { | 95 | struct spi_transfer xfer[2] = { |
102 | .bits_per_word = 8, | 96 | { |
103 | .len = len + 1, | 97 | .len = 1, |
104 | .cs_change = 1, | 98 | .tx_buf = st->tx, |
105 | .tx_buf = st->tx, | 99 | }, { |
100 | .len = len, | ||
101 | .rx_buf = st->rx, | ||
102 | } | ||
106 | }; | 103 | }; |
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 | st->tx[0] = SCA3000_READ_REG(reg_address_high); | 104 | st->tx[0] = SCA3000_READ_REG(reg_address_high); |
115 | spi_message_init(&msg); | 105 | spi_message_init(&msg); |
116 | spi_message_add_tail(&xfer, &msg); | 106 | spi_message_add_tail(&xfer[0], &msg); |
117 | 107 | spi_message_add_tail(&xfer[1], &msg); | |
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 | 108 | ||
109 | return spi_sync(st->us, &msg); | ||
131 | } | 110 | } |
111 | |||
132 | /** | 112 | /** |
133 | * sca3000_reg_lock_on() test if the ctrl register lock is on | 113 | * sca3000_reg_lock_on() test if the ctrl register lock is on |
134 | * | 114 | * |
@@ -136,17 +116,13 @@ error_ret: | |||
136 | **/ | 116 | **/ |
137 | static int sca3000_reg_lock_on(struct sca3000_state *st) | 117 | static int sca3000_reg_lock_on(struct sca3000_state *st) |
138 | { | 118 | { |
139 | u8 *rx; | ||
140 | int ret; | 119 | int ret; |
141 | 120 | ||
142 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_STATUS, &rx, 1); | 121 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_STATUS, 1); |
143 | |||
144 | if (ret < 0) | 122 | if (ret < 0) |
145 | return ret; | 123 | return ret; |
146 | ret = !(rx[1] & SCA3000_LOCKED); | ||
147 | kfree(rx); | ||
148 | 124 | ||
149 | return ret; | 125 | return !(st->rx[0] & SCA3000_LOCKED); |
150 | } | 126 | } |
151 | 127 | ||
152 | /** | 128 | /** |
@@ -161,19 +137,15 @@ static int __sca3000_unlock_reg_lock(struct sca3000_state *st) | |||
161 | struct spi_message msg; | 137 | struct spi_message msg; |
162 | struct spi_transfer xfer[3] = { | 138 | struct spi_transfer xfer[3] = { |
163 | { | 139 | { |
164 | .bits_per_word = 8, | ||
165 | .len = 2, | 140 | .len = 2, |
166 | .cs_change = 1, | 141 | .cs_change = 1, |
167 | .tx_buf = st->tx, | 142 | .tx_buf = st->tx, |
168 | }, { | 143 | }, { |
169 | .bits_per_word = 8, | ||
170 | .len = 2, | 144 | .len = 2, |
171 | .cs_change = 1, | 145 | .cs_change = 1, |
172 | .tx_buf = st->tx + 2, | 146 | .tx_buf = st->tx + 2, |
173 | }, { | 147 | }, { |
174 | .bits_per_word = 8, | ||
175 | .len = 2, | 148 | .len = 2, |
176 | .cs_change = 1, | ||
177 | .tx_buf = st->tx + 4, | 149 | .tx_buf = st->tx + 4, |
178 | }, | 150 | }, |
179 | }; | 151 | }; |
@@ -236,8 +208,7 @@ error_ret: | |||
236 | * Lock must be held. | 208 | * Lock must be held. |
237 | **/ | 209 | **/ |
238 | static int sca3000_read_ctrl_reg(struct sca3000_state *st, | 210 | static int sca3000_read_ctrl_reg(struct sca3000_state *st, |
239 | u8 ctrl_reg, | 211 | u8 ctrl_reg) |
240 | u8 **rx_p) | ||
241 | { | 212 | { |
242 | int ret; | 213 | int ret; |
243 | 214 | ||
@@ -253,8 +224,11 @@ static int sca3000_read_ctrl_reg(struct sca3000_state *st, | |||
253 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_SEL, ctrl_reg); | 224 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_CTRL_SEL, ctrl_reg); |
254 | if (ret) | 225 | if (ret) |
255 | goto error_ret; | 226 | goto error_ret; |
256 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_CTRL_DATA, rx_p, 1); | 227 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_CTRL_DATA, 1); |
257 | 228 | if (ret) | |
229 | goto error_ret; | ||
230 | else | ||
231 | return st->rx[0]; | ||
258 | error_ret: | 232 | error_ret: |
259 | return ret; | 233 | return ret; |
260 | } | 234 | } |
@@ -267,20 +241,18 @@ error_ret: | |||
267 | **/ | 241 | **/ |
268 | static int sca3000_check_status(struct device *dev) | 242 | static int sca3000_check_status(struct device *dev) |
269 | { | 243 | { |
270 | u8 *rx; | ||
271 | int ret; | 244 | int ret; |
272 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | 245 | struct iio_dev *indio_dev = dev_get_drvdata(dev); |
273 | struct sca3000_state *st = indio_dev->dev_data; | 246 | struct sca3000_state *st = indio_dev->dev_data; |
274 | 247 | ||
275 | mutex_lock(&st->lock); | 248 | mutex_lock(&st->lock); |
276 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_STATUS, &rx, 1); | 249 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_STATUS, 1); |
277 | if (ret < 0) | 250 | if (ret < 0) |
278 | goto error_ret; | 251 | goto error_ret; |
279 | if (rx[1] & SCA3000_EEPROM_CS_ERROR) | 252 | if (st->rx[0] & SCA3000_EEPROM_CS_ERROR) |
280 | dev_err(dev, "eeprom error\n"); | 253 | dev_err(dev, "eeprom error\n"); |
281 | if (rx[1] & SCA3000_SPI_FRAME_ERROR) | 254 | if (st->rx[0] & SCA3000_SPI_FRAME_ERROR) |
282 | dev_err(dev, "Previous SPI Frame was corrupt\n"); | 255 | dev_err(dev, "Previous SPI Frame was corrupt\n"); |
283 | kfree(rx); | ||
284 | 256 | ||
285 | error_ret: | 257 | error_ret: |
286 | mutex_unlock(&st->lock); | 258 | mutex_unlock(&st->lock); |
@@ -288,45 +260,6 @@ error_ret: | |||
288 | } | 260 | } |
289 | #endif /* SCA3000_DEBUG */ | 261 | #endif /* SCA3000_DEBUG */ |
290 | 262 | ||
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, | 263 | static ssize_t sca3000_show_name(struct device *dev, |
331 | struct device_attribute *attr, | 264 | struct device_attribute *attr, |
332 | char *buf) | 265 | char *buf) |
@@ -346,18 +279,14 @@ static ssize_t sca3000_show_rev(struct device *dev, | |||
346 | struct iio_dev *dev_info = dev_get_drvdata(dev); | 279 | struct iio_dev *dev_info = dev_get_drvdata(dev); |
347 | struct sca3000_state *st = dev_info->dev_data; | 280 | struct sca3000_state *st = dev_info->dev_data; |
348 | 281 | ||
349 | u8 *rx; | ||
350 | |||
351 | mutex_lock(&st->lock); | 282 | mutex_lock(&st->lock); |
352 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_REVID, &rx, 1); | 283 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_REVID, 1); |
353 | if (ret < 0) | 284 | if (ret < 0) |
354 | goto error_ret; | 285 | goto error_ret; |
355 | len += sprintf(buf + len, | 286 | len += sprintf(buf + len, |
356 | "major=%d, minor=%d\n", | 287 | "major=%d, minor=%d\n", |
357 | rx[1] & SCA3000_REVID_MAJOR_MASK, | 288 | st->rx[0] & SCA3000_REVID_MAJOR_MASK, |
358 | rx[1] & SCA3000_REVID_MINOR_MASK); | 289 | st->rx[0] & SCA3000_REVID_MINOR_MASK); |
359 | kfree(rx); | ||
360 | |||
361 | error_ret: | 290 | error_ret: |
362 | mutex_unlock(&st->lock); | 291 | mutex_unlock(&st->lock); |
363 | 292 | ||
@@ -410,15 +339,14 @@ sca3000_show_measurement_mode(struct device *dev, | |||
410 | struct iio_dev *dev_info = dev_get_drvdata(dev); | 339 | struct iio_dev *dev_info = dev_get_drvdata(dev); |
411 | struct sca3000_state *st = dev_info->dev_data; | 340 | struct sca3000_state *st = dev_info->dev_data; |
412 | int len = 0, ret; | 341 | int len = 0, ret; |
413 | u8 *rx; | ||
414 | 342 | ||
415 | mutex_lock(&st->lock); | 343 | mutex_lock(&st->lock); |
416 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 344 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
417 | if (ret) | 345 | if (ret) |
418 | goto error_ret; | 346 | goto error_ret; |
419 | /* mask bottom 2 bits - only ones that are relevant */ | 347 | /* mask bottom 2 bits - only ones that are relevant */ |
420 | rx[1] &= 0x03; | 348 | st->rx[0] &= 0x03; |
421 | switch (rx[1]) { | 349 | switch (st->rx[0]) { |
422 | case SCA3000_MEAS_MODE_NORMAL: | 350 | case SCA3000_MEAS_MODE_NORMAL: |
423 | len += sprintf(buf + len, "0 - normal mode\n"); | 351 | len += sprintf(buf + len, "0 - normal mode\n"); |
424 | break; | 352 | break; |
@@ -462,7 +390,6 @@ sca3000_store_measurement_mode(struct device *dev, | |||
462 | struct iio_dev *dev_info = dev_get_drvdata(dev); | 390 | struct iio_dev *dev_info = dev_get_drvdata(dev); |
463 | struct sca3000_state *st = dev_info->dev_data; | 391 | struct sca3000_state *st = dev_info->dev_data; |
464 | int ret; | 392 | int ret; |
465 | u8 *rx; | ||
466 | int mask = 0x03; | 393 | int mask = 0x03; |
467 | long val; | 394 | long val; |
468 | 395 | ||
@@ -470,20 +397,18 @@ sca3000_store_measurement_mode(struct device *dev, | |||
470 | ret = strict_strtol(buf, 10, &val); | 397 | ret = strict_strtol(buf, 10, &val); |
471 | if (ret) | 398 | if (ret) |
472 | goto error_ret; | 399 | goto error_ret; |
473 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 400 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
474 | if (ret) | 401 | if (ret) |
475 | goto error_ret; | 402 | goto error_ret; |
476 | rx[1] &= ~mask; | 403 | st->rx[0] &= ~mask; |
477 | rx[1] |= (val & mask); | 404 | st->rx[0] |= (val & mask); |
478 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, rx[1]); | 405 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, st->rx[0]); |
479 | if (ret) | 406 | if (ret) |
480 | goto error_free_rx; | 407 | goto error_ret; |
481 | mutex_unlock(&st->lock); | 408 | mutex_unlock(&st->lock); |
482 | 409 | ||
483 | return len; | 410 | return len; |
484 | 411 | ||
485 | error_free_rx: | ||
486 | kfree(rx); | ||
487 | error_ret: | 412 | error_ret: |
488 | mutex_unlock(&st->lock); | 413 | mutex_unlock(&st->lock); |
489 | 414 | ||
@@ -507,16 +432,72 @@ static IIO_DEVICE_ATTR(measurement_mode, S_IRUGO | S_IWUSR, | |||
507 | 432 | ||
508 | static IIO_DEV_ATTR_NAME(sca3000_show_name); | 433 | static IIO_DEV_ATTR_NAME(sca3000_show_name); |
509 | static IIO_DEV_ATTR_REV(sca3000_show_rev); | 434 | static IIO_DEV_ATTR_REV(sca3000_show_rev); |
510 | static IIO_DEVICE_ATTR(accel_scale, S_IRUGO, sca3000_show_scale, | ||
511 | NULL, 0); | ||
512 | 435 | ||
513 | static IIO_DEV_ATTR_ACCEL_X(sca3000_read_13bit_signed, | 436 | #define SCA3000_INFO_MASK \ |
514 | SCA3000_REG_ADDR_X_MSB); | 437 | (1 << IIO_CHAN_INFO_SCALE_SHARED) |
515 | static IIO_DEV_ATTR_ACCEL_Y(sca3000_read_13bit_signed, | 438 | #define SCA3000_EVENT_MASK \ |
516 | SCA3000_REG_ADDR_Y_MSB); | 439 | (IIO_EV_BIT(IIO_EV_TYPE_MAG, IIO_EV_DIR_RISING)) |
517 | static IIO_DEV_ATTR_ACCEL_Z(sca3000_read_13bit_signed, | 440 | |
518 | SCA3000_REG_ADDR_Z_MSB); | 441 | static struct iio_chan_spec sca3000_channels[] = { |
442 | IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_X, SCA3000_INFO_MASK, | ||
443 | 0, 0, IIO_ST('s', 11, 16, 5), | ||
444 | SCA3000_EVENT_MASK, NULL), | ||
445 | IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Y, SCA3000_INFO_MASK, | ||
446 | 1, 1, IIO_ST('s', 11, 16, 5), | ||
447 | SCA3000_EVENT_MASK, NULL), | ||
448 | IIO_CHAN(IIO_ACCEL, 1, 0, 0, NULL, 0, IIO_MOD_Z, SCA3000_INFO_MASK, | ||
449 | 2, 2, IIO_ST('s', 11, 16, 5), | ||
450 | SCA3000_EVENT_MASK, NULL), | ||
451 | }; | ||
519 | 452 | ||
453 | static u8 sca3000_addresses[3][3] = { | ||
454 | [0] = {SCA3000_REG_ADDR_X_MSB, SCA3000_REG_CTRL_SEL_MD_X_TH, | ||
455 | SCA3000_MD_CTRL_OR_X}, | ||
456 | [1] = {SCA3000_REG_ADDR_Y_MSB, SCA3000_REG_CTRL_SEL_MD_Y_TH, | ||
457 | SCA3000_MD_CTRL_OR_Y}, | ||
458 | [2] = {SCA3000_REG_ADDR_Z_MSB, SCA3000_REG_CTRL_SEL_MD_Z_TH, | ||
459 | SCA3000_MD_CTRL_OR_Z}, | ||
460 | }; | ||
461 | |||
462 | static int sca3000_read_raw(struct iio_dev *indio_dev, | ||
463 | struct iio_chan_spec const *chan, | ||
464 | int *val, | ||
465 | int *val2, | ||
466 | long mask) | ||
467 | { | ||
468 | struct sca3000_state *st = indio_dev->dev_data; | ||
469 | int ret; | ||
470 | u8 address; | ||
471 | |||
472 | switch (mask) { | ||
473 | case 0: | ||
474 | mutex_lock(&st->lock); | ||
475 | if (st->mo_det_use_count) { | ||
476 | mutex_unlock(&st->lock); | ||
477 | return -EBUSY; | ||
478 | } | ||
479 | address = sca3000_addresses[chan->address][0]; | ||
480 | ret = sca3000_read_data_short(st, address, 2); | ||
481 | if (ret < 0) { | ||
482 | mutex_unlock(&st->lock); | ||
483 | return ret; | ||
484 | } | ||
485 | *val = (be16_to_cpup((__be16 *)st->rx) >> 3) & 0x1FFF; | ||
486 | *val = ((*val) << (sizeof(*val)*8 - 13)) >> | ||
487 | (sizeof(*val)*8 - 13); | ||
488 | mutex_unlock(&st->lock); | ||
489 | return IIO_VAL_INT; | ||
490 | case (1 << IIO_CHAN_INFO_SCALE_SHARED): | ||
491 | *val = 0; | ||
492 | if (chan->type == IIO_ACCEL) | ||
493 | *val2 = st->info->scale; | ||
494 | else /* temperature */ | ||
495 | *val2 = 555556; | ||
496 | return IIO_VAL_INT_PLUS_MICRO; | ||
497 | default: | ||
498 | return -EINVAL; | ||
499 | } | ||
500 | } | ||
520 | 501 | ||
521 | /** | 502 | /** |
522 | * sca3000_read_av_freq() sysfs function to get available frequencies | 503 | * sca3000_read_av_freq() sysfs function to get available frequencies |
@@ -532,15 +513,16 @@ static ssize_t sca3000_read_av_freq(struct device *dev, | |||
532 | { | 513 | { |
533 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | 514 | struct iio_dev *indio_dev = dev_get_drvdata(dev); |
534 | struct sca3000_state *st = indio_dev->dev_data; | 515 | struct sca3000_state *st = indio_dev->dev_data; |
535 | int len = 0, ret; | 516 | int len = 0, ret, val; |
536 | u8 *rx; | 517 | |
537 | mutex_lock(&st->lock); | 518 | mutex_lock(&st->lock); |
538 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 519 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
520 | val = st->rx[0]; | ||
539 | mutex_unlock(&st->lock); | 521 | mutex_unlock(&st->lock); |
540 | if (ret) | 522 | if (ret) |
541 | goto error_ret; | 523 | goto error_ret; |
542 | rx[1] &= 0x03; | 524 | |
543 | switch (rx[1]) { | 525 | switch (val & 0x03) { |
544 | case SCA3000_MEAS_MODE_NORMAL: | 526 | case SCA3000_MEAS_MODE_NORMAL: |
545 | len += sprintf(buf + len, "%d %d %d\n", | 527 | len += sprintf(buf + len, "%d %d %d\n", |
546 | st->info->measurement_mode_freq, | 528 | st->info->measurement_mode_freq, |
@@ -560,7 +542,6 @@ static ssize_t sca3000_read_av_freq(struct device *dev, | |||
560 | st->info->option_mode_2_freq/4); | 542 | st->info->option_mode_2_freq/4); |
561 | break; | 543 | break; |
562 | } | 544 | } |
563 | kfree(rx); | ||
564 | return len; | 545 | return len; |
565 | error_ret: | 546 | error_ret: |
566 | return ret; | 547 | return ret; |
@@ -575,12 +556,11 @@ static inline int __sca3000_get_base_freq(struct sca3000_state *st, | |||
575 | int *base_freq) | 556 | int *base_freq) |
576 | { | 557 | { |
577 | int ret; | 558 | int ret; |
578 | u8 *rx; | ||
579 | 559 | ||
580 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 560 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
581 | if (ret) | 561 | if (ret) |
582 | goto error_ret; | 562 | goto error_ret; |
583 | switch (0x03 & rx[1]) { | 563 | switch (0x03 & st->rx[0]) { |
584 | case SCA3000_MEAS_MODE_NORMAL: | 564 | case SCA3000_MEAS_MODE_NORMAL: |
585 | *base_freq = info->measurement_mode_freq; | 565 | *base_freq = info->measurement_mode_freq; |
586 | break; | 566 | break; |
@@ -591,7 +571,6 @@ static inline int __sca3000_get_base_freq(struct sca3000_state *st, | |||
591 | *base_freq = info->option_mode_2_freq; | 571 | *base_freq = info->option_mode_2_freq; |
592 | break; | 572 | break; |
593 | } | 573 | } |
594 | kfree(rx); | ||
595 | error_ret: | 574 | error_ret: |
596 | return ret; | 575 | return ret; |
597 | } | 576 | } |
@@ -605,18 +584,19 @@ static ssize_t sca3000_read_frequency(struct device *dev, | |||
605 | { | 584 | { |
606 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | 585 | struct iio_dev *indio_dev = dev_get_drvdata(dev); |
607 | struct sca3000_state *st = indio_dev->dev_data; | 586 | struct sca3000_state *st = indio_dev->dev_data; |
608 | int ret, len = 0, base_freq = 0; | 587 | int ret, len = 0, base_freq = 0, val; |
609 | u8 *rx; | 588 | |
610 | mutex_lock(&st->lock); | 589 | mutex_lock(&st->lock); |
611 | ret = __sca3000_get_base_freq(st, st->info, &base_freq); | 590 | ret = __sca3000_get_base_freq(st, st->info, &base_freq); |
612 | if (ret) | 591 | if (ret) |
613 | goto error_ret_mut; | 592 | goto error_ret_mut; |
614 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, &rx); | 593 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL); |
615 | mutex_unlock(&st->lock); | 594 | mutex_unlock(&st->lock); |
616 | if (ret) | 595 | if (ret) |
617 | goto error_ret; | 596 | goto error_ret; |
597 | val = ret; | ||
618 | if (base_freq > 0) | 598 | if (base_freq > 0) |
619 | switch (rx[1]&0x03) { | 599 | switch (val & 0x03) { |
620 | case 0x00: | 600 | case 0x00: |
621 | case 0x03: | 601 | case 0x03: |
622 | len = sprintf(buf, "%d\n", base_freq); | 602 | len = sprintf(buf, "%d\n", base_freq); |
@@ -628,7 +608,7 @@ static ssize_t sca3000_read_frequency(struct device *dev, | |||
628 | len = sprintf(buf, "%d\n", base_freq/4); | 608 | len = sprintf(buf, "%d\n", base_freq/4); |
629 | break; | 609 | break; |
630 | } | 610 | } |
631 | kfree(rx); | 611 | |
632 | return len; | 612 | return len; |
633 | error_ret_mut: | 613 | error_ret_mut: |
634 | mutex_unlock(&st->lock); | 614 | mutex_unlock(&st->lock); |
@@ -647,7 +627,7 @@ static ssize_t sca3000_set_frequency(struct device *dev, | |||
647 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | 627 | struct iio_dev *indio_dev = dev_get_drvdata(dev); |
648 | struct sca3000_state *st = indio_dev->dev_data; | 628 | struct sca3000_state *st = indio_dev->dev_data; |
649 | int ret, base_freq = 0; | 629 | int ret, base_freq = 0; |
650 | u8 *rx; | 630 | int ctrlval; |
651 | long val; | 631 | long val; |
652 | 632 | ||
653 | ret = strict_strtol(buf, 10, &val); | 633 | ret = strict_strtol(buf, 10, &val); |
@@ -660,21 +640,23 @@ static ssize_t sca3000_set_frequency(struct device *dev, | |||
660 | if (ret) | 640 | if (ret) |
661 | goto error_free_lock; | 641 | goto error_free_lock; |
662 | 642 | ||
663 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, &rx); | 643 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL); |
664 | if (ret) | 644 | if (ret < 0) |
665 | goto error_free_lock; | 645 | goto error_free_lock; |
646 | ctrlval = ret; | ||
666 | /* clear the bits */ | 647 | /* clear the bits */ |
667 | rx[1] &= ~0x03; | 648 | ctrlval &= ~0x03; |
668 | 649 | ||
669 | if (val == base_freq/2) { | 650 | if (val == base_freq/2) { |
670 | rx[1] |= SCA3000_OUT_CTRL_BUF_DIV_2; | 651 | ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_2; |
671 | } else if (val == base_freq/4) { | 652 | } else if (val == base_freq/4) { |
672 | rx[1] |= SCA3000_OUT_CTRL_BUF_DIV_4; | 653 | ctrlval |= SCA3000_OUT_CTRL_BUF_DIV_4; |
673 | } else if (val != base_freq) { | 654 | } else if (val != base_freq) { |
674 | ret = -EINVAL; | 655 | ret = -EINVAL; |
675 | goto error_free_lock; | 656 | goto error_free_lock; |
676 | } | 657 | } |
677 | ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, rx[1]); | 658 | ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, |
659 | ctrlval); | ||
678 | error_free_lock: | 660 | error_free_lock: |
679 | mutex_unlock(&st->lock); | 661 | mutex_unlock(&st->lock); |
680 | 662 | ||
@@ -704,17 +686,14 @@ static ssize_t sca3000_read_temp(struct device *dev, | |||
704 | { | 686 | { |
705 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | 687 | struct iio_dev *indio_dev = dev_get_drvdata(dev); |
706 | struct sca3000_state *st = indio_dev->dev_data; | 688 | struct sca3000_state *st = indio_dev->dev_data; |
707 | int len = 0, ret; | 689 | int ret; |
708 | int val; | 690 | int val; |
709 | u8 *rx; | 691 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_TEMP_MSB, 2); |
710 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_TEMP_MSB, &rx, 2); | ||
711 | if (ret < 0) | 692 | if (ret < 0) |
712 | goto error_ret; | 693 | goto error_ret; |
713 | val = ((rx[1]&0x3F) << 3) | ((rx[2] & 0xE0) >> 5); | 694 | val = ((st->rx[0] & 0x3F) << 3) | ((st->rx[1] & 0xE0) >> 5); |
714 | len += sprintf(buf + len, "%d\n", val); | ||
715 | kfree(rx); | ||
716 | 695 | ||
717 | return len; | 696 | return sprintf(buf, "%d\n", val); |
718 | 697 | ||
719 | error_ret: | 698 | error_ret: |
720 | return ret; | 699 | return ret; |
@@ -725,80 +704,72 @@ static IIO_CONST_ATTR_TEMP_SCALE("0.555556"); | |||
725 | static IIO_CONST_ATTR_TEMP_OFFSET("-214.6"); | 704 | static IIO_CONST_ATTR_TEMP_OFFSET("-214.6"); |
726 | 705 | ||
727 | /** | 706 | /** |
728 | * sca3000_show_thresh() sysfs query of a threshold | 707 | * sca3000_read_thresh() - query of a threshold |
729 | **/ | 708 | **/ |
730 | static ssize_t sca3000_show_thresh(struct device *dev, | 709 | static int sca3000_read_thresh(struct iio_dev *indio_dev, |
731 | struct device_attribute *attr, | 710 | int e, |
732 | char *buf) | 711 | int *val) |
733 | { | 712 | { |
734 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | 713 | int ret, i; |
735 | struct sca3000_state *st = indio_dev->dev_data; | 714 | struct sca3000_state *st = indio_dev->dev_data; |
736 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); | 715 | int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e); |
737 | int len = 0, ret; | ||
738 | u8 *rx; | ||
739 | |||
740 | mutex_lock(&st->lock); | 716 | mutex_lock(&st->lock); |
741 | ret = sca3000_read_ctrl_reg(st, | 717 | ret = sca3000_read_ctrl_reg(st, sca3000_addresses[num][1]); |
742 | this_attr->address, | ||
743 | &rx); | ||
744 | mutex_unlock(&st->lock); | 718 | mutex_unlock(&st->lock); |
745 | if (ret) | 719 | if (ret < 0) |
746 | return ret; | 720 | return ret; |
747 | len += sprintf(buf + len, "%d\n", rx[1]); | 721 | *val = 0; |
748 | kfree(rx); | 722 | if (num == 1) |
723 | for_each_set_bit(i, (unsigned long *)&ret, | ||
724 | ARRAY_SIZE(st->info->mot_det_mult_y)) | ||
725 | *val += st->info->mot_det_mult_y[i]; | ||
726 | else | ||
727 | for_each_set_bit(i, (unsigned long *)&ret, | ||
728 | ARRAY_SIZE(st->info->mot_det_mult_xz)) | ||
729 | *val += st->info->mot_det_mult_xz[i]; | ||
749 | 730 | ||
750 | return len; | 731 | return 0; |
751 | } | 732 | } |
752 | 733 | ||
753 | /** | 734 | /** |
754 | * sca3000_write_thresh() sysfs control of threshold | 735 | * sca3000_write_thresh() control of threshold |
755 | **/ | 736 | **/ |
756 | static ssize_t sca3000_write_thresh(struct device *dev, | 737 | static int sca3000_write_thresh(struct iio_dev *indio_dev, |
757 | struct device_attribute *attr, | 738 | int e, |
758 | const char *buf, | 739 | int val) |
759 | size_t len) | ||
760 | { | 740 | { |
761 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | ||
762 | struct sca3000_state *st = indio_dev->dev_data; | 741 | struct sca3000_state *st = indio_dev->dev_data; |
763 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); | 742 | int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e); |
764 | int ret; | 743 | int ret; |
765 | long val; | 744 | int i; |
745 | u8 nonlinear = 0; | ||
746 | |||
747 | if (num == 1) { | ||
748 | i = ARRAY_SIZE(st->info->mot_det_mult_y); | ||
749 | while (i > 0) | ||
750 | if (val >= st->info->mot_det_mult_y[--i]) { | ||
751 | nonlinear |= (1 << i); | ||
752 | val -= st->info->mot_det_mult_y[i]; | ||
753 | } | ||
754 | } else { | ||
755 | i = ARRAY_SIZE(st->info->mot_det_mult_xz); | ||
756 | while (i > 0) | ||
757 | if (val >= st->info->mot_det_mult_xz[--i]) { | ||
758 | nonlinear |= (1 << i); | ||
759 | val -= st->info->mot_det_mult_xz[i]; | ||
760 | } | ||
761 | } | ||
766 | 762 | ||
767 | ret = strict_strtol(buf, 10, &val); | ||
768 | if (ret) | ||
769 | return ret; | ||
770 | mutex_lock(&st->lock); | 763 | mutex_lock(&st->lock); |
771 | ret = sca3000_write_ctrl_reg(st, this_attr->address, val); | 764 | ret = sca3000_write_ctrl_reg(st, sca3000_addresses[num][1], nonlinear); |
772 | mutex_unlock(&st->lock); | 765 | mutex_unlock(&st->lock); |
773 | 766 | ||
774 | return ret ? ret : len; | 767 | return ret; |
775 | } | 768 | } |
776 | 769 | ||
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 | static struct attribute *sca3000_attributes[] = { | 770 | static struct attribute *sca3000_attributes[] = { |
796 | &iio_dev_attr_name.dev_attr.attr, | 771 | &iio_dev_attr_name.dev_attr.attr, |
797 | &iio_dev_attr_revision.dev_attr.attr, | 772 | &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 | &iio_dev_attr_measurement_mode_available.dev_attr.attr, | 773 | &iio_dev_attr_measurement_mode_available.dev_attr.attr, |
803 | &iio_dev_attr_measurement_mode.dev_attr.attr, | 774 | &iio_dev_attr_measurement_mode.dev_attr.attr, |
804 | &iio_dev_attr_sampling_frequency_available.dev_attr.attr, | 775 | &iio_dev_attr_sampling_frequency_available.dev_attr.attr, |
@@ -809,10 +780,6 @@ static struct attribute *sca3000_attributes[] = { | |||
809 | static struct attribute *sca3000_attributes_with_temp[] = { | 780 | static struct attribute *sca3000_attributes_with_temp[] = { |
810 | &iio_dev_attr_name.dev_attr.attr, | 781 | &iio_dev_attr_name.dev_attr.attr, |
811 | &iio_dev_attr_revision.dev_attr.attr, | 782 | &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 | &iio_dev_attr_measurement_mode_available.dev_attr.attr, | 783 | &iio_dev_attr_measurement_mode_available.dev_attr.attr, |
817 | &iio_dev_attr_measurement_mode.dev_attr.attr, | 784 | &iio_dev_attr_measurement_mode.dev_attr.attr, |
818 | &iio_dev_attr_sampling_frequency_available.dev_attr.attr, | 785 | &iio_dev_attr_sampling_frequency_available.dev_attr.attr, |
@@ -836,134 +803,102 @@ static const struct attribute_group sca3000_attribute_group_with_temp = { | |||
836 | /* depending on event, push to the ring buffer event chrdev or the event one */ | 803 | /* depending on event, push to the ring buffer event chrdev or the event one */ |
837 | 804 | ||
838 | /** | 805 | /** |
839 | * sca3000_interrupt_handler_bh() - handling ring and non ring events | 806 | * sca3000_event_handler() - handling ring and non ring events |
840 | * | 807 | * |
841 | * This function is complicated by the fact that the devices can signify ring | 808 | * This function is complicated by the fact that the devices can signify ring |
842 | * and non ring events via the same interrupt line and they can only | 809 | * and non ring events via the same interrupt line and they can only |
843 | * be distinguished via a read of the relevant status register. | 810 | * be distinguished via a read of the relevant status register. |
844 | **/ | 811 | **/ |
845 | static void sca3000_interrupt_handler_bh(struct work_struct *work_s) | 812 | static irqreturn_t sca3000_event_handler(int irq, void *private) |
846 | { | 813 | { |
847 | struct sca3000_state *st | 814 | struct iio_dev *indio_dev = private; |
848 | = container_of(work_s, struct sca3000_state, | 815 | struct sca3000_state *st; |
849 | interrupt_handler_ws); | 816 | int ret, val; |
850 | u8 *rx; | 817 | s64 last_timestamp = iio_get_time_ns(); |
851 | int ret; | ||
852 | 818 | ||
819 | st = indio_dev->dev_data; | ||
853 | /* Could lead if badly timed to an extra read of status reg, | 820 | /* Could lead if badly timed to an extra read of status reg, |
854 | * but ensures no interrupt is missed. | 821 | * but ensures no interrupt is missed. |
855 | */ | 822 | */ |
856 | enable_irq(st->us->irq); | ||
857 | mutex_lock(&st->lock); | 823 | mutex_lock(&st->lock); |
858 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_STATUS, | 824 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1); |
859 | &rx, 1); | 825 | val = st->rx[0]; |
860 | mutex_unlock(&st->lock); | 826 | mutex_unlock(&st->lock); |
861 | if (ret) | 827 | if (ret) |
862 | goto done; | 828 | goto done; |
863 | 829 | ||
864 | sca3000_ring_int_process(rx[1], st->indio_dev->ring); | 830 | sca3000_ring_int_process(val, st->indio_dev->ring); |
865 | 831 | ||
866 | if (rx[1] & SCA3000_INT_STATUS_FREE_FALL) | 832 | if (val & SCA3000_INT_STATUS_FREE_FALL) |
867 | iio_push_event(st->indio_dev, 0, | 833 | iio_push_event(st->indio_dev, 0, |
868 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, | 834 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, |
869 | 0, | 835 | 0, |
870 | IIO_EV_MOD_X_AND_Y_AND_Z, | 836 | IIO_EV_MOD_X_AND_Y_AND_Z, |
871 | IIO_EV_TYPE_MAG, | 837 | IIO_EV_TYPE_MAG, |
872 | IIO_EV_DIR_FALLING), | 838 | IIO_EV_DIR_FALLING), |
873 | st->last_timestamp); | 839 | last_timestamp); |
874 | 840 | ||
875 | if (rx[1] & SCA3000_INT_STATUS_Y_TRIGGER) | 841 | if (val & SCA3000_INT_STATUS_Y_TRIGGER) |
876 | iio_push_event(st->indio_dev, 0, | 842 | iio_push_event(st->indio_dev, 0, |
877 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, | 843 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, |
878 | 0, | 844 | 0, |
879 | IIO_EV_MOD_Y, | 845 | IIO_EV_MOD_Y, |
880 | IIO_EV_TYPE_MAG, | 846 | IIO_EV_TYPE_MAG, |
881 | IIO_EV_DIR_RISING), | 847 | IIO_EV_DIR_RISING), |
882 | st->last_timestamp); | 848 | last_timestamp); |
883 | 849 | ||
884 | if (rx[1] & SCA3000_INT_STATUS_X_TRIGGER) | 850 | if (val & SCA3000_INT_STATUS_X_TRIGGER) |
885 | iio_push_event(st->indio_dev, 0, | 851 | iio_push_event(st->indio_dev, 0, |
886 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, | 852 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, |
887 | 0, | 853 | 0, |
888 | IIO_EV_MOD_X, | 854 | IIO_EV_MOD_X, |
889 | IIO_EV_TYPE_MAG, | 855 | IIO_EV_TYPE_MAG, |
890 | IIO_EV_DIR_RISING), | 856 | IIO_EV_DIR_RISING), |
891 | st->last_timestamp); | 857 | last_timestamp); |
892 | 858 | ||
893 | if (rx[1] & SCA3000_INT_STATUS_Z_TRIGGER) | 859 | if (val & SCA3000_INT_STATUS_Z_TRIGGER) |
894 | iio_push_event(st->indio_dev, 0, | 860 | iio_push_event(st->indio_dev, 0, |
895 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, | 861 | IIO_MOD_EVENT_CODE(IIO_EV_CLASS_ACCEL, |
896 | 0, | 862 | 0, |
897 | IIO_EV_MOD_Z, | 863 | IIO_EV_MOD_Z, |
898 | IIO_EV_TYPE_MAG, | 864 | IIO_EV_TYPE_MAG, |
899 | IIO_EV_DIR_RISING), | 865 | IIO_EV_DIR_RISING), |
900 | st->last_timestamp); | 866 | last_timestamp); |
901 | 867 | ||
902 | done: | 868 | done: |
903 | kfree(rx); | 869 | return IRQ_HANDLED; |
904 | return; | ||
905 | } | 870 | } |
906 | 871 | ||
907 | /** | 872 | /** |
908 | * sca3000_handler_th() handles all interrupt events from device | 873 | * sca3000_read_event_config() what events are enabled |
909 | * | ||
910 | * These devices deploy unified interrupt status registers meaning | ||
911 | * all interrupts must be handled together | ||
912 | **/ | 874 | **/ |
913 | static int sca3000_handler_th(struct iio_dev *dev_info, | 875 | static int sca3000_read_event_config(struct iio_dev *indio_dev, |
914 | int index, | 876 | int e) |
915 | s64 timestamp, | ||
916 | int no_test) | ||
917 | { | 877 | { |
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); | ||
937 | struct sca3000_state *st = indio_dev->dev_data; | 878 | struct sca3000_state *st = indio_dev->dev_data; |
938 | struct iio_event_attr *this_attr = to_iio_event_attr(attr); | 879 | int ret; |
939 | int ret, len = 0; | ||
940 | u8 *rx; | ||
941 | u8 protect_mask = 0x03; | 880 | u8 protect_mask = 0x03; |
881 | int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e); | ||
942 | 882 | ||
943 | /* read current value of mode register */ | 883 | /* read current value of mode register */ |
944 | mutex_lock(&st->lock); | 884 | mutex_lock(&st->lock); |
945 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 885 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
946 | if (ret) | 886 | if (ret) |
947 | goto error_ret; | 887 | goto error_ret; |
948 | 888 | ||
949 | if ((rx[1]&protect_mask) != SCA3000_MEAS_MODE_MOT_DET) | 889 | if ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET) |
950 | len += sprintf(buf + len, "0\n"); | 890 | ret = 0; |
951 | else { | 891 | else { |
952 | kfree(rx); | 892 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL); |
953 | ret = sca3000_read_ctrl_reg(st, | 893 | if (ret < 0) |
954 | SCA3000_REG_CTRL_SEL_MD_CTRL, | ||
955 | &rx); | ||
956 | if (ret) | ||
957 | goto error_ret; | 894 | goto error_ret; |
958 | /* only supporting logical or's for now */ | 895 | /* only supporting logical or's for now */ |
959 | len += sprintf(buf + len, "%d\n", | 896 | ret = !!(ret & sca3000_addresses[num][2]); |
960 | (rx[1] & this_attr->mask) ? 1 : 0); | ||
961 | } | 897 | } |
962 | kfree(rx); | ||
963 | error_ret: | 898 | error_ret: |
964 | mutex_unlock(&st->lock); | 899 | mutex_unlock(&st->lock); |
965 | 900 | ||
966 | return ret ? ret : len; | 901 | return ret; |
967 | } | 902 | } |
968 | /** | 903 | /** |
969 | * sca3000_query_free_fall_mode() is free fall mode enabled | 904 | * sca3000_query_free_fall_mode() is free fall mode enabled |
@@ -973,80 +908,20 @@ static ssize_t sca3000_query_free_fall_mode(struct device *dev, | |||
973 | char *buf) | 908 | char *buf) |
974 | { | 909 | { |
975 | int ret, len; | 910 | int ret, len; |
976 | u8 *rx; | ||
977 | struct iio_dev *indio_dev = dev_get_drvdata(dev); | 911 | struct iio_dev *indio_dev = dev_get_drvdata(dev); |
978 | struct sca3000_state *st = indio_dev->dev_data; | 912 | struct sca3000_state *st = indio_dev->dev_data; |
913 | int val; | ||
979 | 914 | ||
980 | mutex_lock(&st->lock); | 915 | mutex_lock(&st->lock); |
981 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 916 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
917 | val = st->rx[0]; | ||
982 | mutex_unlock(&st->lock); | 918 | mutex_unlock(&st->lock); |
983 | if (ret) | 919 | if (ret < 0) |
984 | return ret; | 920 | return ret; |
985 | len = sprintf(buf, "%d\n", | 921 | len = sprintf(buf, "%d\n", |
986 | !!(rx[1] & SCA3000_FREE_FALL_DETECT)); | 922 | !!(val & SCA3000_FREE_FALL_DETECT)); |
987 | kfree(rx); | ||
988 | |||
989 | return len; | 923 | return len; |
990 | } | 924 | } |
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; | ||
1049 | } | ||
1050 | 925 | ||
1051 | /** | 926 | /** |
1052 | * sca3000_set_free_fall_mode() simple on off control for free fall int | 927 | * sca3000_set_free_fall_mode() simple on off control for free fall int |
@@ -1065,7 +940,6 @@ static ssize_t sca3000_set_free_fall_mode(struct device *dev, | |||
1065 | struct sca3000_state *st = indio_dev->dev_data; | 940 | struct sca3000_state *st = indio_dev->dev_data; |
1066 | long val; | 941 | long val; |
1067 | int ret; | 942 | int ret; |
1068 | u8 *rx; | ||
1069 | u8 protect_mask = SCA3000_FREE_FALL_DETECT; | 943 | u8 protect_mask = SCA3000_FREE_FALL_DETECT; |
1070 | 944 | ||
1071 | mutex_lock(&st->lock); | 945 | mutex_lock(&st->lock); |
@@ -1074,20 +948,18 @@ static ssize_t sca3000_set_free_fall_mode(struct device *dev, | |||
1074 | goto error_ret; | 948 | goto error_ret; |
1075 | 949 | ||
1076 | /* read current value of mode register */ | 950 | /* read current value of mode register */ |
1077 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 951 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
1078 | if (ret) | 952 | if (ret) |
1079 | goto error_ret; | 953 | goto error_ret; |
1080 | 954 | ||
1081 | /*if off and should be on*/ | 955 | /*if off and should be on*/ |
1082 | if (val && !(rx[1] & protect_mask)) | 956 | if (val && !(st->rx[0] & protect_mask)) |
1083 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | 957 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, |
1084 | (rx[1] | SCA3000_FREE_FALL_DETECT)); | 958 | (st->rx[0] | SCA3000_FREE_FALL_DETECT)); |
1085 | /* if on and should be off */ | 959 | /* if on and should be off */ |
1086 | else if (!val && (rx[1]&protect_mask)) | 960 | else if (!val && (st->rx[0] & protect_mask)) |
1087 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | 961 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, |
1088 | (rx[1] & ~protect_mask)); | 962 | (st->rx[0] & ~protect_mask)); |
1089 | |||
1090 | kfree(rx); | ||
1091 | error_ret: | 963 | error_ret: |
1092 | mutex_unlock(&st->lock); | 964 | mutex_unlock(&st->lock); |
1093 | 965 | ||
@@ -1103,73 +975,65 @@ error_ret: | |||
1103 | * There is a complexity in knowing which mode to return to when | 975 | * There is a complexity in knowing which mode to return to when |
1104 | * this mode is disabled. Currently normal mode is assumed. | 976 | * this mode is disabled. Currently normal mode is assumed. |
1105 | **/ | 977 | **/ |
1106 | static ssize_t sca3000_set_mo_det(struct device *dev, | 978 | static int sca3000_write_event_config(struct iio_dev *indio_dev, |
1107 | struct device_attribute *attr, | 979 | int e, |
1108 | const char *buf, | 980 | struct iio_event_handler_list *list_el, |
1109 | size_t len) | 981 | int state) |
1110 | { | 982 | { |
1111 | struct iio_dev *indio_dev = dev_get_drvdata(dev->parent); | ||
1112 | struct sca3000_state *st = indio_dev->dev_data; | 983 | struct sca3000_state *st = indio_dev->dev_data; |
1113 | struct iio_event_attr *this_attr = to_iio_event_attr(attr); | 984 | int ret, ctrlval; |
1114 | long val; | ||
1115 | int ret; | ||
1116 | u8 *rx; | ||
1117 | u8 protect_mask = 0x03; | 985 | u8 protect_mask = 0x03; |
1118 | ret = strict_strtol(buf, 10, &val); | 986 | int num = IIO_EVENT_CODE_EXTRACT_MODIFIER(e); |
1119 | if (ret) | ||
1120 | return ret; | ||
1121 | 987 | ||
1122 | mutex_lock(&st->lock); | 988 | mutex_lock(&st->lock); |
1123 | /* First read the motion detector config to find out if | 989 | /* First read the motion detector config to find out if |
1124 | * this axis is on*/ | 990 | * this axis is on*/ |
1125 | ret = sca3000_read_ctrl_reg(st, | 991 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL); |
1126 | SCA3000_REG_CTRL_SEL_MD_CTRL, | 992 | if (ret < 0) |
1127 | &rx); | ||
1128 | if (ret) | ||
1129 | goto exit_point; | 993 | goto exit_point; |
994 | ctrlval = ret; | ||
1130 | /* Off and should be on */ | 995 | /* Off and should be on */ |
1131 | if (val && !(rx[1] & this_attr->mask)) { | 996 | if (state && !(ctrlval & sca3000_addresses[num][2])) { |
1132 | ret = sca3000_write_ctrl_reg(st, | 997 | ret = sca3000_write_ctrl_reg(st, |
1133 | SCA3000_REG_CTRL_SEL_MD_CTRL, | 998 | SCA3000_REG_CTRL_SEL_MD_CTRL, |
1134 | rx[1] | this_attr->mask); | 999 | ctrlval | |
1000 | sca3000_addresses[num][2]); | ||
1135 | if (ret) | 1001 | if (ret) |
1136 | goto exit_point_free_rx; | 1002 | goto exit_point; |
1137 | st->mo_det_use_count++; | 1003 | st->mo_det_use_count++; |
1138 | } else if (!val && (rx[1]&this_attr->mask)) { | 1004 | } else if (!state && (ctrlval & sca3000_addresses[num][2])) { |
1139 | ret = sca3000_write_ctrl_reg(st, | 1005 | ret = sca3000_write_ctrl_reg(st, |
1140 | SCA3000_REG_CTRL_SEL_MD_CTRL, | 1006 | SCA3000_REG_CTRL_SEL_MD_CTRL, |
1141 | rx[1] & ~(this_attr->mask)); | 1007 | ctrlval & |
1008 | ~(sca3000_addresses[num][2])); | ||
1142 | if (ret) | 1009 | if (ret) |
1143 | goto exit_point_free_rx; | 1010 | goto exit_point; |
1144 | st->mo_det_use_count--; | 1011 | st->mo_det_use_count--; |
1145 | } else /* relies on clean state for device on boot */ | 1012 | } |
1146 | goto exit_point_free_rx; | 1013 | |
1147 | kfree(rx); | ||
1148 | /* read current value of mode register */ | 1014 | /* read current value of mode register */ |
1149 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 1015 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
1150 | if (ret) | 1016 | if (ret) |
1151 | goto exit_point; | 1017 | goto exit_point; |
1152 | /*if off and should be on*/ | 1018 | /*if off and should be on*/ |
1153 | if ((st->mo_det_use_count) | 1019 | if ((st->mo_det_use_count) |
1154 | && ((rx[1]&protect_mask) != SCA3000_MEAS_MODE_MOT_DET)) | 1020 | && ((st->rx[0] & protect_mask) != SCA3000_MEAS_MODE_MOT_DET)) |
1155 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | 1021 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, |
1156 | (rx[1] & ~protect_mask) | 1022 | (st->rx[0] & ~protect_mask) |
1157 | | SCA3000_MEAS_MODE_MOT_DET); | 1023 | | SCA3000_MEAS_MODE_MOT_DET); |
1158 | /* if on and should be off */ | 1024 | /* if on and should be off */ |
1159 | else if (!(st->mo_det_use_count) | 1025 | else if (!(st->mo_det_use_count) |
1160 | && ((rx[1]&protect_mask) == SCA3000_MEAS_MODE_MOT_DET)) | 1026 | && ((st->rx[0] & protect_mask) == SCA3000_MEAS_MODE_MOT_DET)) |
1161 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | 1027 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, |
1162 | (rx[1] & ~protect_mask)); | 1028 | (st->rx[0] & ~protect_mask)); |
1163 | exit_point_free_rx: | ||
1164 | kfree(rx); | ||
1165 | exit_point: | 1029 | exit_point: |
1166 | mutex_unlock(&st->lock); | 1030 | mutex_unlock(&st->lock); |
1167 | 1031 | ||
1168 | return ret ? ret : len; | 1032 | return ret; |
1169 | } | 1033 | } |
1170 | 1034 | ||
1171 | /* Shared event handler for all events as single event status register */ | 1035 | /* Shared event handler for all events as single event status register */ |
1172 | IIO_EVENT_SH(all, &sca3000_handler_th); | 1036 | IIO_EVENT_SH(all, NULL); |
1173 | 1037 | ||
1174 | /* Free fall detector related event attribute */ | 1038 | /* Free fall detector related event attribute */ |
1175 | IIO_EVENT_ATTR_NAMED_SH(accel_xayaz_mag_falling_en, | 1039 | IIO_EVENT_ATTR_NAMED_SH(accel_xayaz_mag_falling_en, |
@@ -1179,51 +1043,13 @@ IIO_EVENT_ATTR_NAMED_SH(accel_xayaz_mag_falling_en, | |||
1179 | sca3000_set_free_fall_mode, | 1043 | sca3000_set_free_fall_mode, |
1180 | 0); | 1044 | 0); |
1181 | 1045 | ||
1182 | IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period, | 1046 | static IIO_CONST_ATTR_NAMED(accel_xayaz_mag_falling_period, |
1183 | accel_x&y&z_mag_falling_period, | 1047 | accel_x&y&z_mag_falling_period, |
1184 | "0.226"); | 1048 | "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); | ||
1215 | 1049 | ||
1216 | static struct attribute *sca3000_event_attributes[] = { | 1050 | static struct attribute *sca3000_event_attributes[] = { |
1217 | &iio_event_attr_accel_xayaz_mag_falling_en.dev_attr.attr, | 1051 | &iio_event_attr_accel_xayaz_mag_falling_en.dev_attr.attr, |
1218 | &iio_const_attr_accel_xayaz_mag_falling_period.dev_attr.attr, | 1052 | &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 | NULL, | 1053 | NULL, |
1228 | }; | 1054 | }; |
1229 | 1055 | ||
@@ -1241,70 +1067,50 @@ static struct attribute_group sca3000_event_attribute_group = { | |||
1241 | static int sca3000_clean_setup(struct sca3000_state *st) | 1067 | static int sca3000_clean_setup(struct sca3000_state *st) |
1242 | { | 1068 | { |
1243 | int ret; | 1069 | int ret; |
1244 | u8 *rx; | ||
1245 | 1070 | ||
1246 | mutex_lock(&st->lock); | 1071 | mutex_lock(&st->lock); |
1247 | /* Ensure all interrupts have been acknowledged */ | 1072 | /* Ensure all interrupts have been acknowledged */ |
1248 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_STATUS, &rx, 1); | 1073 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_STATUS, 1); |
1249 | if (ret) | 1074 | if (ret) |
1250 | goto error_ret; | 1075 | goto error_ret; |
1251 | kfree(rx); | ||
1252 | 1076 | ||
1253 | /* Turn off all motion detection channels */ | 1077 | /* Turn off all motion detection channels */ |
1254 | ret = sca3000_read_ctrl_reg(st, | 1078 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL); |
1255 | SCA3000_REG_CTRL_SEL_MD_CTRL, | 1079 | if (ret < 0) |
1256 | &rx); | ||
1257 | if (ret) | ||
1258 | goto error_ret; | 1080 | goto error_ret; |
1259 | ret = sca3000_write_ctrl_reg(st, | 1081 | ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_MD_CTRL, |
1260 | SCA3000_REG_CTRL_SEL_MD_CTRL, | 1082 | ret & SCA3000_MD_CTRL_PROT_MASK); |
1261 | rx[1] & SCA3000_MD_CTRL_PROT_MASK); | ||
1262 | kfree(rx); | ||
1263 | if (ret) | 1083 | if (ret) |
1264 | goto error_ret; | 1084 | goto error_ret; |
1265 | 1085 | ||
1266 | /* Disable ring buffer */ | 1086 | /* Disable ring buffer */ |
1267 | sca3000_read_ctrl_reg(st, | 1087 | ret = sca3000_read_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL); |
1268 | SCA3000_REG_CTRL_SEL_OUT_CTRL, | 1088 | ret = sca3000_write_ctrl_reg(st, SCA3000_REG_CTRL_SEL_OUT_CTRL, |
1269 | &rx); | 1089 | (ret & SCA3000_OUT_CTRL_PROT_MASK) |
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) | ||
1275 | | SCA3000_OUT_CTRL_BUF_X_EN | 1090 | | SCA3000_OUT_CTRL_BUF_X_EN |
1276 | | SCA3000_OUT_CTRL_BUF_Y_EN | 1091 | | SCA3000_OUT_CTRL_BUF_Y_EN |
1277 | | SCA3000_OUT_CTRL_BUF_Z_EN | 1092 | | SCA3000_OUT_CTRL_BUF_Z_EN |
1278 | | SCA3000_OUT_CTRL_BUF_DIV_4); | 1093 | | SCA3000_OUT_CTRL_BUF_DIV_4); |
1279 | kfree(rx); | ||
1280 | |||
1281 | if (ret) | 1094 | if (ret) |
1282 | goto error_ret; | 1095 | goto error_ret; |
1283 | /* Enable interrupts, relevant to mode and set up as active low */ | 1096 | /* Enable interrupts, relevant to mode and set up as active low */ |
1284 | ret = sca3000_read_data(st, | 1097 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1); |
1285 | SCA3000_REG_ADDR_INT_MASK, | ||
1286 | &rx, 1); | ||
1287 | if (ret) | 1098 | if (ret) |
1288 | goto error_ret; | 1099 | goto error_ret; |
1289 | ret = sca3000_write_reg(st, | 1100 | ret = sca3000_write_reg(st, |
1290 | SCA3000_REG_ADDR_INT_MASK, | 1101 | SCA3000_REG_ADDR_INT_MASK, |
1291 | (rx[1] & SCA3000_INT_MASK_PROT_MASK) | 1102 | (ret & SCA3000_INT_MASK_PROT_MASK) |
1292 | | SCA3000_INT_MASK_ACTIVE_LOW); | 1103 | | SCA3000_INT_MASK_ACTIVE_LOW); |
1293 | kfree(rx); | ||
1294 | if (ret) | 1104 | if (ret) |
1295 | goto error_ret; | 1105 | goto error_ret; |
1296 | /* Select normal measurement mode, free fall off, ring off */ | 1106 | /* Select normal measurement mode, free fall off, ring off */ |
1297 | /* Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5 | 1107 | /* Ring in 12 bit mode - it is fine to overwrite reserved bits 3,5 |
1298 | * as that occurs in one of the example on the datasheet */ | 1108 | * as that occurs in one of the example on the datasheet */ |
1299 | ret = sca3000_read_data(st, | 1109 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
1300 | SCA3000_REG_ADDR_MODE, | ||
1301 | &rx, 1); | ||
1302 | if (ret) | 1110 | if (ret) |
1303 | goto error_ret; | 1111 | goto error_ret; |
1304 | ret = sca3000_write_reg(st, | 1112 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, |
1305 | SCA3000_REG_ADDR_MODE, | 1113 | (st->rx[0] & SCA3000_MODE_PROT_MASK)); |
1306 | (rx[1] & SCA3000_MODE_PROT_MASK)); | ||
1307 | kfree(rx); | ||
1308 | st->bpse = 11; | 1114 | st->bpse = 11; |
1309 | 1115 | ||
1310 | error_ret: | 1116 | error_ret: |
@@ -1312,8 +1118,7 @@ error_ret: | |||
1312 | return ret; | 1118 | return ret; |
1313 | } | 1119 | } |
1314 | 1120 | ||
1315 | static int __devinit __sca3000_probe(struct spi_device *spi, | 1121 | static int __devinit sca3000_probe(struct spi_device *spi) |
1316 | enum sca3000_variant variant) | ||
1317 | { | 1122 | { |
1318 | int ret, regdone = 0; | 1123 | int ret, regdone = 0; |
1319 | struct sca3000_state *st; | 1124 | struct sca3000_state *st; |
@@ -1325,75 +1130,63 @@ static int __devinit __sca3000_probe(struct spi_device *spi, | |||
1325 | } | 1130 | } |
1326 | spi_set_drvdata(spi, st); | 1131 | spi_set_drvdata(spi, st); |
1327 | 1132 | ||
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 | st->us = spi; | 1133 | st->us = spi; |
1339 | mutex_init(&st->lock); | 1134 | mutex_init(&st->lock); |
1340 | st->info = &sca3000_spi_chip_info_tbl[variant]; | 1135 | st->info = &sca3000_spi_chip_info_tbl[spi_get_device_id(spi) |
1136 | ->driver_data]; | ||
1341 | 1137 | ||
1342 | st->indio_dev = iio_allocate_device(0); | 1138 | st->indio_dev = iio_allocate_device(0); |
1343 | if (st->indio_dev == NULL) { | 1139 | if (st->indio_dev == NULL) { |
1344 | ret = -ENOMEM; | 1140 | ret = -ENOMEM; |
1345 | goto error_free_rx; | 1141 | goto error_clear_st; |
1346 | } | 1142 | } |
1347 | |||
1348 | st->indio_dev->dev.parent = &spi->dev; | 1143 | st->indio_dev->dev.parent = &spi->dev; |
1349 | st->indio_dev->num_interrupt_lines = 1; | 1144 | st->indio_dev->num_interrupt_lines = 1; |
1350 | st->indio_dev->event_attrs = &sca3000_event_attribute_group; | 1145 | st->indio_dev->event_attrs = &sca3000_event_attribute_group; |
1351 | if (st->info->temp_output) | 1146 | if (st->info->temp_output) |
1352 | st->indio_dev->attrs = &sca3000_attribute_group_with_temp; | 1147 | st->indio_dev->attrs = &sca3000_attribute_group_with_temp; |
1353 | else | 1148 | else { |
1354 | st->indio_dev->attrs = &sca3000_attribute_group; | 1149 | st->indio_dev->attrs = &sca3000_attribute_group; |
1150 | st->indio_dev->channels = sca3000_channels; | ||
1151 | st->indio_dev->num_channels = ARRAY_SIZE(sca3000_channels); | ||
1152 | } | ||
1153 | st->indio_dev->read_raw = &sca3000_read_raw; | ||
1154 | st->indio_dev->read_event_value = &sca3000_read_thresh; | ||
1155 | st->indio_dev->write_event_value = &sca3000_write_thresh; | ||
1156 | st->indio_dev->read_event_config = &sca3000_read_event_config; | ||
1157 | st->indio_dev->write_event_config = &sca3000_write_event_config; | ||
1355 | st->indio_dev->dev_data = (void *)(st); | 1158 | st->indio_dev->dev_data = (void *)(st); |
1356 | st->indio_dev->modes = INDIO_DIRECT_MODE; | 1159 | st->indio_dev->modes = INDIO_DIRECT_MODE; |
1357 | 1160 | ||
1358 | sca3000_configure_ring(st->indio_dev); | 1161 | sca3000_configure_ring(st->indio_dev); |
1359 | |||
1360 | ret = iio_device_register(st->indio_dev); | 1162 | ret = iio_device_register(st->indio_dev); |
1361 | if (ret < 0) | 1163 | if (ret < 0) |
1362 | goto error_free_dev; | 1164 | goto error_free_dev; |
1363 | regdone = 1; | 1165 | regdone = 1; |
1364 | ret = iio_ring_buffer_register(st->indio_dev->ring, 0); | 1166 | ret = iio_ring_buffer_register_ex(st->indio_dev->ring, 0, |
1167 | sca3000_channels, | ||
1168 | ARRAY_SIZE(sca3000_channels)); | ||
1365 | if (ret < 0) | 1169 | if (ret < 0) |
1366 | goto error_unregister_dev; | 1170 | goto error_unregister_dev; |
1367 | if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) { | 1171 | if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) { |
1368 | INIT_WORK(&st->interrupt_handler_ws, | 1172 | ret = request_threaded_irq(spi->irq, |
1369 | sca3000_interrupt_handler_bh); | 1173 | NULL, |
1370 | ret = iio_register_interrupt_line(spi->irq, | 1174 | &sca3000_event_handler, |
1371 | st->indio_dev, | 1175 | IRQF_TRIGGER_FALLING, |
1372 | 0, | 1176 | "sca3000", |
1373 | IRQF_TRIGGER_FALLING, | 1177 | st->indio_dev); |
1374 | "sca3000"); | ||
1375 | if (ret) | 1178 | if (ret) |
1376 | goto error_unregister_ring; | 1179 | 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 | } | 1180 | } |
1388 | sca3000_register_ring_funcs(st->indio_dev); | 1181 | sca3000_register_ring_funcs(st->indio_dev); |
1389 | ret = sca3000_clean_setup(st); | 1182 | ret = sca3000_clean_setup(st); |
1390 | if (ret) | 1183 | if (ret) |
1391 | goto error_unregister_interrupt_line; | 1184 | goto error_free_irq; |
1392 | return 0; | 1185 | return 0; |
1393 | 1186 | ||
1394 | error_unregister_interrupt_line: | 1187 | error_free_irq: |
1395 | if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) | 1188 | if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) |
1396 | iio_unregister_interrupt_line(st->indio_dev, 0); | 1189 | free_irq(spi->irq, st->indio_dev); |
1397 | error_unregister_ring: | 1190 | error_unregister_ring: |
1398 | iio_ring_buffer_unregister(st->indio_dev->ring); | 1191 | iio_ring_buffer_unregister(st->indio_dev->ring); |
1399 | error_unregister_dev: | 1192 | error_unregister_dev: |
@@ -1402,10 +1195,6 @@ error_free_dev: | |||
1402 | iio_device_unregister(st->indio_dev); | 1195 | iio_device_unregister(st->indio_dev); |
1403 | else | 1196 | else |
1404 | iio_free_device(st->indio_dev); | 1197 | iio_free_device(st->indio_dev); |
1405 | error_free_rx: | ||
1406 | kfree(st->rx); | ||
1407 | error_free_tx: | ||
1408 | kfree(st->tx); | ||
1409 | error_clear_st: | 1198 | error_clear_st: |
1410 | kfree(st); | 1199 | kfree(st); |
1411 | error_ret: | 1200 | error_ret: |
@@ -1415,20 +1204,19 @@ error_ret: | |||
1415 | static int sca3000_stop_all_interrupts(struct sca3000_state *st) | 1204 | static int sca3000_stop_all_interrupts(struct sca3000_state *st) |
1416 | { | 1205 | { |
1417 | int ret; | 1206 | int ret; |
1418 | u8 *rx; | ||
1419 | 1207 | ||
1420 | mutex_lock(&st->lock); | 1208 | mutex_lock(&st->lock); |
1421 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_INT_MASK, &rx, 1); | 1209 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1); |
1422 | if (ret) | 1210 | if (ret) |
1423 | goto error_ret; | 1211 | goto error_ret; |
1424 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_INT_MASK, | 1212 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_INT_MASK, |
1425 | (rx[1] & ~(SCA3000_INT_MASK_RING_THREE_QUARTER | 1213 | (st->rx[0] & |
1426 | | SCA3000_INT_MASK_RING_HALF | 1214 | ~(SCA3000_INT_MASK_RING_THREE_QUARTER | |
1427 | | SCA3000_INT_MASK_ALL_INTS))); | 1215 | SCA3000_INT_MASK_RING_HALF | |
1216 | SCA3000_INT_MASK_ALL_INTS))); | ||
1428 | error_ret: | 1217 | error_ret: |
1429 | kfree(rx); | 1218 | mutex_unlock(&st->lock); |
1430 | return ret; | 1219 | return ret; |
1431 | |||
1432 | } | 1220 | } |
1433 | 1221 | ||
1434 | static int sca3000_remove(struct spi_device *spi) | 1222 | static int sca3000_remove(struct spi_device *spi) |
@@ -1441,87 +1229,44 @@ static int sca3000_remove(struct spi_device *spi) | |||
1441 | if (ret) | 1229 | if (ret) |
1442 | return ret; | 1230 | return ret; |
1443 | if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) | 1231 | if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) |
1444 | iio_unregister_interrupt_line(indio_dev, 0); | 1232 | free_irq(spi->irq, indio_dev); |
1445 | iio_ring_buffer_unregister(indio_dev->ring); | 1233 | iio_ring_buffer_unregister(indio_dev->ring); |
1446 | sca3000_unconfigure_ring(indio_dev); | 1234 | sca3000_unconfigure_ring(indio_dev); |
1447 | iio_device_unregister(indio_dev); | 1235 | iio_device_unregister(indio_dev); |
1448 | 1236 | ||
1449 | kfree(st->tx); | ||
1450 | kfree(st->rx); | ||
1451 | kfree(st); | 1237 | kfree(st); |
1452 | 1238 | ||
1453 | return 0; | 1239 | return 0; |
1454 | } | 1240 | } |
1455 | 1241 | ||
1456 | /* These macros save on an awful lot of repeated code */ | 1242 | static const struct spi_device_id sca3000_id[] = { |
1457 | #define SCA3000_VARIANT_PROBE(_name) \ | 1243 | {"sca3000_d01", d01}, |
1458 | static int __devinit \ | 1244 | {"sca3000_e02", e02}, |
1459 | sca3000_##_name##_probe(struct spi_device *spi) \ | 1245 | {"sca3000_e04", e04}, |
1460 | { \ | 1246 | {"sca3000_e05", e05}, |
1461 | return __sca3000_probe(spi, _name); \ | 1247 | {} |
1462 | } | 1248 | }; |
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 | 1249 | ||
1483 | SCA3000_VARIANT_PROBE(e05); | 1250 | static struct spi_driver sca3000_driver = { |
1484 | static SCA3000_VARIANT_SPI_DRIVER(e05); | 1251 | .driver = { |
1252 | .name = "sca3000", | ||
1253 | .owner = THIS_MODULE, | ||
1254 | }, | ||
1255 | .probe = sca3000_probe, | ||
1256 | .remove = __devexit_p(sca3000_remove), | ||
1257 | .id_table = sca3000_id, | ||
1258 | }; | ||
1485 | 1259 | ||
1486 | static __init int sca3000_init(void) | 1260 | static __init int sca3000_init(void) |
1487 | { | 1261 | { |
1488 | int ret; | 1262 | return spi_register_driver(&sca3000_driver); |
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; | ||
1514 | } | 1263 | } |
1264 | module_init(sca3000_init); | ||
1515 | 1265 | ||
1516 | static __exit void sca3000_exit(void) | 1266 | static __exit void sca3000_exit(void) |
1517 | { | 1267 | { |
1518 | spi_unregister_driver(&sca3000_e05_driver); | 1268 | spi_unregister_driver(&sca3000_driver); |
1519 | spi_unregister_driver(&sca3000_e04_driver); | ||
1520 | spi_unregister_driver(&sca3000_e02_driver); | ||
1521 | spi_unregister_driver(&sca3000_d01_driver); | ||
1522 | } | 1269 | } |
1523 | |||
1524 | module_init(sca3000_init); | ||
1525 | module_exit(sca3000_exit); | 1270 | module_exit(sca3000_exit); |
1526 | 1271 | ||
1527 | MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>"); | 1272 | MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>"); |
diff --git a/drivers/staging/iio/accel/sca3000_ring.c b/drivers/staging/iio/accel/sca3000_ring.c index 44f9a56b8f8..8efd4f0144b 100644 --- a/drivers/staging/iio/accel/sca3000_ring.c +++ b/drivers/staging/iio/accel/sca3000_ring.c | |||
@@ -17,6 +17,8 @@ | |||
17 | #include <linux/kernel.h> | 17 | #include <linux/kernel.h> |
18 | #include <linux/spi/spi.h> | 18 | #include <linux/spi/spi.h> |
19 | #include <linux/sysfs.h> | 19 | #include <linux/sysfs.h> |
20 | #include <linux/sched.h> | ||
21 | #include <linux/poll.h> | ||
20 | 22 | ||
21 | #include "../iio.h" | 23 | #include "../iio.h" |
22 | #include "../sysfs.h" | 24 | #include "../sysfs.h" |
@@ -34,6 +36,44 @@ | |||
34 | * Currently scan elements aren't configured so it doesn't matter. | 36 | * Currently scan elements aren't configured so it doesn't matter. |
35 | */ | 37 | */ |
36 | 38 | ||
39 | static int sca3000_read_data(struct sca3000_state *st, | ||
40 | uint8_t reg_address_high, | ||
41 | u8 **rx_p, | ||
42 | int len) | ||
43 | { | ||
44 | int ret; | ||
45 | struct spi_message msg; | ||
46 | struct spi_transfer xfer[2] = { | ||
47 | { | ||
48 | .len = 1, | ||
49 | .tx_buf = st->tx, | ||
50 | }, { | ||
51 | .len = len, | ||
52 | } | ||
53 | }; | ||
54 | *rx_p = kmalloc(len, GFP_KERNEL); | ||
55 | if (*rx_p == NULL) { | ||
56 | ret = -ENOMEM; | ||
57 | goto error_ret; | ||
58 | } | ||
59 | xfer[1].rx_buf = *rx_p; | ||
60 | st->tx[0] = SCA3000_READ_REG(reg_address_high); | ||
61 | spi_message_init(&msg); | ||
62 | spi_message_add_tail(&xfer[0], &msg); | ||
63 | spi_message_add_tail(&xfer[1], &msg); | ||
64 | ret = spi_sync(st->us, &msg); | ||
65 | if (ret) { | ||
66 | dev_err(get_device(&st->us->dev), "problem reading register"); | ||
67 | goto error_free_rx; | ||
68 | } | ||
69 | |||
70 | return 0; | ||
71 | error_free_rx: | ||
72 | kfree(*rx_p); | ||
73 | error_ret: | ||
74 | return ret; | ||
75 | } | ||
76 | |||
37 | /** | 77 | /** |
38 | * sca3000_read_first_n_hw_rb() - main ring access, pulls data from ring | 78 | * sca3000_read_first_n_hw_rb() - main ring access, pulls data from ring |
39 | * @r: the ring | 79 | * @r: the ring |
@@ -45,8 +85,6 @@ | |||
45 | * Currently does not provide timestamps. As the hardware doesn't add them they | 85 | * Currently does not provide timestamps. As the hardware doesn't add them they |
46 | * can only be inferred approximately from ring buffer events such as 50% full | 86 | * can only be inferred approximately from ring buffer events such as 50% full |
47 | * and knowledge of when buffer was last emptied. This is left to userspace. | 87 | * and knowledge of when buffer was last emptied. This is left to userspace. |
48 | * | ||
49 | * Temporarily deliberately broken. | ||
50 | **/ | 88 | **/ |
51 | static int sca3000_read_first_n_hw_rb(struct iio_ring_buffer *r, | 89 | static int sca3000_read_first_n_hw_rb(struct iio_ring_buffer *r, |
52 | size_t count, char __user *buf, | 90 | size_t count, char __user *buf, |
@@ -56,54 +94,45 @@ static int sca3000_read_first_n_hw_rb(struct iio_ring_buffer *r, | |||
56 | struct iio_dev *indio_dev = hw_ring->private; | 94 | struct iio_dev *indio_dev = hw_ring->private; |
57 | struct sca3000_state *st = indio_dev->dev_data; | 95 | struct sca3000_state *st = indio_dev->dev_data; |
58 | u8 *rx; | 96 | u8 *rx; |
59 | s16 *samples; | ||
60 | int ret, i, num_available, num_read = 0; | 97 | int ret, i, num_available, num_read = 0; |
61 | int bytes_per_sample = 1; | 98 | int bytes_per_sample = 1; |
62 | u8 *datas; | ||
63 | u8 **data = &datas; | ||
64 | 99 | ||
65 | if (st->bpse == 11) | 100 | if (st->bpse == 11) |
66 | bytes_per_sample = 2; | 101 | bytes_per_sample = 2; |
67 | 102 | ||
68 | mutex_lock(&st->lock); | 103 | mutex_lock(&st->lock); |
69 | /* Check how much data is available: | 104 | if (count % bytes_per_sample) { |
70 | * RFC: Implement an ioctl to not bother checking whether there | 105 | ret = -EINVAL; |
71 | * is enough data in the ring? Afterall, if we are responding | 106 | goto error_ret; |
72 | * to an interrupt we have a minimum content guaranteed so it | 107 | } |
73 | * seems slight silly to waste time checking it is there. | 108 | |
74 | */ | 109 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_BUF_COUNT, 1); |
75 | ret = sca3000_read_data(st, | ||
76 | SCA3000_REG_ADDR_BUF_COUNT, | ||
77 | &rx, 1); | ||
78 | if (ret) | 110 | if (ret) |
79 | goto error_ret; | 111 | goto error_ret; |
80 | else | 112 | else |
81 | num_available = rx[1]; | 113 | num_available = st->rx[0]; |
82 | /* num_available is the total number of samples available | 114 | /* |
115 | * num_available is the total number of samples available | ||
83 | * i.e. number of time points * number of channels. | 116 | * i.e. number of time points * number of channels. |
84 | */ | 117 | */ |
85 | kfree(rx); | ||
86 | if (count > num_available * bytes_per_sample) | 118 | if (count > num_available * bytes_per_sample) |
87 | num_read = num_available*bytes_per_sample; | 119 | num_read = num_available*bytes_per_sample; |
88 | else | 120 | else |
89 | num_read = count - (count % (bytes_per_sample)); | 121 | num_read = count; |
90 | 122 | ||
91 | /* Avoid the read request byte */ | ||
92 | *dead_offset = 1; | ||
93 | ret = sca3000_read_data(st, | 123 | ret = sca3000_read_data(st, |
94 | SCA3000_REG_ADDR_RING_OUT, | 124 | SCA3000_REG_ADDR_RING_OUT, |
95 | data, num_read); | 125 | &rx, num_read); |
96 | 126 | if (ret) | |
97 | /* Convert byte order and shift to default resolution */ | 127 | goto error_ret; |
98 | if (st->bpse == 11) { | 128 | |
99 | samples = (s16*)(*data+1); | 129 | for (i = 0; i < num_read; i++) |
100 | for (i = 0; i < (num_read/2); i++) { | 130 | *(((u16 *)rx) + i) = be16_to_cpup((u16 *)rx + i); |
101 | samples[i] = be16_to_cpup( | ||
102 | (__be16 *)&(samples[i])); | ||
103 | samples[i] >>= 3; | ||
104 | } | ||
105 | } | ||
106 | 131 | ||
132 | if (copy_to_user(buf, rx, num_read)) | ||
133 | ret = -EFAULT; | ||
134 | kfree(rx); | ||
135 | r->stufftoread = 0; | ||
107 | error_ret: | 136 | error_ret: |
108 | mutex_unlock(&st->lock); | 137 | mutex_unlock(&st->lock); |
109 | 138 | ||
@@ -132,6 +161,76 @@ static IIO_RING_BYTES_PER_DATUM_ATTR; | |||
132 | static IIO_RING_LENGTH_ATTR; | 161 | static IIO_RING_LENGTH_ATTR; |
133 | 162 | ||
134 | /** | 163 | /** |
164 | * sca3000_query_ring_int() is the hardware ring status interrupt enabled | ||
165 | **/ | ||
166 | static ssize_t sca3000_query_ring_int(struct device *dev, | ||
167 | struct device_attribute *attr, | ||
168 | char *buf) | ||
169 | { | ||
170 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); | ||
171 | int ret, val; | ||
172 | struct iio_ring_buffer *ring = dev_get_drvdata(dev); | ||
173 | struct iio_dev *indio_dev = ring->indio_dev; | ||
174 | struct sca3000_state *st = indio_dev->dev_data; | ||
175 | |||
176 | mutex_lock(&st->lock); | ||
177 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1); | ||
178 | val = st->rx[0]; | ||
179 | mutex_unlock(&st->lock); | ||
180 | if (ret) | ||
181 | return ret; | ||
182 | |||
183 | return sprintf(buf, "%d\n", !!(val & this_attr->address)); | ||
184 | } | ||
185 | |||
186 | /** | ||
187 | * sca3000_set_ring_int() set state of ring status interrupt | ||
188 | **/ | ||
189 | static ssize_t sca3000_set_ring_int(struct device *dev, | ||
190 | struct device_attribute *attr, | ||
191 | const char *buf, | ||
192 | size_t len) | ||
193 | { | ||
194 | struct iio_ring_buffer *ring = dev_get_drvdata(dev); | ||
195 | struct iio_dev *indio_dev = ring->indio_dev; | ||
196 | struct sca3000_state *st = indio_dev->dev_data; | ||
197 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); | ||
198 | long val; | ||
199 | int ret; | ||
200 | |||
201 | mutex_lock(&st->lock); | ||
202 | ret = strict_strtol(buf, 10, &val); | ||
203 | if (ret) | ||
204 | goto error_ret; | ||
205 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1); | ||
206 | if (ret) | ||
207 | goto error_ret; | ||
208 | if (val) | ||
209 | ret = sca3000_write_reg(st, | ||
210 | SCA3000_REG_ADDR_INT_MASK, | ||
211 | st->rx[0] | this_attr->address); | ||
212 | else | ||
213 | ret = sca3000_write_reg(st, | ||
214 | SCA3000_REG_ADDR_INT_MASK, | ||
215 | st->rx[0] & ~this_attr->address); | ||
216 | error_ret: | ||
217 | mutex_unlock(&st->lock); | ||
218 | |||
219 | return ret ? ret : len; | ||
220 | } | ||
221 | |||
222 | static IIO_DEVICE_ATTR(50_percent, S_IRUGO | S_IWUSR, | ||
223 | sca3000_query_ring_int, | ||
224 | sca3000_set_ring_int, | ||
225 | SCA3000_INT_MASK_RING_HALF); | ||
226 | |||
227 | static IIO_DEVICE_ATTR(75_percent, S_IRUGO | S_IWUSR, | ||
228 | sca3000_query_ring_int, | ||
229 | sca3000_set_ring_int, | ||
230 | SCA3000_INT_MASK_RING_THREE_QUARTER); | ||
231 | |||
232 | |||
233 | /** | ||
135 | * sca3000_show_ring_bpse() -sysfs function to query bits per sample from ring | 234 | * sca3000_show_ring_bpse() -sysfs function to query bits per sample from ring |
136 | * @dev: ring buffer device | 235 | * @dev: ring buffer device |
137 | * @attr: this device attribute | 236 | * @attr: this device attribute |
@@ -142,20 +241,18 @@ static ssize_t sca3000_show_ring_bpse(struct device *dev, | |||
142 | char *buf) | 241 | char *buf) |
143 | { | 242 | { |
144 | int len = 0, ret; | 243 | int len = 0, ret; |
145 | u8 *rx; | ||
146 | struct iio_ring_buffer *ring = dev_get_drvdata(dev); | 244 | struct iio_ring_buffer *ring = dev_get_drvdata(dev); |
147 | struct iio_dev *indio_dev = ring->indio_dev; | 245 | struct iio_dev *indio_dev = ring->indio_dev; |
148 | struct sca3000_state *st = indio_dev->dev_data; | 246 | struct sca3000_state *st = indio_dev->dev_data; |
149 | 247 | ||
150 | mutex_lock(&st->lock); | 248 | mutex_lock(&st->lock); |
151 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 249 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
152 | if (ret) | 250 | if (ret) |
153 | goto error_ret; | 251 | goto error_ret; |
154 | if (rx[1] & SCA3000_RING_BUF_8BIT) | 252 | if (st->rx[0] & SCA3000_RING_BUF_8BIT) |
155 | len = sprintf(buf, "s8/8\n"); | 253 | len = sprintf(buf, "s8/8\n"); |
156 | else | 254 | else |
157 | len = sprintf(buf, "s11/16\n"); | 255 | len = sprintf(buf, "s11/16\n"); |
158 | kfree(rx); | ||
159 | error_ret: | 256 | error_ret: |
160 | mutex_unlock(&st->lock); | 257 | mutex_unlock(&st->lock); |
161 | 258 | ||
@@ -178,20 +275,19 @@ static ssize_t sca3000_store_ring_bpse(struct device *dev, | |||
178 | struct iio_dev *indio_dev = ring->indio_dev; | 275 | struct iio_dev *indio_dev = ring->indio_dev; |
179 | struct sca3000_state *st = indio_dev->dev_data; | 276 | struct sca3000_state *st = indio_dev->dev_data; |
180 | int ret; | 277 | int ret; |
181 | u8 *rx; | ||
182 | 278 | ||
183 | mutex_lock(&st->lock); | 279 | mutex_lock(&st->lock); |
184 | 280 | ||
185 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 281 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
186 | if (ret) | 282 | if (ret) |
187 | goto error_ret; | 283 | goto error_ret; |
188 | if (strncmp(buf, "s8/8", 4) == 0) { | 284 | if (sysfs_streq(buf, "s8/8")) { |
189 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | 285 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, |
190 | rx[1] | SCA3000_RING_BUF_8BIT); | 286 | st->rx[0] | SCA3000_RING_BUF_8BIT); |
191 | st->bpse = 8; | 287 | st->bpse = 8; |
192 | } else if (strncmp(buf, "s11/16", 5) == 0) { | 288 | } else if (sysfs_streq(buf, "s11/16")) { |
193 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | 289 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, |
194 | rx[1] & ~SCA3000_RING_BUF_8BIT); | 290 | st->rx[0] & ~SCA3000_RING_BUF_8BIT); |
195 | st->bpse = 11; | 291 | st->bpse = 11; |
196 | } else | 292 | } else |
197 | ret = -EINVAL; | 293 | ret = -EINVAL; |
@@ -201,32 +297,22 @@ error_ret: | |||
201 | return ret ? ret : len; | 297 | return ret ? ret : len; |
202 | } | 298 | } |
203 | 299 | ||
204 | static IIO_SCAN_EL_C(accel_x, 0, 0, NULL); | 300 | static ssize_t sca3000_show_buffer_scale(struct device *dev, |
205 | static IIO_SCAN_EL_C(accel_y, 1, 0, NULL); | 301 | struct device_attribute *attr, |
206 | static IIO_SCAN_EL_C(accel_z, 2, 0, NULL); | 302 | char *buf) |
207 | static IIO_CONST_ATTR(accel_type_available, "s8/8 s11/16"); | 303 | { |
208 | static IIO_DEVICE_ATTR(accel_type, | 304 | struct iio_ring_buffer *ring = dev_get_drvdata(dev); |
209 | S_IRUGO | S_IWUSR, | 305 | struct iio_dev *indio_dev = ring->indio_dev; |
210 | sca3000_show_ring_bpse, | 306 | struct sca3000_state *st = indio_dev->dev_data; |
211 | sca3000_store_ring_bpse, | ||
212 | 0); | ||
213 | 307 | ||
214 | static struct attribute *sca3000_scan_el_attrs[] = { | 308 | return sprintf(buf, "0.%06d\n", 4*st->info->scale); |
215 | &iio_scan_el_accel_x.dev_attr.attr, | 309 | } |
216 | &iio_const_attr_accel_x_index.dev_attr.attr, | ||
217 | &iio_scan_el_accel_y.dev_attr.attr, | ||
218 | &iio_const_attr_accel_y_index.dev_attr.attr, | ||
219 | &iio_scan_el_accel_z.dev_attr.attr, | ||
220 | &iio_const_attr_accel_z_index.dev_attr.attr, | ||
221 | &iio_const_attr_accel_type_available.dev_attr.attr, | ||
222 | &iio_dev_attr_accel_type.dev_attr.attr, | ||
223 | NULL | ||
224 | }; | ||
225 | 310 | ||
226 | static struct attribute_group sca3000_scan_el_group = { | 311 | static IIO_DEVICE_ATTR(accel_scale, |
227 | .attrs = sca3000_scan_el_attrs, | 312 | S_IRUGO, |
228 | .name = "scan_elements", | 313 | sca3000_show_buffer_scale, |
229 | }; | 314 | NULL, |
315 | 0); | ||
230 | 316 | ||
231 | /* | 317 | /* |
232 | * Ring buffer attributes | 318 | * Ring buffer attributes |
@@ -238,6 +324,9 @@ static struct attribute *sca3000_ring_attributes[] = { | |||
238 | &dev_attr_length.attr, | 324 | &dev_attr_length.attr, |
239 | &dev_attr_bytes_per_datum.attr, | 325 | &dev_attr_bytes_per_datum.attr, |
240 | &dev_attr_enable.attr, | 326 | &dev_attr_enable.attr, |
327 | &iio_dev_attr_50_percent.dev_attr.attr, | ||
328 | &iio_dev_attr_75_percent.dev_attr.attr, | ||
329 | &iio_dev_attr_accel_scale.dev_attr.attr, | ||
241 | NULL, | 330 | NULL, |
242 | }; | 331 | }; |
243 | 332 | ||
@@ -263,11 +352,12 @@ static struct iio_ring_buffer *sca3000_rb_allocate(struct iio_dev *indio_dev) | |||
263 | ring = kzalloc(sizeof *ring, GFP_KERNEL); | 352 | ring = kzalloc(sizeof *ring, GFP_KERNEL); |
264 | if (!ring) | 353 | if (!ring) |
265 | return NULL; | 354 | return NULL; |
355 | |||
266 | ring->private = indio_dev; | 356 | ring->private = indio_dev; |
267 | buf = &ring->buf; | 357 | buf = &ring->buf; |
358 | buf->stufftoread = 0; | ||
268 | iio_ring_buffer_init(buf, indio_dev); | 359 | iio_ring_buffer_init(buf, indio_dev); |
269 | buf->dev.type = &sca3000_ring_type; | 360 | buf->dev.type = &sca3000_ring_type; |
270 | device_initialize(&buf->dev); | ||
271 | buf->dev.parent = &indio_dev->dev; | 361 | buf->dev.parent = &indio_dev->dev; |
272 | dev_set_drvdata(&buf->dev, (void *)buf); | 362 | dev_set_drvdata(&buf->dev, (void *)buf); |
273 | 363 | ||
@@ -287,10 +377,14 @@ int sca3000_configure_ring(struct iio_dev *indio_dev) | |||
287 | return -ENOMEM; | 377 | return -ENOMEM; |
288 | indio_dev->modes |= INDIO_RING_HARDWARE_BUFFER; | 378 | indio_dev->modes |= INDIO_RING_HARDWARE_BUFFER; |
289 | 379 | ||
290 | indio_dev->ring->scan_el_attrs = &sca3000_scan_el_group; | ||
291 | indio_dev->ring->access.read_first_n = &sca3000_read_first_n_hw_rb; | 380 | indio_dev->ring->access.read_first_n = &sca3000_read_first_n_hw_rb; |
292 | indio_dev->ring->access.get_length = &sca3000_ring_get_length; | 381 | indio_dev->ring->access.get_length = &sca3000_ring_get_length; |
293 | indio_dev->ring->access.get_bytes_per_datum = &sca3000_ring_get_bytes_per_datum; | 382 | indio_dev->ring->access.get_bytes_per_datum = |
383 | &sca3000_ring_get_bytes_per_datum; | ||
384 | |||
385 | iio_scan_mask_set(indio_dev->ring, 0); | ||
386 | iio_scan_mask_set(indio_dev->ring, 1); | ||
387 | iio_scan_mask_set(indio_dev->ring, 2); | ||
294 | 388 | ||
295 | return 0; | 389 | return 0; |
296 | } | 390 | } |
@@ -305,22 +399,20 @@ int __sca3000_hw_ring_state_set(struct iio_dev *indio_dev, bool state) | |||
305 | { | 399 | { |
306 | struct sca3000_state *st = indio_dev->dev_data; | 400 | struct sca3000_state *st = indio_dev->dev_data; |
307 | int ret; | 401 | int ret; |
308 | u8 *rx; | ||
309 | 402 | ||
310 | mutex_lock(&st->lock); | 403 | mutex_lock(&st->lock); |
311 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | 404 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
312 | if (ret) | 405 | if (ret) |
313 | goto error_ret; | 406 | goto error_ret; |
314 | if (state) { | 407 | if (state) { |
315 | printk(KERN_INFO "supposedly enabling ring buffer\n"); | 408 | printk(KERN_INFO "supposedly enabling ring buffer\n"); |
316 | ret = sca3000_write_reg(st, | 409 | ret = sca3000_write_reg(st, |
317 | SCA3000_REG_ADDR_MODE, | 410 | SCA3000_REG_ADDR_MODE, |
318 | (rx[1] | SCA3000_RING_BUF_ENABLE)); | 411 | (st->rx[0] | SCA3000_RING_BUF_ENABLE)); |
319 | } else | 412 | } else |
320 | ret = sca3000_write_reg(st, | 413 | ret = sca3000_write_reg(st, |
321 | SCA3000_REG_ADDR_MODE, | 414 | SCA3000_REG_ADDR_MODE, |
322 | (rx[1] & ~SCA3000_RING_BUF_ENABLE)); | 415 | (st->rx[0] & ~SCA3000_RING_BUF_ENABLE)); |
323 | kfree(rx); | ||
324 | error_ret: | 416 | error_ret: |
325 | mutex_unlock(&st->lock); | 417 | mutex_unlock(&st->lock); |
326 | 418 | ||
@@ -357,13 +449,9 @@ void sca3000_register_ring_funcs(struct iio_dev *indio_dev) | |||
357 | **/ | 449 | **/ |
358 | void sca3000_ring_int_process(u8 val, struct iio_ring_buffer *ring) | 450 | void sca3000_ring_int_process(u8 val, struct iio_ring_buffer *ring) |
359 | { | 451 | { |
360 | /* | 452 | if (val & (SCA3000_INT_STATUS_THREE_QUARTERS | |
361 | if (val & SCA3000_INT_STATUS_THREE_QUARTERS) | 453 | SCA3000_INT_STATUS_HALF)) { |
362 | iio_push_ring_event(ring, | 454 | ring->stufftoread = true; |
363 | IIO_EVENT_CODE_RING_75_FULL, | 455 | wake_up_interruptible(&ring->pollq); |
364 | 0); | 456 | } |
365 | else if (val & SCA3000_INT_STATUS_HALF) | ||
366 | iio_push_ring_event(ring, | ||
367 | IIO_EVENT_CODE_RING_50_FULL, 0); | ||
368 | */ | ||
369 | } | 457 | } |