projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging:iio:events: use IIO_<TYPE> and IIO_MOD_<> instead of IIO_EV_CLASS_<TYPE> etc
[deliverable/linux.git] / drivers / staging / iio / adc / max1363_core.c
1 /*
2 * iio/adc/max1363.c
3 * Copyright (C) 2008-2010 Jonathan Cameron
4 *
5 * based on linux/drivers/i2c/chips/max123x
6 * Copyright (C) 2002-2004 Stefan Eletzhofer
7 *
8 * based on linux/drivers/acron/char/pcf8583.c
9 * Copyright (C) 2000 Russell King
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 *
15 * max1363.c
16 *
17 * Partial support for max1363 and similar chips.
18 *
19 * Not currently implemented.
20 *
21 * - Control of internal reference.
22 */
23
24 #include <linux/interrupt.h>
25 #include <linux/device.h>
26 #include <linux/kernel.h>
27 #include <linux/sysfs.h>
28 #include <linux/list.h>
29 #include <linux/i2c.h>
30 #include <linux/regulator/consumer.h>
31 #include <linux/slab.h>
32 #include <linux/err.h>
33
34 #include "../iio.h"
35 #include "../sysfs.h"
36 #include "../ring_generic.h"
37
38 #include "max1363.h"
39
40 #define MAX1363_MODE_SINGLE(_num, _mask) { \
41 .conf = MAX1363_CHANNEL_SEL(_num) \
42 | MAX1363_CONFIG_SCAN_SINGLE_1 \
43 | MAX1363_CONFIG_SE, \
44 .modemask = _mask, \
45 }
46
47 #define MAX1363_MODE_SCAN_TO_CHANNEL(_num, _mask) { \
48 .conf = MAX1363_CHANNEL_SEL(_num) \
49 | MAX1363_CONFIG_SCAN_TO_CS \
50 | MAX1363_CONFIG_SE, \
51 .modemask = _mask, \
52 }
53
54 /* note not available for max1363 hence naming */
55 #define MAX1236_MODE_SCAN_MID_TO_CHANNEL(_mid, _num, _mask) { \
56 .conf = MAX1363_CHANNEL_SEL(_num) \
57 | MAX1236_SCAN_MID_TO_CHANNEL \
58 | MAX1363_CONFIG_SE, \
59 .modemask = _mask \
60 }
61
62 #define MAX1363_MODE_DIFF_SINGLE(_nump, _numm, _mask) { \
63 .conf = MAX1363_CHANNEL_SEL(_nump) \
64 | MAX1363_CONFIG_SCAN_SINGLE_1 \
65 | MAX1363_CONFIG_DE, \
66 .modemask = _mask \
67 }
68
69 /* Can't think how to automate naming so specify for now */
70 #define MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(_num, _numvals, _mask) { \
71 .conf = MAX1363_CHANNEL_SEL(_num) \
72 | MAX1363_CONFIG_SCAN_TO_CS \
73 | MAX1363_CONFIG_DE, \
74 .modemask = _mask \
75 }
76
77 /* note only available for max1363 hence naming */
78 #define MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(_num, _numvals, _mask) { \
79 .conf = MAX1363_CHANNEL_SEL(_num) \
80 | MAX1236_SCAN_MID_TO_CHANNEL \
81 | MAX1363_CONFIG_SE, \
82 .modemask = _mask \
83 }
84
85 static const struct max1363_mode max1363_mode_table[] = {
86 /* All of the single channel options first */
87 MAX1363_MODE_SINGLE(0, 1 << 0),
88 MAX1363_MODE_SINGLE(1, 1 << 1),
89 MAX1363_MODE_SINGLE(2, 1 << 2),
90 MAX1363_MODE_SINGLE(3, 1 << 3),
91 MAX1363_MODE_SINGLE(4, 1 << 4),
92 MAX1363_MODE_SINGLE(5, 1 << 5),
93 MAX1363_MODE_SINGLE(6, 1 << 6),
94 MAX1363_MODE_SINGLE(7, 1 << 7),
95 MAX1363_MODE_SINGLE(8, 1 << 8),
96 MAX1363_MODE_SINGLE(9, 1 << 9),
97 MAX1363_MODE_SINGLE(10, 1 << 10),
98 MAX1363_MODE_SINGLE(11, 1 << 11),
99
100 MAX1363_MODE_DIFF_SINGLE(0, 1, 1 << 12),
101 MAX1363_MODE_DIFF_SINGLE(2, 3, 1 << 13),
102 MAX1363_MODE_DIFF_SINGLE(4, 5, 1 << 14),
103 MAX1363_MODE_DIFF_SINGLE(6, 7, 1 << 15),
104 MAX1363_MODE_DIFF_SINGLE(8, 9, 1 << 16),
105 MAX1363_MODE_DIFF_SINGLE(10, 11, 1 << 17),
106 MAX1363_MODE_DIFF_SINGLE(1, 0, 1 << 18),
107 MAX1363_MODE_DIFF_SINGLE(3, 2, 1 << 19),
108 MAX1363_MODE_DIFF_SINGLE(5, 4, 1 << 20),
109 MAX1363_MODE_DIFF_SINGLE(7, 6, 1 << 21),
110 MAX1363_MODE_DIFF_SINGLE(9, 8, 1 << 22),
111 MAX1363_MODE_DIFF_SINGLE(11, 10, 1 << 23),
112
113 /* The multichannel scans next */
114 MAX1363_MODE_SCAN_TO_CHANNEL(1, 0x003),
115 MAX1363_MODE_SCAN_TO_CHANNEL(2, 0x007),
116 MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3, 0x00C),
117 MAX1363_MODE_SCAN_TO_CHANNEL(3, 0x00F),
118 MAX1363_MODE_SCAN_TO_CHANNEL(4, 0x01F),
119 MAX1363_MODE_SCAN_TO_CHANNEL(5, 0x03F),
120 MAX1363_MODE_SCAN_TO_CHANNEL(6, 0x07F),
121 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7, 0x0C0),
122 MAX1363_MODE_SCAN_TO_CHANNEL(7, 0x0FF),
123 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8, 0x1C0),
124 MAX1363_MODE_SCAN_TO_CHANNEL(8, 0x1FF),
125 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9, 0x3C0),
126 MAX1363_MODE_SCAN_TO_CHANNEL(9, 0x3FF),
127 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10, 0x7C0),
128 MAX1363_MODE_SCAN_TO_CHANNEL(10, 0x7FF),
129 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11, 0xFC0),
130 MAX1363_MODE_SCAN_TO_CHANNEL(11, 0xFFF),
131
132 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(2, 2, 0x003000),
133 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(4, 3, 0x007000),
134 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(6, 4, 0x00F000),
135 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(8, 2, 0x018000),
136 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(8, 5, 0x01F000),
137 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(10, 3, 0x038000),
138 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(10, 6, 0x3F000),
139 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(3, 2, 0x0C0000),
140 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(5, 3, 0x1C0000),
141 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(7, 4, 0x3C0000),
142 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(9, 2, 0x600000),
143 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(9, 5, 0x7C0000),
144 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(11, 3, 0xE00000),
145 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(11, 6, 0xFC0000),
146 };
147
148 const struct max1363_mode
149 *max1363_match_mode(u32 mask, const struct max1363_chip_info *ci)
150 {
151 int i;
152 if (mask)
153 for (i = 0; i < ci->num_modes; i++)
154 if (!((~max1363_mode_table[ci->mode_list[i]].modemask) &
155 mask))
156 return &max1363_mode_table[ci->mode_list[i]];
157 return NULL;
158 }
159
160 static int max1363_write_basic_config(struct i2c_client *client,
161 unsigned char d1,
162 unsigned char d2)
163 {
164 u8 tx_buf[2] = {d1, d2};
165
166 return i2c_master_send(client, tx_buf, 2);
167 }
168
169 int max1363_set_scan_mode(struct max1363_state *st)
170 {
171 st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
172 | MAX1363_SCAN_MASK
173 | MAX1363_SE_DE_MASK);
174 st->configbyte |= st->current_mode->conf;
175
176 return max1363_write_basic_config(st->client,
177 st->setupbyte,
178 st->configbyte);
179 }
180
181 static int max1363_read_single_chan(struct iio_dev *indio_dev,
182 struct iio_chan_spec const *chan,
183 int *val,
184 long m)
185 {
186 int ret = 0;
187 s32 data;
188 char rxbuf[2];
189 long mask;
190 struct max1363_state *st = iio_priv(indio_dev);
191 struct i2c_client *client = st->client;
192
193 mutex_lock(&indio_dev->mlock);
194 /*
195 * If monitor mode is enabled, the method for reading a single
196 * channel will have to be rather different and has not yet
197 * been implemented.
198 */
199 if (st->monitor_on) {
200 ret = -EBUSY;
201 goto error_ret;
202 }
203
204 /* If ring buffer capture is occurring, query the buffer */
205 if (iio_ring_enabled(indio_dev)) {
206 mask = max1363_mode_table[chan->address].modemask;
207 data = max1363_single_channel_from_ring(mask, st);
208 if (data < 0) {
209 ret = data;
210 goto error_ret;
211 }
212 } else {
213 /* Check to see if current scan mode is correct */
214 if (st->current_mode != &max1363_mode_table[chan->address]) {
215 /* Update scan mode if needed */
216 st->current_mode = &max1363_mode_table[chan->address];
217 ret = max1363_set_scan_mode(st);
218 if (ret < 0)
219 goto error_ret;
220 }
221 if (st->chip_info->bits != 8) {
222 /* Get reading */
223 data = i2c_master_recv(client, rxbuf, 2);
224 if (data < 0) {
225 ret = data;
226 goto error_ret;
227 }
228 data = (s32)(rxbuf[1]) | ((s32)(rxbuf[0] & 0x0F)) << 8;
229 } else {
230 /* Get reading */
231 data = i2c_master_recv(client, rxbuf, 1);
232 if (data < 0) {
233 ret = data;
234 goto error_ret;
235 }
236 data = rxbuf[0];
237 }
238 }
239 *val = data;
240 error_ret:
241 mutex_unlock(&indio_dev->mlock);
242 return ret;
243
244 }
245
246 static int max1363_read_raw(struct iio_dev *indio_dev,
247 struct iio_chan_spec const *chan,
248 int *val,
249 int *val2,
250 long m)
251 {
252 struct max1363_state *st = iio_priv(indio_dev);
253 int ret;
254 switch (m) {
255 case 0:
256 ret = max1363_read_single_chan(indio_dev, chan, val, m);
257 if (ret < 0)
258 return ret;
259 return IIO_VAL_INT;
260 case (1 << IIO_CHAN_INFO_SCALE_SHARED):
261 if ((1 << (st->chip_info->bits + 1)) >
262 st->chip_info->int_vref_mv) {
263 *val = 0;
264 *val2 = 500000;
265 return IIO_VAL_INT_PLUS_MICRO;
266 } else {
267 *val = (st->chip_info->int_vref_mv)
268 >> st->chip_info->bits;
269 return IIO_VAL_INT;
270 }
271 default:
272 return -EINVAL;
273 }
274 return 0;
275 }
276
277 /* Applies to max1363 */
278 static const enum max1363_modes max1363_mode_list[] = {
279 _s0, _s1, _s2, _s3,
280 s0to1, s0to2, s0to3,
281 d0m1, d2m3, d1m0, d3m2,
282 d0m1to2m3, d1m0to3m2,
283 };
284
285 #define MAX1363_EV_M \
286 (IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) \
287 | IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING))
288 #define MAX1363_INFO_MASK (1 << IIO_CHAN_INFO_SCALE_SHARED)
289
290 static struct iio_chan_spec max1363_channels[] = {
291 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0, MAX1363_INFO_MASK,
292 _s0, 0, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
293 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
294 _s1, 1, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
295 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0, MAX1363_INFO_MASK,
296 _s2, 2, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
297 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0, MAX1363_INFO_MASK,
298 _s3, 3, IIO_ST('u', 12, 16, 0), MAX1363_EV_M),
299 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 0, 1, MAX1363_INFO_MASK,
300 d0m1, 4, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
301 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 2, 3, MAX1363_INFO_MASK,
302 d2m3, 5, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
303 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
304 d1m0, 6, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
305 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 3, 2, MAX1363_INFO_MASK,
306 d3m2, 7, IIO_ST('s', 12, 16, 0), MAX1363_EV_M),
307 IIO_CHAN_SOFT_TIMESTAMP(8)
308 };
309
310 static struct iio_chan_spec max1361_channels[] = {
311 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 0, 0, MAX1363_INFO_MASK,
312 _s0, 0, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
313 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
314 _s1, 1, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
315 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 2, 0, MAX1363_INFO_MASK,
316 _s2, 2, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
317 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, 3, 0, MAX1363_INFO_MASK,
318 _s3, 3, IIO_ST('u', 10, 16, 0), MAX1363_EV_M),
319 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 0, 1, MAX1363_INFO_MASK,
320 d0m1, 4, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
321 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 2, 3, MAX1363_INFO_MASK,
322 d2m3, 5, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
323 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 1, 0, MAX1363_INFO_MASK,
324 d1m0, 6, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
325 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, 3, 2, MAX1363_INFO_MASK,
326 d3m2, 7, IIO_ST('s', 10, 16, 0), MAX1363_EV_M),
327 IIO_CHAN_SOFT_TIMESTAMP(8)
328 };
329
330 #define MAX1363_CHAN_U(num, address, scan_index, bits) \
331 IIO_CHAN(IIO_IN, 0, 1, 0, NULL, num, 0, MAX1363_INFO_MASK, \
332 address, scan_index, IIO_ST('u', bits, \
333 (bits == 8) ? 8 : 16, 0), 0)
334 /* bipolar channel */
335 #define MAX1363_CHAN_B(num, num2, address, scan_index, bits) \
336 IIO_CHAN(IIO_IN_DIFF, 0, 1, 0, NULL, num, num2, MAX1363_INFO_MASK,\
337 address, scan_index, IIO_ST('s', bits, \
338 (bits == 8) ? 8 : 16, 0), 0)
339
340 #define MAX1363_4X_CHANS(bits) { \
341 MAX1363_CHAN_U(0, _s0, 0, bits), \
342 MAX1363_CHAN_U(1, _s1, 1, bits), \
343 MAX1363_CHAN_U(2, _s2, 2, bits), \
344 MAX1363_CHAN_U(3, _s3, 3, bits), \
345 MAX1363_CHAN_B(0, 1, d0m1, 4, bits), \
346 MAX1363_CHAN_B(2, 3, d2m3, 5, bits), \
347 MAX1363_CHAN_B(1, 0, d1m0, 6, bits), \
348 MAX1363_CHAN_B(3, 2, d3m2, 7, bits), \
349 IIO_CHAN_SOFT_TIMESTAMP(8) \
350 }
351
352 static struct iio_chan_spec max1036_channels[] = MAX1363_4X_CHANS(8);
353 static struct iio_chan_spec max1136_channels[] = MAX1363_4X_CHANS(10);
354 static struct iio_chan_spec max1236_channels[] = MAX1363_4X_CHANS(12);
355
356 /* Appies to max1236, max1237 */
357 static const enum max1363_modes max1236_mode_list[] = {
358 _s0, _s1, _s2, _s3,
359 s0to1, s0to2, s0to3,
360 d0m1, d2m3, d1m0, d3m2,
361 d0m1to2m3, d1m0to3m2,
362 s2to3,
363 };
364
365 /* Applies to max1238, max1239 */
366 static const enum max1363_modes max1238_mode_list[] = {
367 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11,
368 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6,
369 s0to7, s0to8, s0to9, s0to10, s0to11,
370 d0m1, d2m3, d4m5, d6m7, d8m9, d10m11,
371 d1m0, d3m2, d5m4, d7m6, d9m8, d11m10,
372 d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11,
373 d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10,
374 s6to7, s6to8, s6to9, s6to10, s6to11,
375 d6m7to8m9, d6m7to10m11, d7m6to9m8, d7m6to11m10,
376 };
377
378 #define MAX1363_12X_CHANS(bits) { \
379 MAX1363_CHAN_U(0, _s0, 0, bits), \
380 MAX1363_CHAN_U(1, _s1, 1, bits), \
381 MAX1363_CHAN_U(2, _s2, 2, bits), \
382 MAX1363_CHAN_U(3, _s3, 3, bits), \
383 MAX1363_CHAN_U(4, _s4, 4, bits), \
384 MAX1363_CHAN_U(5, _s5, 5, bits), \
385 MAX1363_CHAN_U(6, _s6, 6, bits), \
386 MAX1363_CHAN_U(7, _s7, 7, bits), \
387 MAX1363_CHAN_U(8, _s8, 8, bits), \
388 MAX1363_CHAN_U(9, _s9, 9, bits), \
389 MAX1363_CHAN_U(10, _s10, 10, bits), \
390 MAX1363_CHAN_U(11, _s11, 11, bits), \
391 MAX1363_CHAN_B(0, 1, d0m1, 12, bits), \
392 MAX1363_CHAN_B(2, 3, d2m3, 13, bits), \
393 MAX1363_CHAN_B(4, 5, d4m5, 14, bits), \
394 MAX1363_CHAN_B(6, 7, d6m7, 15, bits), \
395 MAX1363_CHAN_B(8, 9, d8m9, 16, bits), \
396 MAX1363_CHAN_B(10, 11, d10m11, 17, bits), \
397 MAX1363_CHAN_B(1, 0, d1m0, 18, bits), \
398 MAX1363_CHAN_B(3, 2, d3m2, 19, bits), \
399 MAX1363_CHAN_B(5, 4, d5m4, 20, bits), \
400 MAX1363_CHAN_B(7, 6, d7m6, 21, bits), \
401 MAX1363_CHAN_B(9, 8, d9m8, 22, bits), \
402 MAX1363_CHAN_B(11, 10, d11m10, 23, bits), \
403 IIO_CHAN_SOFT_TIMESTAMP(24) \
404 }
405 static struct iio_chan_spec max1038_channels[] = MAX1363_12X_CHANS(8);
406 static struct iio_chan_spec max1138_channels[] = MAX1363_12X_CHANS(10);
407 static struct iio_chan_spec max1238_channels[] = MAX1363_12X_CHANS(12);
408
409 static const enum max1363_modes max11607_mode_list[] = {
410 _s0, _s1, _s2, _s3,
411 s0to1, s0to2, s0to3,
412 s2to3,
413 d0m1, d2m3, d1m0, d3m2,
414 d0m1to2m3, d1m0to3m2,
415 };
416
417 static const enum max1363_modes max11608_mode_list[] = {
418 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7,
419 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s0to7,
420 s6to7,
421 d0m1, d2m3, d4m5, d6m7,
422 d1m0, d3m2, d5m4, d7m6,
423 d0m1to2m3, d0m1to4m5, d0m1to6m7,
424 d1m0to3m2, d1m0to5m4, d1m0to7m6,
425 };
426
427 #define MAX1363_8X_CHANS(bits) { \
428 MAX1363_CHAN_U(0, _s0, 0, bits), \
429 MAX1363_CHAN_U(1, _s1, 1, bits), \
430 MAX1363_CHAN_U(2, _s2, 2, bits), \
431 MAX1363_CHAN_U(3, _s3, 3, bits), \
432 MAX1363_CHAN_U(4, _s4, 4, bits), \
433 MAX1363_CHAN_U(5, _s5, 5, bits), \
434 MAX1363_CHAN_U(6, _s6, 6, bits), \
435 MAX1363_CHAN_U(7, _s7, 7, bits), \
436 MAX1363_CHAN_B(0, 1, d0m1, 8, bits), \
437 MAX1363_CHAN_B(2, 3, d2m3, 9, bits), \
438 MAX1363_CHAN_B(4, 5, d4m5, 10, bits), \
439 MAX1363_CHAN_B(6, 7, d6m7, 11, bits), \
440 MAX1363_CHAN_B(1, 0, d1m0, 12, bits), \
441 MAX1363_CHAN_B(3, 2, d3m2, 13, bits), \
442 MAX1363_CHAN_B(5, 4, d5m4, 14, bits), \
443 MAX1363_CHAN_B(7, 6, d7m6, 15, bits), \
444 IIO_CHAN_SOFT_TIMESTAMP(16) \
445 }
446 static struct iio_chan_spec max11602_channels[] = MAX1363_8X_CHANS(8);
447 static struct iio_chan_spec max11608_channels[] = MAX1363_8X_CHANS(10);
448 static struct iio_chan_spec max11614_channels[] = MAX1363_8X_CHANS(12);
449
450 static const enum max1363_modes max11644_mode_list[] = {
451 _s0, _s1, s0to1, d0m1, d1m0,
452 };
453
454 #define MAX1363_2X_CHANS(bits) { \
455 MAX1363_CHAN_U(0, _s0, 0, bits), \
456 MAX1363_CHAN_U(1, _s1, 1, bits), \
457 MAX1363_CHAN_B(0, 1, d0m1, 2, bits), \
458 MAX1363_CHAN_B(1, 0, d1m0, 3, bits), \
459 IIO_CHAN_SOFT_TIMESTAMP(4) \
460 }
461
462 static struct iio_chan_spec max11646_channels[] = MAX1363_2X_CHANS(10);
463 static struct iio_chan_spec max11644_channels[] = MAX1363_2X_CHANS(12);
464
465 enum { max1361,
466 max1362,
467 max1363,
468 max1364,
469 max1036,
470 max1037,
471 max1038,
472 max1039,
473 max1136,
474 max1137,
475 max1138,
476 max1139,
477 max1236,
478 max1237,
479 max1238,
480 max1239,
481 max11600,
482 max11601,
483 max11602,
484 max11603,
485 max11604,
486 max11605,
487 max11606,
488 max11607,
489 max11608,
490 max11609,
491 max11610,
492 max11611,
493 max11612,
494 max11613,
495 max11614,
496 max11615,
497 max11616,
498 max11617,
499 max11644,
500 max11645,
501 max11646,
502 max11647
503 };
504
505 static const int max1363_monitor_speeds[] = { 133000, 665000, 33300, 16600,
506 8300, 4200, 2000, 1000 };
507
508 static ssize_t max1363_monitor_show_freq(struct device *dev,
509 struct device_attribute *attr,
510 char *buf)
511 {
512 struct max1363_state *st = iio_priv(dev_get_drvdata(dev));
513 return sprintf(buf, "%d\n", max1363_monitor_speeds[st->monitor_speed]);
514 }
515
516 static ssize_t max1363_monitor_store_freq(struct device *dev,
517 struct device_attribute *attr,
518 const char *buf,
519 size_t len)
520 {
521 struct iio_dev *indio_dev = dev_get_drvdata(dev);
522 struct max1363_state *st = iio_priv(indio_dev);
523 int i, ret;
524 unsigned long val;
525 bool found = false;
526
527 ret = strict_strtoul(buf, 10, &val);
528 if (ret)
529 return -EINVAL;
530 for (i = 0; i < ARRAY_SIZE(max1363_monitor_speeds); i++)
531 if (val == max1363_monitor_speeds[i]) {
532 found = true;
533 break;
534 }
535 if (!found)
536 return -EINVAL;
537
538 mutex_lock(&indio_dev->mlock);
539 st->monitor_speed = i;
540 mutex_unlock(&indio_dev->mlock);
541
542 return 0;
543 }
544
545 static IIO_DEV_ATTR_SAMP_FREQ(S_IRUGO | S_IWUSR,
546 max1363_monitor_show_freq,
547 max1363_monitor_store_freq);
548
549 static IIO_CONST_ATTR(sampling_frequency_available,
550 "133000 665000 33300 16600 8300 4200 2000 1000");
551
552 static int max1363_read_thresh(struct iio_dev *indio_dev,
553 int event_code,
554 int *val)
555 {
556 struct max1363_state *st = iio_priv(indio_dev);
557 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING)
558 *val = st->thresh_low[IIO_EVENT_CODE_EXTRACT_NUM(event_code)];
559 else
560 *val = st->thresh_high[IIO_EVENT_CODE_EXTRACT_NUM(event_code)];
561 return 0;
562 }
563
564 static int max1363_write_thresh(struct iio_dev *indio_dev,
565 int event_code,
566 int val)
567 {
568 struct max1363_state *st = iio_priv(indio_dev);
569 /* make it handle signed correctly as well */
570 switch (st->chip_info->bits) {
571 case 10:
572 if (val > 0x3FF)
573 return -EINVAL;
574 break;
575 case 12:
576 if (val > 0xFFF)
577 return -EINVAL;
578 break;
579 }
580
581 switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
582 case IIO_EV_DIR_FALLING:
583 st->thresh_low[IIO_EVENT_CODE_EXTRACT_NUM(event_code)] = val;
584 break;
585 case IIO_EV_DIR_RISING:
586 st->thresh_high[IIO_EVENT_CODE_EXTRACT_NUM(event_code)] = val;
587 break;
588 }
589
590 return 0;
591 }
592
593 static const int max1363_event_codes[] = {
594 IIO_UNMOD_EVENT_CODE(IIO_IN, 0, IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
595 IIO_UNMOD_EVENT_CODE(IIO_IN, 1, IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
596 IIO_UNMOD_EVENT_CODE(IIO_IN, 2, IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
597 IIO_UNMOD_EVENT_CODE(IIO_IN, 3, IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
598 IIO_UNMOD_EVENT_CODE(IIO_IN, 0, IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
599 IIO_UNMOD_EVENT_CODE(IIO_IN, 1, IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
600 IIO_UNMOD_EVENT_CODE(IIO_IN, 2, IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
601 IIO_UNMOD_EVENT_CODE(IIO_IN, 3, IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
602 };
603
604 static irqreturn_t max1363_event_handler(int irq, void *private)
605 {
606 struct iio_dev *indio_dev = private;
607 struct max1363_state *st = iio_priv(indio_dev);
608 s64 timestamp = iio_get_time_ns();
609 unsigned long mask, loc;
610 u8 rx;
611 u8 tx[2] = { st->setupbyte,
612 MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0 };
613
614 i2c_master_recv(st->client, &rx, 1);
615 mask = rx;
616 for_each_set_bit(loc, &mask, 8)
617 iio_push_event(indio_dev, 0, max1363_event_codes[loc],
618 timestamp);
619 i2c_master_send(st->client, tx, 2);
620
621 return IRQ_HANDLED;
622 }
623
624 static int max1363_read_event_config(struct iio_dev *indio_dev,
625 int event_code)
626 {
627 struct max1363_state *st = iio_priv(indio_dev);
628
629 int val;
630 int number = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
631 mutex_lock(&indio_dev->mlock);
632 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING)
633 val = (1 << number) & st->mask_low;
634 else
635 val = (1 << number) & st->mask_high;
636 mutex_unlock(&indio_dev->mlock);
637
638 return val;
639 }
640
641 static int max1363_monitor_mode_update(struct max1363_state *st, int enabled)
642 {
643 u8 *tx_buf;
644 int ret, i = 3, j;
645 unsigned long numelements;
646 int len;
647 long modemask;
648
649 if (!enabled) {
650 /* transition to ring capture is not currently supported */
651 st->setupbyte &= ~MAX1363_SETUP_MONITOR_SETUP;
652 st->configbyte &= ~MAX1363_SCAN_MASK;
653 st->monitor_on = false;
654 return max1363_write_basic_config(st->client,
655 st->setupbyte,
656 st->configbyte);
657 }
658
659 /* Ensure we are in the relevant mode */
660 st->setupbyte |= MAX1363_SETUP_MONITOR_SETUP;
661 st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
662 | MAX1363_SCAN_MASK
663 | MAX1363_SE_DE_MASK);
664 st->configbyte |= MAX1363_CONFIG_SCAN_MONITOR_MODE;
665 if ((st->mask_low | st->mask_high) & 0x0F) {
666 st->configbyte |= max1363_mode_table[s0to3].conf;
667 modemask = max1363_mode_table[s0to3].modemask;
668 } else if ((st->mask_low | st->mask_high) & 0x30) {
669 st->configbyte |= max1363_mode_table[d0m1to2m3].conf;
670 modemask = max1363_mode_table[d0m1to2m3].modemask;
671 } else {
672 st->configbyte |= max1363_mode_table[d1m0to3m2].conf;
673 modemask = max1363_mode_table[d1m0to3m2].modemask;
674 }
675 numelements = hweight_long(modemask);
676 len = 3 * numelements + 3;
677 tx_buf = kmalloc(len, GFP_KERNEL);
678 if (!tx_buf) {
679 ret = -ENOMEM;
680 goto error_ret;
681 }
682 tx_buf[0] = st->configbyte;
683 tx_buf[1] = st->setupbyte;
684 tx_buf[2] = (st->monitor_speed << 1);
685
686 /*
687 * So we need to do yet another bit of nefarious scan mode
688 * setup to match what we need.
689 */
690 for (j = 0; j < 8; j++)
691 if (modemask & (1 << j)) {
692 /* Establish the mode is in the scan */
693 if (st->mask_low & (1 << j)) {
694 tx_buf[i] = (st->thresh_low[j] >> 4) & 0xFF;
695 tx_buf[i + 1] = (st->thresh_low[j] << 4) & 0xF0;
696 } else if (j < 4) {
697 tx_buf[i] = 0;
698 tx_buf[i + 1] = 0;
699 } else {
700 tx_buf[i] = 0x80;
701 tx_buf[i + 1] = 0;
702 }
703 if (st->mask_high & (1 << j)) {
704 tx_buf[i + 1] |=
705 (st->thresh_high[j] >> 8) & 0x0F;
706 tx_buf[i + 2] = st->thresh_high[j] & 0xFF;
707 } else if (j < 4) {
708 tx_buf[i + 1] |= 0x0F;
709 tx_buf[i + 2] = 0xFF;
710 } else {
711 tx_buf[i + 1] |= 0x07;
712 tx_buf[i + 2] = 0xFF;
713 }
714 i += 3;
715 }
716
717
718 ret = i2c_master_send(st->client, tx_buf, len);
719 if (ret < 0)
720 goto error_ret;
721 if (ret != len) {
722 ret = -EIO;
723 goto error_ret;
724 }
725
726 /*
727 * Now that we hopefully have sensible thresholds in place it is
728 * time to turn the interrupts on.
729 * It is unclear from the data sheet if this should be necessary
730 * (i.e. whether monitor mode setup is atomic) but it appears to
731 * be in practice.
732 */
733 tx_buf[0] = st->setupbyte;
734 tx_buf[1] = MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0;
735 ret = i2c_master_send(st->client, tx_buf, 2);
736 if (ret < 0)
737 goto error_ret;
738 if (ret != 2) {
739 ret = -EIO;
740 goto error_ret;
741 }
742 ret = 0;
743 st->monitor_on = true;
744 error_ret:
745
746 kfree(tx_buf);
747
748 return ret;
749 }
750
751 /*
752 * To keep this manageable we always use one of 3 scan modes.
753 * Scan 0...3, 0-1,2-3 and 1-0,3-2
754 */
755
756 static inline int __max1363_check_event_mask(int thismask, int checkmask)
757 {
758 int ret = 0;
759 /* Is it unipolar */
760 if (thismask < 4) {
761 if (checkmask & ~0x0F) {
762 ret = -EBUSY;
763 goto error_ret;
764 }
765 } else if (thismask < 6) {
766 if (checkmask & ~0x30) {
767 ret = -EBUSY;
768 goto error_ret;
769 }
770 } else if (checkmask & ~0xC0)
771 ret = -EBUSY;
772 error_ret:
773 return ret;
774 }
775
776 static int max1363_write_event_config(struct iio_dev *indio_dev,
777 int event_code,
778 int state)
779 {
780 int ret = 0;
781 struct max1363_state *st = iio_priv(indio_dev);
782 u16 unifiedmask;
783 int number = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
784
785 mutex_lock(&indio_dev->mlock);
786 unifiedmask = st->mask_low | st->mask_high;
787 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING) {
788
789 if (state == 0)
790 st->mask_low &= ~(1 << number);
791 else {
792 ret = __max1363_check_event_mask((1 << number),
793 unifiedmask);
794 if (ret)
795 goto error_ret;
796 st->mask_low |= (1 << number);
797 }
798 } else {
799 if (state == 0)
800 st->mask_high &= ~(1 << number);
801 else {
802 ret = __max1363_check_event_mask((1 << number),
803 unifiedmask);
804 if (ret)
805 goto error_ret;
806 st->mask_high |= (1 << number);
807 }
808 }
809
810 max1363_monitor_mode_update(st, !!(st->mask_high | st->mask_low));
811 error_ret:
812 mutex_unlock(&indio_dev->mlock);
813
814 return ret;
815 }
816
817 /*
818 * As with scan_elements, only certain sets of these can
819 * be combined.
820 */
821 static struct attribute *max1363_event_attributes[] = {
822 &iio_dev_attr_sampling_frequency.dev_attr.attr,
823 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
824 NULL,
825 };
826
827 static struct attribute_group max1363_event_attribute_group = {
828 .attrs = max1363_event_attributes,
829 };
830
831 #define MAX1363_EVENT_FUNCS \
832
833
834 static const struct iio_info max1238_info = {
835 .read_raw = &max1363_read_raw,
836 .driver_module = THIS_MODULE,
837 };
838
839 static const struct iio_info max1363_info = {
840 .read_event_value = &max1363_read_thresh,
841 .write_event_value = &max1363_write_thresh,
842 .read_event_config = &max1363_read_event_config,
843 .write_event_config = &max1363_write_event_config,
844 .read_raw = &max1363_read_raw,
845 .driver_module = THIS_MODULE,
846 .num_interrupt_lines = 1,
847 .event_attrs = &max1363_event_attribute_group,
848 };
849
850 /* max1363 and max1368 tested - rest from data sheet */
851 static const struct max1363_chip_info max1363_chip_info_tbl[] = {
852 [max1361] = {
853 .bits = 10,
854 .int_vref_mv = 2048,
855 .mode_list = max1363_mode_list,
856 .num_modes = ARRAY_SIZE(max1363_mode_list),
857 .default_mode = s0to3,
858 .channels = max1361_channels,
859 .num_channels = ARRAY_SIZE(max1361_channels),
860 .info = &max1363_info,
861 },
862 [max1362] = {
863 .bits = 10,
864 .int_vref_mv = 4096,
865 .mode_list = max1363_mode_list,
866 .num_modes = ARRAY_SIZE(max1363_mode_list),
867 .default_mode = s0to3,
868 .channels = max1361_channels,
869 .num_channels = ARRAY_SIZE(max1361_channels),
870 .info = &max1363_info,
871 },
872 [max1363] = {
873 .bits = 12,
874 .int_vref_mv = 2048,
875 .mode_list = max1363_mode_list,
876 .num_modes = ARRAY_SIZE(max1363_mode_list),
877 .default_mode = s0to3,
878 .channels = max1363_channels,
879 .num_channels = ARRAY_SIZE(max1363_channels),
880 .info = &max1363_info,
881 },
882 [max1364] = {
883 .bits = 12,
884 .int_vref_mv = 4096,
885 .mode_list = max1363_mode_list,
886 .num_modes = ARRAY_SIZE(max1363_mode_list),
887 .default_mode = s0to3,
888 .channels = max1363_channels,
889 .num_channels = ARRAY_SIZE(max1363_channels),
890 .info = &max1363_info,
891 },
892 [max1036] = {
893 .bits = 8,
894 .int_vref_mv = 4096,
895 .mode_list = max1236_mode_list,
896 .num_modes = ARRAY_SIZE(max1236_mode_list),
897 .default_mode = s0to3,
898 .info = &max1238_info,
899 .channels = max1036_channels,
900 .num_channels = ARRAY_SIZE(max1036_channels),
901 },
902 [max1037] = {
903 .bits = 8,
904 .int_vref_mv = 2048,
905 .mode_list = max1236_mode_list,
906 .num_modes = ARRAY_SIZE(max1236_mode_list),
907 .default_mode = s0to3,
908 .info = &max1238_info,
909 .channels = max1036_channels,
910 .num_channels = ARRAY_SIZE(max1036_channels),
911 },
912 [max1038] = {
913 .bits = 8,
914 .int_vref_mv = 4096,
915 .mode_list = max1238_mode_list,
916 .num_modes = ARRAY_SIZE(max1238_mode_list),
917 .default_mode = s0to11,
918 .info = &max1238_info,
919 .channels = max1038_channels,
920 .num_channels = ARRAY_SIZE(max1038_channels),
921 },
922 [max1039] = {
923 .bits = 8,
924 .int_vref_mv = 2048,
925 .mode_list = max1238_mode_list,
926 .num_modes = ARRAY_SIZE(max1238_mode_list),
927 .default_mode = s0to11,
928 .info = &max1238_info,
929 .channels = max1038_channels,
930 .num_channels = ARRAY_SIZE(max1038_channels),
931 },
932 [max1136] = {
933 .bits = 10,
934 .int_vref_mv = 4096,
935 .mode_list = max1236_mode_list,
936 .num_modes = ARRAY_SIZE(max1236_mode_list),
937 .default_mode = s0to3,
938 .info = &max1238_info,
939 .channels = max1136_channels,
940 .num_channels = ARRAY_SIZE(max1136_channels),
941 },
942 [max1137] = {
943 .bits = 10,
944 .int_vref_mv = 2048,
945 .mode_list = max1236_mode_list,
946 .num_modes = ARRAY_SIZE(max1236_mode_list),
947 .default_mode = s0to3,
948 .info = &max1238_info,
949 .channels = max1136_channels,
950 .num_channels = ARRAY_SIZE(max1136_channels),
951 },
952 [max1138] = {
953 .bits = 10,
954 .int_vref_mv = 4096,
955 .mode_list = max1238_mode_list,
956 .num_modes = ARRAY_SIZE(max1238_mode_list),
957 .default_mode = s0to11,
958 .info = &max1238_info,
959 .channels = max1138_channels,
960 .num_channels = ARRAY_SIZE(max1138_channels),
961 },
962 [max1139] = {
963 .bits = 10,
964 .int_vref_mv = 2048,
965 .mode_list = max1238_mode_list,
966 .num_modes = ARRAY_SIZE(max1238_mode_list),
967 .default_mode = s0to11,
968 .info = &max1238_info,
969 .channels = max1138_channels,
970 .num_channels = ARRAY_SIZE(max1138_channels),
971 },
972 [max1236] = {
973 .bits = 12,
974 .int_vref_mv = 4096,
975 .mode_list = max1236_mode_list,
976 .num_modes = ARRAY_SIZE(max1236_mode_list),
977 .default_mode = s0to3,
978 .info = &max1238_info,
979 .channels = max1236_channels,
980 .num_channels = ARRAY_SIZE(max1236_channels),
981 },
982 [max1237] = {
983 .bits = 12,
984 .int_vref_mv = 2048,
985 .mode_list = max1236_mode_list,
986 .num_modes = ARRAY_SIZE(max1236_mode_list),
987 .default_mode = s0to3,
988 .info = &max1238_info,
989 .channels = max1236_channels,
990 .num_channels = ARRAY_SIZE(max1236_channels),
991 },
992 [max1238] = {
993 .bits = 12,
994 .int_vref_mv = 4096,
995 .mode_list = max1238_mode_list,
996 .num_modes = ARRAY_SIZE(max1238_mode_list),
997 .default_mode = s0to11,
998 .info = &max1238_info,
999 .channels = max1238_channels,
1000 .num_channels = ARRAY_SIZE(max1238_channels),
1001 },
1002 [max1239] = {
1003 .bits = 12,
1004 .int_vref_mv = 2048,
1005 .mode_list = max1238_mode_list,
1006 .num_modes = ARRAY_SIZE(max1238_mode_list),
1007 .default_mode = s0to11,
1008 .info = &max1238_info,
1009 .channels = max1238_channels,
1010 .num_channels = ARRAY_SIZE(max1238_channels),
1011 },
1012 [max11600] = {
1013 .bits = 8,
1014 .int_vref_mv = 4096,
1015 .mode_list = max11607_mode_list,
1016 .num_modes = ARRAY_SIZE(max11607_mode_list),
1017 .default_mode = s0to3,
1018 .info = &max1238_info,
1019 .channels = max1036_channels,
1020 .num_channels = ARRAY_SIZE(max1036_channels),
1021 },
1022 [max11601] = {
1023 .bits = 8,
1024 .int_vref_mv = 2048,
1025 .mode_list = max11607_mode_list,
1026 .num_modes = ARRAY_SIZE(max11607_mode_list),
1027 .default_mode = s0to3,
1028 .info = &max1238_info,
1029 .channels = max1036_channels,
1030 .num_channels = ARRAY_SIZE(max1036_channels),
1031 },
1032 [max11602] = {
1033 .bits = 8,
1034 .int_vref_mv = 4096,
1035 .mode_list = max11608_mode_list,
1036 .num_modes = ARRAY_SIZE(max11608_mode_list),
1037 .default_mode = s0to7,
1038 .info = &max1238_info,
1039 .channels = max11602_channels,
1040 .num_channels = ARRAY_SIZE(max11602_channels),
1041 },
1042 [max11603] = {
1043 .bits = 8,
1044 .int_vref_mv = 2048,
1045 .mode_list = max11608_mode_list,
1046 .num_modes = ARRAY_SIZE(max11608_mode_list),
1047 .default_mode = s0to7,
1048 .info = &max1238_info,
1049 .channels = max11602_channels,
1050 .num_channels = ARRAY_SIZE(max11602_channels),
1051 },
1052 [max11604] = {
1053 .bits = 8,
1054 .int_vref_mv = 4098,
1055 .mode_list = max1238_mode_list,
1056 .num_modes = ARRAY_SIZE(max1238_mode_list),
1057 .default_mode = s0to11,
1058 .info = &max1238_info,
1059 .channels = max1238_channels,
1060 .num_channels = ARRAY_SIZE(max1238_channels),
1061 },
1062 [max11605] = {
1063 .bits = 8,
1064 .int_vref_mv = 2048,
1065 .mode_list = max1238_mode_list,
1066 .num_modes = ARRAY_SIZE(max1238_mode_list),
1067 .default_mode = s0to11,
1068 .info = &max1238_info,
1069 .channels = max1238_channels,
1070 .num_channels = ARRAY_SIZE(max1238_channels),
1071 },
1072 [max11606] = {
1073 .bits = 10,
1074 .int_vref_mv = 4096,
1075 .mode_list = max11607_mode_list,
1076 .num_modes = ARRAY_SIZE(max11607_mode_list),
1077 .default_mode = s0to3,
1078 .info = &max1238_info,
1079 .channels = max1136_channels,
1080 .num_channels = ARRAY_SIZE(max1136_channels),
1081 },
1082 [max11607] = {
1083 .bits = 10,
1084 .int_vref_mv = 2048,
1085 .mode_list = max11607_mode_list,
1086 .num_modes = ARRAY_SIZE(max11607_mode_list),
1087 .default_mode = s0to3,
1088 .info = &max1238_info,
1089 .channels = max1136_channels,
1090 .num_channels = ARRAY_SIZE(max1136_channels),
1091 },
1092 [max11608] = {
1093 .bits = 10,
1094 .int_vref_mv = 4096,
1095 .mode_list = max11608_mode_list,
1096 .num_modes = ARRAY_SIZE(max11608_mode_list),
1097 .default_mode = s0to7,
1098 .info = &max1238_info,
1099 .channels = max11608_channels,
1100 .num_channels = ARRAY_SIZE(max11608_channels),
1101 },
1102 [max11609] = {
1103 .bits = 10,
1104 .int_vref_mv = 2048,
1105 .mode_list = max11608_mode_list,
1106 .num_modes = ARRAY_SIZE(max11608_mode_list),
1107 .default_mode = s0to7,
1108 .info = &max1238_info,
1109 .channels = max11608_channels,
1110 .num_channels = ARRAY_SIZE(max11608_channels),
1111 },
1112 [max11610] = {
1113 .bits = 10,
1114 .int_vref_mv = 4098,
1115 .mode_list = max1238_mode_list,
1116 .num_modes = ARRAY_SIZE(max1238_mode_list),
1117 .default_mode = s0to11,
1118 .info = &max1238_info,
1119 .channels = max1238_channels,
1120 .num_channels = ARRAY_SIZE(max1238_channels),
1121 },
1122 [max11611] = {
1123 .bits = 10,
1124 .int_vref_mv = 2048,
1125 .mode_list = max1238_mode_list,
1126 .num_modes = ARRAY_SIZE(max1238_mode_list),
1127 .default_mode = s0to11,
1128 .info = &max1238_info,
1129 .channels = max1238_channels,
1130 .num_channels = ARRAY_SIZE(max1238_channels),
1131 },
1132 [max11612] = {
1133 .bits = 12,
1134 .int_vref_mv = 4096,
1135 .mode_list = max11607_mode_list,
1136 .num_modes = ARRAY_SIZE(max11607_mode_list),
1137 .default_mode = s0to3,
1138 .info = &max1238_info,
1139 .channels = max1363_channels,
1140 .num_channels = ARRAY_SIZE(max1363_channels),
1141 },
1142 [max11613] = {
1143 .bits = 12,
1144 .int_vref_mv = 2048,
1145 .mode_list = max11607_mode_list,
1146 .num_modes = ARRAY_SIZE(max11607_mode_list),
1147 .default_mode = s0to3,
1148 .info = &max1238_info,
1149 .channels = max1363_channels,
1150 .num_channels = ARRAY_SIZE(max1363_channels),
1151 },
1152 [max11614] = {
1153 .bits = 12,
1154 .int_vref_mv = 4096,
1155 .mode_list = max11608_mode_list,
1156 .num_modes = ARRAY_SIZE(max11608_mode_list),
1157 .default_mode = s0to7,
1158 .info = &max1238_info,
1159 .channels = max11614_channels,
1160 .num_channels = ARRAY_SIZE(max11614_channels),
1161 },
1162 [max11615] = {
1163 .bits = 12,
1164 .int_vref_mv = 2048,
1165 .mode_list = max11608_mode_list,
1166 .num_modes = ARRAY_SIZE(max11608_mode_list),
1167 .default_mode = s0to7,
1168 .info = &max1238_info,
1169 .channels = max11614_channels,
1170 .num_channels = ARRAY_SIZE(max11614_channels),
1171 },
1172 [max11616] = {
1173 .bits = 12,
1174 .int_vref_mv = 4098,
1175 .mode_list = max1238_mode_list,
1176 .num_modes = ARRAY_SIZE(max1238_mode_list),
1177 .default_mode = s0to11,
1178 .info = &max1238_info,
1179 .channels = max1238_channels,
1180 .num_channels = ARRAY_SIZE(max1238_channels),
1181 },
1182 [max11617] = {
1183 .bits = 12,
1184 .int_vref_mv = 2048,
1185 .mode_list = max1238_mode_list,
1186 .num_modes = ARRAY_SIZE(max1238_mode_list),
1187 .default_mode = s0to11,
1188 .info = &max1238_info,
1189 .channels = max1238_channels,
1190 .num_channels = ARRAY_SIZE(max1238_channels),
1191 },
1192 [max11644] = {
1193 .bits = 12,
1194 .int_vref_mv = 2048,
1195 .mode_list = max11644_mode_list,
1196 .num_modes = ARRAY_SIZE(max11644_mode_list),
1197 .default_mode = s0to1,
1198 .info = &max1238_info,
1199 .channels = max11644_channels,
1200 .num_channels = ARRAY_SIZE(max11644_channels),
1201 },
1202 [max11645] = {
1203 .bits = 12,
1204 .int_vref_mv = 4096,
1205 .mode_list = max11644_mode_list,
1206 .num_modes = ARRAY_SIZE(max11644_mode_list),
1207 .default_mode = s0to1,
1208 .info = &max1238_info,
1209 .channels = max11644_channels,
1210 .num_channels = ARRAY_SIZE(max11644_channels),
1211 },
1212 [max11646] = {
1213 .bits = 10,
1214 .int_vref_mv = 2048,
1215 .mode_list = max11644_mode_list,
1216 .num_modes = ARRAY_SIZE(max11644_mode_list),
1217 .default_mode = s0to1,
1218 .info = &max1238_info,
1219 .channels = max11646_channels,
1220 .num_channels = ARRAY_SIZE(max11646_channels),
1221 },
1222 [max11647] = {
1223 .bits = 10,
1224 .int_vref_mv = 4096,
1225 .mode_list = max11644_mode_list,
1226 .num_modes = ARRAY_SIZE(max11644_mode_list),
1227 .default_mode = s0to1,
1228 .info = &max1238_info,
1229 .channels = max11646_channels,
1230 .num_channels = ARRAY_SIZE(max11646_channels),
1231 },
1232 };
1233
1234
1235
1236 static int max1363_initial_setup(struct max1363_state *st)
1237 {
1238 st->setupbyte = MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD
1239 | MAX1363_SETUP_POWER_UP_INT_REF
1240 | MAX1363_SETUP_INT_CLOCK
1241 | MAX1363_SETUP_UNIPOLAR
1242 | MAX1363_SETUP_NORESET;
1243
1244 /* Set scan mode writes the config anyway so wait until then*/
1245 st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte);
1246 st->current_mode = &max1363_mode_table[st->chip_info->default_mode];
1247 st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte);
1248
1249 return max1363_set_scan_mode(st);
1250 }
1251
1252 static int __devinit max1363_probe(struct i2c_client *client,
1253 const struct i2c_device_id *id)
1254 {
1255 int ret, i, regdone = 0;
1256 struct max1363_state *st;
1257 struct iio_dev *indio_dev;
1258 struct regulator *reg;
1259
1260 reg = regulator_get(&client->dev, "vcc");
1261 if (IS_ERR(reg)) {
1262 ret = PTR_ERR(reg);
1263 goto error_out;
1264 }
1265
1266 ret = regulator_enable(reg);
1267 if (ret)
1268 goto error_put_reg;
1269
1270 indio_dev = iio_allocate_device(sizeof(struct max1363_state));
1271 if (indio_dev == NULL) {
1272 ret = -ENOMEM;
1273 goto error_disable_reg;
1274 }
1275 st = iio_priv(indio_dev);
1276 st->reg = reg;
1277 /* this is only used for device removal purposes */
1278 i2c_set_clientdata(client, indio_dev);
1279
1280 st->chip_info = &max1363_chip_info_tbl[id->driver_data];
1281 st->client = client;
1282
1283 indio_dev->available_scan_masks
1284 = kzalloc(sizeof(*indio_dev->available_scan_masks)*
1285 (st->chip_info->num_modes + 1), GFP_KERNEL);
1286 if (!indio_dev->available_scan_masks) {
1287 ret = -ENOMEM;
1288 goto error_free_device;
1289 }
1290
1291 for (i = 0; i < st->chip_info->num_modes; i++)
1292 indio_dev->available_scan_masks[i] =
1293 max1363_mode_table[st->chip_info->mode_list[i]]
1294 .modemask;
1295 /* Estabilish that the iio_dev is a child of the i2c device */
1296 indio_dev->dev.parent = &client->dev;
1297 indio_dev->name = id->name;
1298
1299 indio_dev->info = st->chip_info->info;
1300 indio_dev->modes = INDIO_DIRECT_MODE;
1301 indio_dev->channels = st->chip_info->channels;
1302 indio_dev->num_channels = st->chip_info->num_channels;
1303 ret = max1363_initial_setup(st);
1304 if (ret < 0)
1305 goto error_free_available_scan_masks;
1306
1307 ret = max1363_register_ring_funcs_and_init(indio_dev);
1308 if (ret)
1309 goto error_free_available_scan_masks;
1310
1311 ret = iio_device_register(indio_dev);
1312 if (ret)
1313 goto error_cleanup_ring;
1314 regdone = 1;
1315 ret = iio_ring_buffer_register_ex(indio_dev->ring, 0,
1316 st->chip_info->channels,
1317 st->chip_info->num_channels);
1318 if (ret)
1319 goto error_cleanup_ring;
1320
1321 if (client->irq) {
1322 ret = request_threaded_irq(st->client->irq,
1323 NULL,
1324 &max1363_event_handler,
1325 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1326 "max1363_event",
1327 indio_dev);
1328
1329 if (ret)
1330 goto error_uninit_ring;
1331 }
1332
1333 return 0;
1334
1335 error_uninit_ring:
1336 iio_ring_buffer_unregister(indio_dev->ring);
1337 error_cleanup_ring:
1338 max1363_ring_cleanup(indio_dev);
1339 error_free_available_scan_masks:
1340 kfree(indio_dev->available_scan_masks);
1341 error_free_device:
1342 if (!regdone)
1343 iio_free_device(indio_dev);
1344 else
1345 iio_device_unregister(indio_dev);
1346 error_disable_reg:
1347 regulator_disable(reg);
1348 error_put_reg:
1349 regulator_put(reg);
1350 error_out:
1351 return ret;
1352 }
1353
1354 static int max1363_remove(struct i2c_client *client)
1355 {
1356 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1357 struct max1363_state *st = iio_priv(indio_dev);
1358 struct regulator *reg = st->reg;
1359
1360 if (client->irq)
1361 free_irq(st->client->irq, indio_dev);
1362 iio_ring_buffer_unregister(indio_dev->ring);
1363 max1363_ring_cleanup(indio_dev);
1364 kfree(indio_dev->available_scan_masks);
1365 if (!IS_ERR(reg)) {
1366 regulator_disable(reg);
1367 regulator_put(reg);
1368 }
1369 iio_device_unregister(indio_dev);
1370
1371 return 0;
1372 }
1373
1374 static const struct i2c_device_id max1363_id[] = {
1375 { "max1361", max1361 },
1376 { "max1362", max1362 },
1377 { "max1363", max1363 },
1378 { "max1364", max1364 },
1379 { "max1036", max1036 },
1380 { "max1037", max1037 },
1381 { "max1038", max1038 },
1382 { "max1039", max1039 },
1383 { "max1136", max1136 },
1384 { "max1137", max1137 },
1385 { "max1138", max1138 },
1386 { "max1139", max1139 },
1387 { "max1236", max1236 },
1388 { "max1237", max1237 },
1389 { "max1238", max1238 },
1390 { "max1239", max1239 },
1391 { "max11600", max11600 },
1392 { "max11601", max11601 },
1393 { "max11602", max11602 },
1394 { "max11603", max11603 },
1395 { "max11604", max11604 },
1396 { "max11605", max11605 },
1397 { "max11606", max11606 },
1398 { "max11607", max11607 },
1399 { "max11608", max11608 },
1400 { "max11609", max11609 },
1401 { "max11610", max11610 },
1402 { "max11611", max11611 },
1403 { "max11612", max11612 },
1404 { "max11613", max11613 },
1405 { "max11614", max11614 },
1406 { "max11615", max11615 },
1407 { "max11616", max11616 },
1408 { "max11617", max11617 },
1409 {}
1410 };
1411
1412 MODULE_DEVICE_TABLE(i2c, max1363_id);
1413
1414 static struct i2c_driver max1363_driver = {
1415 .driver = {
1416 .name = "max1363",
1417 },
1418 .probe = max1363_probe,
1419 .remove = max1363_remove,
1420 .id_table = max1363_id,
1421 };
1422
1423 static __init int max1363_init(void)
1424 {
1425 return i2c_add_driver(&max1363_driver);
1426 }
1427
1428 static __exit void max1363_exit(void)
1429 {
1430 i2c_del_driver(&max1363_driver);
1431 }
1432
1433 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
1434 MODULE_DESCRIPTION("Maxim 1363 ADC");
1435 MODULE_LICENSE("GPL v2");
1436
1437 module_init(max1363_init);
1438 module_exit(max1363_exit);
Linux kernel - Deliverables
This page took 0.060526 seconds and 6 git commands to generate.