?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: mm: Recreate kernel mappings in early_paging_init()
[linux/fpc-iii.git] / drivers / iio / adc / max1363.c
blob4fb35d1d74943b72a77e9a5affe4f8f751382b22
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 #include <linux/module.h>
34
35 #include <linux/iio/iio.h>
36 #include <linux/iio/sysfs.h>
37 #include <linux/iio/events.h>
38 #include <linux/iio/buffer.h>
39 #include <linux/iio/driver.h>
40 #include <linux/iio/kfifo_buf.h>
41 #include <linux/iio/trigger_consumer.h>
42 #include <linux/iio/triggered_buffer.h>
43
44 #define MAX1363_SETUP_BYTE(a) ((a) | 0x80)
45
46 /* There is a fair bit more defined here than currently
47 * used, but the intention is to support everything these
48 * chips do in the long run */
49
50 /* see data sheets */
51 /* max1363 and max1236, max1237, max1238, max1239 */
52 #define MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD 0x00
53 #define MAX1363_SETUP_AIN3_IS_REF_EXT_TO_REF 0x20
54 #define MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_INT 0x40
55 #define MAX1363_SETUP_AIN3_IS_REF_REF_IS_INT 0x60
56 #define MAX1363_SETUP_POWER_UP_INT_REF 0x10
57 #define MAX1363_SETUP_POWER_DOWN_INT_REF 0x00
58
59 /* think about including max11600 etc - more settings */
60 #define MAX1363_SETUP_EXT_CLOCK 0x08
61 #define MAX1363_SETUP_INT_CLOCK 0x00
62 #define MAX1363_SETUP_UNIPOLAR 0x00
63 #define MAX1363_SETUP_BIPOLAR 0x04
64 #define MAX1363_SETUP_RESET 0x00
65 #define MAX1363_SETUP_NORESET 0x02
66 /* max1363 only - though don't care on others.
67 * For now monitor modes are not implemented as the relevant
68 * line is not connected on my test board.
69 * The definitions are here as I intend to add this soon.
70 */
71 #define MAX1363_SETUP_MONITOR_SETUP 0x01
72
73 /* Specific to the max1363 */
74 #define MAX1363_MON_RESET_CHAN(a) (1 << ((a) + 4))
75 #define MAX1363_MON_INT_ENABLE 0x01
76
77 /* defined for readability reasons */
78 /* All chips */
79 #define MAX1363_CONFIG_BYTE(a) ((a))
80
81 #define MAX1363_CONFIG_SE 0x01
82 #define MAX1363_CONFIG_DE 0x00
83 #define MAX1363_CONFIG_SCAN_TO_CS 0x00
84 #define MAX1363_CONFIG_SCAN_SINGLE_8 0x20
85 #define MAX1363_CONFIG_SCAN_MONITOR_MODE 0x40
86 #define MAX1363_CONFIG_SCAN_SINGLE_1 0x60
87 /* max123{6-9} only */
88 #define MAX1236_SCAN_MID_TO_CHANNEL 0x40
89
90 /* max1363 only - merely part of channel selects or don't care for others */
91 #define MAX1363_CONFIG_EN_MON_MODE_READ 0x18
92
93 #define MAX1363_CHANNEL_SEL(a) ((a) << 1)
94
95 /* max1363 strictly 0x06 - but doesn't matter */
96 #define MAX1363_CHANNEL_SEL_MASK 0x1E
97 #define MAX1363_SCAN_MASK 0x60
98 #define MAX1363_SE_DE_MASK 0x01
99
100 #define MAX1363_MAX_CHANNELS 25
101 /**
102 * struct max1363_mode - scan mode information
103 * @conf: The corresponding value of the configuration register
104 * @modemask: Bit mask corresponding to channels enabled in this mode
105 */
106 struct max1363_mode {
107 int8_t conf;
108 DECLARE_BITMAP(modemask, MAX1363_MAX_CHANNELS);
109 };
110
111 /* This must be maintained along side the max1363_mode_table in max1363_core */
112 enum max1363_modes {
113 /* Single read of a single channel */
114 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11,
115 /* Differential single read */
116 d0m1, d2m3, d4m5, d6m7, d8m9, d10m11,
117 d1m0, d3m2, d5m4, d7m6, d9m8, d11m10,
118 /* Scan to channel and mid to channel where overlapping */
119 s0to1, s0to2, s2to3, s0to3, s0to4, s0to5, s0to6,
120 s6to7, s0to7, s6to8, s0to8, s6to9,
121 s0to9, s6to10, s0to10, s6to11, s0to11,
122 /* Differential scan to channel and mid to channel where overlapping */
123 d0m1to2m3, d0m1to4m5, d0m1to6m7, d6m7to8m9,
124 d0m1to8m9, d6m7to10m11, d0m1to10m11, d1m0to3m2,
125 d1m0to5m4, d1m0to7m6, d7m6to9m8, d1m0to9m8,
126 d7m6to11m10, d1m0to11m10,
127 };
128
129 /**
130 * struct max1363_chip_info - chip specifc information
131 * @info: iio core function callbacks structure
132 * @channels: channel specification
133 * @num_channels: number of channels
134 * @mode_list: array of available scan modes
135 * @default_mode: the scan mode in which the chip starts up
136 * @int_vref_mv: the internal reference voltage
137 * @num_modes: number of modes
138 * @bits: accuracy of the adc in bits
139 */
140 struct max1363_chip_info {
141 const struct iio_info *info;
142 const struct iio_chan_spec *channels;
143 int num_channels;
144 const enum max1363_modes *mode_list;
145 enum max1363_modes default_mode;
146 u16 int_vref_mv;
147 u8 num_modes;
148 u8 bits;
149 };
150
151 /**
152 * struct max1363_state - driver instance specific data
153 * @client: i2c_client
154 * @setupbyte: cache of current device setup byte
155 * @configbyte: cache of current device config byte
156 * @chip_info: chip model specific constants, available modes, etc.
157 * @current_mode: the scan mode of this chip
158 * @requestedmask: a valid requested set of channels
159 * @reg: supply regulator
160 * @monitor_on: whether monitor mode is enabled
161 * @monitor_speed: parameter corresponding to device monitor speed setting
162 * @mask_high: bitmask for enabled high thresholds
163 * @mask_low: bitmask for enabled low thresholds
164 * @thresh_high: high threshold values
165 * @thresh_low: low threshold values
166 * @vref: Reference voltage regulator
167 * @vref_uv: Actual (external or internal) reference voltage
168 */
169 struct max1363_state {
170 struct i2c_client *client;
171 u8 setupbyte;
172 u8 configbyte;
173 const struct max1363_chip_info *chip_info;
174 const struct max1363_mode *current_mode;
175 u32 requestedmask;
176 struct regulator *reg;
177
178 /* Using monitor modes and buffer at the same time is
179 currently not supported */
180 bool monitor_on;
181 unsigned int monitor_speed:3;
182 u8 mask_high;
183 u8 mask_low;
184 /* 4x unipolar first then the fours bipolar ones */
185 s16 thresh_high[8];
186 s16 thresh_low[8];
187 struct regulator *vref;
188 u32 vref_uv;
189 };
190
191 #define MAX1363_MODE_SINGLE(_num, _mask) { \
192 .conf = MAX1363_CHANNEL_SEL(_num) \
193 | MAX1363_CONFIG_SCAN_SINGLE_1 \
194 | MAX1363_CONFIG_SE, \
195 .modemask[0] = _mask, \
196 }
197
198 #define MAX1363_MODE_SCAN_TO_CHANNEL(_num, _mask) { \
199 .conf = MAX1363_CHANNEL_SEL(_num) \
200 | MAX1363_CONFIG_SCAN_TO_CS \
201 | MAX1363_CONFIG_SE, \
202 .modemask[0] = _mask, \
203 }
204
205 /* note not available for max1363 hence naming */
206 #define MAX1236_MODE_SCAN_MID_TO_CHANNEL(_mid, _num, _mask) { \
207 .conf = MAX1363_CHANNEL_SEL(_num) \
208 | MAX1236_SCAN_MID_TO_CHANNEL \
209 | MAX1363_CONFIG_SE, \
210 .modemask[0] = _mask \
211 }
212
213 #define MAX1363_MODE_DIFF_SINGLE(_nump, _numm, _mask) { \
214 .conf = MAX1363_CHANNEL_SEL(_nump) \
215 | MAX1363_CONFIG_SCAN_SINGLE_1 \
216 | MAX1363_CONFIG_DE, \
217 .modemask[0] = _mask \
218 }
219
220 /* Can't think how to automate naming so specify for now */
221 #define MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(_num, _numvals, _mask) { \
222 .conf = MAX1363_CHANNEL_SEL(_num) \
223 | MAX1363_CONFIG_SCAN_TO_CS \
224 | MAX1363_CONFIG_DE, \
225 .modemask[0] = _mask \
226 }
227
228 /* note only available for max1363 hence naming */
229 #define MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(_num, _numvals, _mask) { \
230 .conf = MAX1363_CHANNEL_SEL(_num) \
231 | MAX1236_SCAN_MID_TO_CHANNEL \
232 | MAX1363_CONFIG_SE, \
233 .modemask[0] = _mask \
234 }
235
236 static const struct max1363_mode max1363_mode_table[] = {
237 /* All of the single channel options first */
238 MAX1363_MODE_SINGLE(0, 1 << 0),
239 MAX1363_MODE_SINGLE(1, 1 << 1),
240 MAX1363_MODE_SINGLE(2, 1 << 2),
241 MAX1363_MODE_SINGLE(3, 1 << 3),
242 MAX1363_MODE_SINGLE(4, 1 << 4),
243 MAX1363_MODE_SINGLE(5, 1 << 5),
244 MAX1363_MODE_SINGLE(6, 1 << 6),
245 MAX1363_MODE_SINGLE(7, 1 << 7),
246 MAX1363_MODE_SINGLE(8, 1 << 8),
247 MAX1363_MODE_SINGLE(9, 1 << 9),
248 MAX1363_MODE_SINGLE(10, 1 << 10),
249 MAX1363_MODE_SINGLE(11, 1 << 11),
250
251 MAX1363_MODE_DIFF_SINGLE(0, 1, 1 << 12),
252 MAX1363_MODE_DIFF_SINGLE(2, 3, 1 << 13),
253 MAX1363_MODE_DIFF_SINGLE(4, 5, 1 << 14),
254 MAX1363_MODE_DIFF_SINGLE(6, 7, 1 << 15),
255 MAX1363_MODE_DIFF_SINGLE(8, 9, 1 << 16),
256 MAX1363_MODE_DIFF_SINGLE(10, 11, 1 << 17),
257 MAX1363_MODE_DIFF_SINGLE(1, 0, 1 << 18),
258 MAX1363_MODE_DIFF_SINGLE(3, 2, 1 << 19),
259 MAX1363_MODE_DIFF_SINGLE(5, 4, 1 << 20),
260 MAX1363_MODE_DIFF_SINGLE(7, 6, 1 << 21),
261 MAX1363_MODE_DIFF_SINGLE(9, 8, 1 << 22),
262 MAX1363_MODE_DIFF_SINGLE(11, 10, 1 << 23),
263
264 /* The multichannel scans next */
265 MAX1363_MODE_SCAN_TO_CHANNEL(1, 0x003),
266 MAX1363_MODE_SCAN_TO_CHANNEL(2, 0x007),
267 MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3, 0x00C),
268 MAX1363_MODE_SCAN_TO_CHANNEL(3, 0x00F),
269 MAX1363_MODE_SCAN_TO_CHANNEL(4, 0x01F),
270 MAX1363_MODE_SCAN_TO_CHANNEL(5, 0x03F),
271 MAX1363_MODE_SCAN_TO_CHANNEL(6, 0x07F),
272 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7, 0x0C0),
273 MAX1363_MODE_SCAN_TO_CHANNEL(7, 0x0FF),
274 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8, 0x1C0),
275 MAX1363_MODE_SCAN_TO_CHANNEL(8, 0x1FF),
276 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9, 0x3C0),
277 MAX1363_MODE_SCAN_TO_CHANNEL(9, 0x3FF),
278 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10, 0x7C0),
279 MAX1363_MODE_SCAN_TO_CHANNEL(10, 0x7FF),
280 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11, 0xFC0),
281 MAX1363_MODE_SCAN_TO_CHANNEL(11, 0xFFF),
282
283 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(2, 2, 0x003000),
284 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(4, 3, 0x007000),
285 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(6, 4, 0x00F000),
286 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(8, 2, 0x018000),
287 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(8, 5, 0x01F000),
288 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(10, 3, 0x038000),
289 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(10, 6, 0x3F000),
290 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(3, 2, 0x0C0000),
291 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(5, 3, 0x1C0000),
292 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(7, 4, 0x3C0000),
293 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(9, 2, 0x600000),
294 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(9, 5, 0x7C0000),
295 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(11, 3, 0xE00000),
296 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(11, 6, 0xFC0000),
297 };
298
299 static const struct max1363_mode
300 *max1363_match_mode(const unsigned long *mask,
301 const struct max1363_chip_info *ci)
302 {
303 int i;
304 if (mask)
305 for (i = 0; i < ci->num_modes; i++)
306 if (bitmap_subset(mask,
307 max1363_mode_table[ci->mode_list[i]].
308 modemask,
309 MAX1363_MAX_CHANNELS))
310 return &max1363_mode_table[ci->mode_list[i]];
311 return NULL;
312 }
313
314 static int max1363_write_basic_config(struct i2c_client *client,
315 unsigned char d1,
316 unsigned char d2)
317 {
318 u8 tx_buf[2] = {d1, d2};
319
320 return i2c_master_send(client, tx_buf, 2);
321 }
322
323 static int max1363_set_scan_mode(struct max1363_state *st)
324 {
325 st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
326 | MAX1363_SCAN_MASK
327 | MAX1363_SE_DE_MASK);
328 st->configbyte |= st->current_mode->conf;
329
330 return max1363_write_basic_config(st->client,
331 st->setupbyte,
332 st->configbyte);
333 }
334
335 static int max1363_read_single_chan(struct iio_dev *indio_dev,
336 struct iio_chan_spec const *chan,
337 int *val,
338 long m)
339 {
340 int ret = 0;
341 s32 data;
342 u8 rxbuf[2];
343 struct max1363_state *st = iio_priv(indio_dev);
344 struct i2c_client *client = st->client;
345
346 mutex_lock(&indio_dev->mlock);
347 /*
348 * If monitor mode is enabled, the method for reading a single
349 * channel will have to be rather different and has not yet
350 * been implemented.
351 *
352 * Also, cannot read directly if buffered capture enabled.
353 */
354 if (st->monitor_on || iio_buffer_enabled(indio_dev)) {
355 ret = -EBUSY;
356 goto error_ret;
357 }
358
359 /* Check to see if current scan mode is correct */
360 if (st->current_mode != &max1363_mode_table[chan->address]) {
361 /* Update scan mode if needed */
362 st->current_mode = &max1363_mode_table[chan->address];
363 ret = max1363_set_scan_mode(st);
364 if (ret < 0)
365 goto error_ret;
366 }
367 if (st->chip_info->bits != 8) {
368 /* Get reading */
369 data = i2c_master_recv(client, rxbuf, 2);
370 if (data < 0) {
371 ret = data;
372 goto error_ret;
373 }
374 data = (rxbuf[1] | rxbuf[0] << 8) &
375 ((1 << st->chip_info->bits) - 1);
376 } else {
377 /* Get reading */
378 data = i2c_master_recv(client, rxbuf, 1);
379 if (data < 0) {
380 ret = data;
381 goto error_ret;
382 }
383 data = rxbuf[0];
384 }
385 *val = data;
386 error_ret:
387 mutex_unlock(&indio_dev->mlock);
388 return ret;
389
390 }
391
392 static int max1363_read_raw(struct iio_dev *indio_dev,
393 struct iio_chan_spec const *chan,
394 int *val,
395 int *val2,
396 long m)
397 {
398 struct max1363_state *st = iio_priv(indio_dev);
399 int ret;
400 unsigned long scale_uv;
401
402 switch (m) {
403 case IIO_CHAN_INFO_RAW:
404 ret = max1363_read_single_chan(indio_dev, chan, val, m);
405 if (ret < 0)
406 return ret;
407 return IIO_VAL_INT;
408 case IIO_CHAN_INFO_SCALE:
409 scale_uv = st->vref_uv >> st->chip_info->bits;
410 *val = scale_uv / 1000;
411 *val2 = (scale_uv % 1000) * 1000;
412 return IIO_VAL_INT_PLUS_MICRO;
413 default:
414 return -EINVAL;
415 }
416 return 0;
417 }
418
419 /* Applies to max1363 */
420 static const enum max1363_modes max1363_mode_list[] = {
421 _s0, _s1, _s2, _s3,
422 s0to1, s0to2, s0to3,
423 d0m1, d2m3, d1m0, d3m2,
424 d0m1to2m3, d1m0to3m2,
425 };
426
427 #define MAX1363_EV_M \
428 (IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) \
429 | IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING))
430
431 #define MAX1363_CHAN_U(num, addr, si, bits, evmask) \
432 { \
433 .type = IIO_VOLTAGE, \
434 .indexed = 1, \
435 .channel = num, \
436 .address = addr, \
437 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
438 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
439 .datasheet_name = "AIN"#num, \
440 .scan_type = { \
441 .sign = 'u', \
442 .realbits = bits, \
443 .storagebits = (bits > 8) ? 16 : 8, \
444 .endianness = IIO_BE, \
445 }, \
446 .scan_index = si, \
447 .event_mask = evmask, \
448 }
449
450 /* bipolar channel */
451 #define MAX1363_CHAN_B(num, num2, addr, si, bits, evmask) \
452 { \
453 .type = IIO_VOLTAGE, \
454 .differential = 1, \
455 .indexed = 1, \
456 .channel = num, \
457 .channel2 = num2, \
458 .address = addr, \
459 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
460 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
461 .datasheet_name = "AIN"#num"-AIN"#num2, \
462 .scan_type = { \
463 .sign = 's', \
464 .realbits = bits, \
465 .storagebits = (bits > 8) ? 16 : 8, \
466 .endianness = IIO_BE, \
467 }, \
468 .scan_index = si, \
469 .event_mask = evmask, \
470 }
471
472 #define MAX1363_4X_CHANS(bits, em) { \
473 MAX1363_CHAN_U(0, _s0, 0, bits, em), \
474 MAX1363_CHAN_U(1, _s1, 1, bits, em), \
475 MAX1363_CHAN_U(2, _s2, 2, bits, em), \
476 MAX1363_CHAN_U(3, _s3, 3, bits, em), \
477 MAX1363_CHAN_B(0, 1, d0m1, 4, bits, em), \
478 MAX1363_CHAN_B(2, 3, d2m3, 5, bits, em), \
479 MAX1363_CHAN_B(1, 0, d1m0, 6, bits, em), \
480 MAX1363_CHAN_B(3, 2, d3m2, 7, bits, em), \
481 IIO_CHAN_SOFT_TIMESTAMP(8) \
482 }
483
484 static const struct iio_chan_spec max1036_channels[] = MAX1363_4X_CHANS(8, 0);
485 static const struct iio_chan_spec max1136_channels[] = MAX1363_4X_CHANS(10, 0);
486 static const struct iio_chan_spec max1236_channels[] = MAX1363_4X_CHANS(12, 0);
487 static const struct iio_chan_spec max1361_channels[] =
488 MAX1363_4X_CHANS(10, MAX1363_EV_M);
489 static const struct iio_chan_spec max1363_channels[] =
490 MAX1363_4X_CHANS(12, MAX1363_EV_M);
491
492 /* Applies to max1236, max1237 */
493 static const enum max1363_modes max1236_mode_list[] = {
494 _s0, _s1, _s2, _s3,
495 s0to1, s0to2, s0to3,
496 d0m1, d2m3, d1m0, d3m2,
497 d0m1to2m3, d1m0to3m2,
498 s2to3,
499 };
500
501 /* Applies to max1238, max1239 */
502 static const enum max1363_modes max1238_mode_list[] = {
503 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11,
504 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6,
505 s0to7, s0to8, s0to9, s0to10, s0to11,
506 d0m1, d2m3, d4m5, d6m7, d8m9, d10m11,
507 d1m0, d3m2, d5m4, d7m6, d9m8, d11m10,
508 d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11,
509 d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10,
510 s6to7, s6to8, s6to9, s6to10, s6to11,
511 d6m7to8m9, d6m7to10m11, d7m6to9m8, d7m6to11m10,
512 };
513
514 #define MAX1363_12X_CHANS(bits) { \
515 MAX1363_CHAN_U(0, _s0, 0, bits, 0), \
516 MAX1363_CHAN_U(1, _s1, 1, bits, 0), \
517 MAX1363_CHAN_U(2, _s2, 2, bits, 0), \
518 MAX1363_CHAN_U(3, _s3, 3, bits, 0), \
519 MAX1363_CHAN_U(4, _s4, 4, bits, 0), \
520 MAX1363_CHAN_U(5, _s5, 5, bits, 0), \
521 MAX1363_CHAN_U(6, _s6, 6, bits, 0), \
522 MAX1363_CHAN_U(7, _s7, 7, bits, 0), \
523 MAX1363_CHAN_U(8, _s8, 8, bits, 0), \
524 MAX1363_CHAN_U(9, _s9, 9, bits, 0), \
525 MAX1363_CHAN_U(10, _s10, 10, bits, 0), \
526 MAX1363_CHAN_U(11, _s11, 11, bits, 0), \
527 MAX1363_CHAN_B(0, 1, d0m1, 12, bits, 0), \
528 MAX1363_CHAN_B(2, 3, d2m3, 13, bits, 0), \
529 MAX1363_CHAN_B(4, 5, d4m5, 14, bits, 0), \
530 MAX1363_CHAN_B(6, 7, d6m7, 15, bits, 0), \
531 MAX1363_CHAN_B(8, 9, d8m9, 16, bits, 0), \
532 MAX1363_CHAN_B(10, 11, d10m11, 17, bits, 0), \
533 MAX1363_CHAN_B(1, 0, d1m0, 18, bits, 0), \
534 MAX1363_CHAN_B(3, 2, d3m2, 19, bits, 0), \
535 MAX1363_CHAN_B(5, 4, d5m4, 20, bits, 0), \
536 MAX1363_CHAN_B(7, 6, d7m6, 21, bits, 0), \
537 MAX1363_CHAN_B(9, 8, d9m8, 22, bits, 0), \
538 MAX1363_CHAN_B(11, 10, d11m10, 23, bits, 0), \
539 IIO_CHAN_SOFT_TIMESTAMP(24) \
540 }
541 static const struct iio_chan_spec max1038_channels[] = MAX1363_12X_CHANS(8);
542 static const struct iio_chan_spec max1138_channels[] = MAX1363_12X_CHANS(10);
543 static const struct iio_chan_spec max1238_channels[] = MAX1363_12X_CHANS(12);
544
545 static const enum max1363_modes max11607_mode_list[] = {
546 _s0, _s1, _s2, _s3,
547 s0to1, s0to2, s0to3,
548 s2to3,
549 d0m1, d2m3, d1m0, d3m2,
550 d0m1to2m3, d1m0to3m2,
551 };
552
553 static const enum max1363_modes max11608_mode_list[] = {
554 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7,
555 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s0to7,
556 s6to7,
557 d0m1, d2m3, d4m5, d6m7,
558 d1m0, d3m2, d5m4, d7m6,
559 d0m1to2m3, d0m1to4m5, d0m1to6m7,
560 d1m0to3m2, d1m0to5m4, d1m0to7m6,
561 };
562
563 #define MAX1363_8X_CHANS(bits) { \
564 MAX1363_CHAN_U(0, _s0, 0, bits, 0), \
565 MAX1363_CHAN_U(1, _s1, 1, bits, 0), \
566 MAX1363_CHAN_U(2, _s2, 2, bits, 0), \
567 MAX1363_CHAN_U(3, _s3, 3, bits, 0), \
568 MAX1363_CHAN_U(4, _s4, 4, bits, 0), \
569 MAX1363_CHAN_U(5, _s5, 5, bits, 0), \
570 MAX1363_CHAN_U(6, _s6, 6, bits, 0), \
571 MAX1363_CHAN_U(7, _s7, 7, bits, 0), \
572 MAX1363_CHAN_B(0, 1, d0m1, 8, bits, 0), \
573 MAX1363_CHAN_B(2, 3, d2m3, 9, bits, 0), \
574 MAX1363_CHAN_B(4, 5, d4m5, 10, bits, 0), \
575 MAX1363_CHAN_B(6, 7, d6m7, 11, bits, 0), \
576 MAX1363_CHAN_B(1, 0, d1m0, 12, bits, 0), \
577 MAX1363_CHAN_B(3, 2, d3m2, 13, bits, 0), \
578 MAX1363_CHAN_B(5, 4, d5m4, 14, bits, 0), \
579 MAX1363_CHAN_B(7, 6, d7m6, 15, bits, 0), \
580 IIO_CHAN_SOFT_TIMESTAMP(16) \
581 }
582 static const struct iio_chan_spec max11602_channels[] = MAX1363_8X_CHANS(8);
583 static const struct iio_chan_spec max11608_channels[] = MAX1363_8X_CHANS(10);
584 static const struct iio_chan_spec max11614_channels[] = MAX1363_8X_CHANS(12);
585
586 static const enum max1363_modes max11644_mode_list[] = {
587 _s0, _s1, s0to1, d0m1, d1m0,
588 };
589
590 #define MAX1363_2X_CHANS(bits) { \
591 MAX1363_CHAN_U(0, _s0, 0, bits, 0), \
592 MAX1363_CHAN_U(1, _s1, 1, bits, 0), \
593 MAX1363_CHAN_B(0, 1, d0m1, 2, bits, 0), \
594 MAX1363_CHAN_B(1, 0, d1m0, 3, bits, 0), \
595 IIO_CHAN_SOFT_TIMESTAMP(4) \
596 }
597
598 static const struct iio_chan_spec max11646_channels[] = MAX1363_2X_CHANS(10);
599 static const struct iio_chan_spec max11644_channels[] = MAX1363_2X_CHANS(12);
600
601 enum { max1361,
602 max1362,
603 max1363,
604 max1364,
605 max1036,
606 max1037,
607 max1038,
608 max1039,
609 max1136,
610 max1137,
611 max1138,
612 max1139,
613 max1236,
614 max1237,
615 max1238,
616 max1239,
617 max11600,
618 max11601,
619 max11602,
620 max11603,
621 max11604,
622 max11605,
623 max11606,
624 max11607,
625 max11608,
626 max11609,
627 max11610,
628 max11611,
629 max11612,
630 max11613,
631 max11614,
632 max11615,
633 max11616,
634 max11617,
635 max11644,
636 max11645,
637 max11646,
638 max11647
639 };
640
641 static const int max1363_monitor_speeds[] = { 133000, 665000, 33300, 16600,
642 8300, 4200, 2000, 1000 };
643
644 static ssize_t max1363_monitor_show_freq(struct device *dev,
645 struct device_attribute *attr,
646 char *buf)
647 {
648 struct max1363_state *st = iio_priv(dev_to_iio_dev(dev));
649 return sprintf(buf, "%d\n", max1363_monitor_speeds[st->monitor_speed]);
650 }
651
652 static ssize_t max1363_monitor_store_freq(struct device *dev,
653 struct device_attribute *attr,
654 const char *buf,
655 size_t len)
656 {
657 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
658 struct max1363_state *st = iio_priv(indio_dev);
659 int i, ret;
660 unsigned long val;
661 bool found = false;
662
663 ret = kstrtoul(buf, 10, &val);
664 if (ret)
665 return -EINVAL;
666 for (i = 0; i < ARRAY_SIZE(max1363_monitor_speeds); i++)
667 if (val == max1363_monitor_speeds[i]) {
668 found = true;
669 break;
670 }
671 if (!found)
672 return -EINVAL;
673
674 mutex_lock(&indio_dev->mlock);
675 st->monitor_speed = i;
676 mutex_unlock(&indio_dev->mlock);
677
678 return 0;
679 }
680
681 static IIO_DEV_ATTR_SAMP_FREQ(S_IRUGO | S_IWUSR,
682 max1363_monitor_show_freq,
683 max1363_monitor_store_freq);
684
685 static IIO_CONST_ATTR(sampling_frequency_available,
686 "133000 665000 33300 16600 8300 4200 2000 1000");
687
688 static int max1363_read_thresh(struct iio_dev *indio_dev,
689 u64 event_code,
690 int *val)
691 {
692 struct max1363_state *st = iio_priv(indio_dev);
693 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING)
694 *val = st->thresh_low[IIO_EVENT_CODE_EXTRACT_CHAN(event_code)];
695 else
696 *val = st->thresh_high[IIO_EVENT_CODE_EXTRACT_CHAN(event_code)];
697 return 0;
698 }
699
700 static int max1363_write_thresh(struct iio_dev *indio_dev,
701 u64 event_code,
702 int val)
703 {
704 struct max1363_state *st = iio_priv(indio_dev);
705 /* make it handle signed correctly as well */
706 switch (st->chip_info->bits) {
707 case 10:
708 if (val > 0x3FF)
709 return -EINVAL;
710 break;
711 case 12:
712 if (val > 0xFFF)
713 return -EINVAL;
714 break;
715 }
716
717 switch (IIO_EVENT_CODE_EXTRACT_DIR(event_code)) {
718 case IIO_EV_DIR_FALLING:
719 st->thresh_low[IIO_EVENT_CODE_EXTRACT_CHAN(event_code)] = val;
720 break;
721 case IIO_EV_DIR_RISING:
722 st->thresh_high[IIO_EVENT_CODE_EXTRACT_CHAN(event_code)] = val;
723 break;
724 }
725
726 return 0;
727 }
728
729 static const u64 max1363_event_codes[] = {
730 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 0,
731 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
732 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1,
733 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
734 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2,
735 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
736 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3,
737 IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING),
738 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 0,
739 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
740 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 1,
741 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
742 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 2,
743 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
744 IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, 3,
745 IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
746 };
747
748 static irqreturn_t max1363_event_handler(int irq, void *private)
749 {
750 struct iio_dev *indio_dev = private;
751 struct max1363_state *st = iio_priv(indio_dev);
752 s64 timestamp = iio_get_time_ns();
753 unsigned long mask, loc;
754 u8 rx;
755 u8 tx[2] = { st->setupbyte,
756 MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0 };
757
758 i2c_master_recv(st->client, &rx, 1);
759 mask = rx;
760 for_each_set_bit(loc, &mask, 8)
761 iio_push_event(indio_dev, max1363_event_codes[loc], timestamp);
762 i2c_master_send(st->client, tx, 2);
763
764 return IRQ_HANDLED;
765 }
766
767 static int max1363_read_event_config(struct iio_dev *indio_dev,
768 u64 event_code)
769 {
770 struct max1363_state *st = iio_priv(indio_dev);
771 int val;
772 int number = IIO_EVENT_CODE_EXTRACT_CHAN(event_code);
773
774 mutex_lock(&indio_dev->mlock);
775 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING)
776 val = (1 << number) & st->mask_low;
777 else
778 val = (1 << number) & st->mask_high;
779 mutex_unlock(&indio_dev->mlock);
780
781 return val;
782 }
783
784 static int max1363_monitor_mode_update(struct max1363_state *st, int enabled)
785 {
786 u8 *tx_buf;
787 int ret, i = 3, j;
788 unsigned long numelements;
789 int len;
790 const long *modemask;
791
792 if (!enabled) {
793 /* transition to buffered capture is not currently supported */
794 st->setupbyte &= ~MAX1363_SETUP_MONITOR_SETUP;
795 st->configbyte &= ~MAX1363_SCAN_MASK;
796 st->monitor_on = false;
797 return max1363_write_basic_config(st->client,
798 st->setupbyte,
799 st->configbyte);
800 }
801
802 /* Ensure we are in the relevant mode */
803 st->setupbyte |= MAX1363_SETUP_MONITOR_SETUP;
804 st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
805 | MAX1363_SCAN_MASK
806 | MAX1363_SE_DE_MASK);
807 st->configbyte |= MAX1363_CONFIG_SCAN_MONITOR_MODE;
808 if ((st->mask_low | st->mask_high) & 0x0F) {
809 st->configbyte |= max1363_mode_table[s0to3].conf;
810 modemask = max1363_mode_table[s0to3].modemask;
811 } else if ((st->mask_low | st->mask_high) & 0x30) {
812 st->configbyte |= max1363_mode_table[d0m1to2m3].conf;
813 modemask = max1363_mode_table[d0m1to2m3].modemask;
814 } else {
815 st->configbyte |= max1363_mode_table[d1m0to3m2].conf;
816 modemask = max1363_mode_table[d1m0to3m2].modemask;
817 }
818 numelements = bitmap_weight(modemask, MAX1363_MAX_CHANNELS);
819 len = 3 * numelements + 3;
820 tx_buf = kmalloc(len, GFP_KERNEL);
821 if (!tx_buf) {
822 ret = -ENOMEM;
823 goto error_ret;
824 }
825 tx_buf[0] = st->configbyte;
826 tx_buf[1] = st->setupbyte;
827 tx_buf[2] = (st->monitor_speed << 1);
828
829 /*
830 * So we need to do yet another bit of nefarious scan mode
831 * setup to match what we need.
832 */
833 for (j = 0; j < 8; j++)
834 if (test_bit(j, modemask)) {
835 /* Establish the mode is in the scan */
836 if (st->mask_low & (1 << j)) {
837 tx_buf[i] = (st->thresh_low[j] >> 4) & 0xFF;
838 tx_buf[i + 1] = (st->thresh_low[j] << 4) & 0xF0;
839 } else if (j < 4) {
840 tx_buf[i] = 0;
841 tx_buf[i + 1] = 0;
842 } else {
843 tx_buf[i] = 0x80;
844 tx_buf[i + 1] = 0;
845 }
846 if (st->mask_high & (1 << j)) {
847 tx_buf[i + 1] |=
848 (st->thresh_high[j] >> 8) & 0x0F;
849 tx_buf[i + 2] = st->thresh_high[j] & 0xFF;
850 } else if (j < 4) {
851 tx_buf[i + 1] |= 0x0F;
852 tx_buf[i + 2] = 0xFF;
853 } else {
854 tx_buf[i + 1] |= 0x07;
855 tx_buf[i + 2] = 0xFF;
856 }
857 i += 3;
858 }
859
860
861 ret = i2c_master_send(st->client, tx_buf, len);
862 if (ret < 0)
863 goto error_ret;
864 if (ret != len) {
865 ret = -EIO;
866 goto error_ret;
867 }
868
869 /*
870 * Now that we hopefully have sensible thresholds in place it is
871 * time to turn the interrupts on.
872 * It is unclear from the data sheet if this should be necessary
873 * (i.e. whether monitor mode setup is atomic) but it appears to
874 * be in practice.
875 */
876 tx_buf[0] = st->setupbyte;
877 tx_buf[1] = MAX1363_MON_INT_ENABLE | (st->monitor_speed << 1) | 0xF0;
878 ret = i2c_master_send(st->client, tx_buf, 2);
879 if (ret < 0)
880 goto error_ret;
881 if (ret != 2) {
882 ret = -EIO;
883 goto error_ret;
884 }
885 ret = 0;
886 st->monitor_on = true;
887 error_ret:
888
889 kfree(tx_buf);
890
891 return ret;
892 }
893
894 /*
895 * To keep this manageable we always use one of 3 scan modes.
896 * Scan 0...3, 0-1,2-3 and 1-0,3-2
897 */
898
899 static inline int __max1363_check_event_mask(int thismask, int checkmask)
900 {
901 int ret = 0;
902 /* Is it unipolar */
903 if (thismask < 4) {
904 if (checkmask & ~0x0F) {
905 ret = -EBUSY;
906 goto error_ret;
907 }
908 } else if (thismask < 6) {
909 if (checkmask & ~0x30) {
910 ret = -EBUSY;
911 goto error_ret;
912 }
913 } else if (checkmask & ~0xC0)
914 ret = -EBUSY;
915 error_ret:
916 return ret;
917 }
918
919 static int max1363_write_event_config(struct iio_dev *indio_dev,
920 u64 event_code,
921 int state)
922 {
923 int ret = 0;
924 struct max1363_state *st = iio_priv(indio_dev);
925 u16 unifiedmask;
926 int number = IIO_EVENT_CODE_EXTRACT_CHAN(event_code);
927
928 mutex_lock(&indio_dev->mlock);
929 unifiedmask = st->mask_low | st->mask_high;
930 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) == IIO_EV_DIR_FALLING) {
931
932 if (state == 0)
933 st->mask_low &= ~(1 << number);
934 else {
935 ret = __max1363_check_event_mask((1 << number),
936 unifiedmask);
937 if (ret)
938 goto error_ret;
939 st->mask_low |= (1 << number);
940 }
941 } else {
942 if (state == 0)
943 st->mask_high &= ~(1 << number);
944 else {
945 ret = __max1363_check_event_mask((1 << number),
946 unifiedmask);
947 if (ret)
948 goto error_ret;
949 st->mask_high |= (1 << number);
950 }
951 }
952
953 max1363_monitor_mode_update(st, !!(st->mask_high | st->mask_low));
954 error_ret:
955 mutex_unlock(&indio_dev->mlock);
956
957 return ret;
958 }
959
960 /*
961 * As with scan_elements, only certain sets of these can
962 * be combined.
963 */
964 static struct attribute *max1363_event_attributes[] = {
965 &iio_dev_attr_sampling_frequency.dev_attr.attr,
966 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
967 NULL,
968 };
969
970 static struct attribute_group max1363_event_attribute_group = {
971 .attrs = max1363_event_attributes,
972 .name = "events",
973 };
974
975 static int max1363_update_scan_mode(struct iio_dev *indio_dev,
976 const unsigned long *scan_mask)
977 {
978 struct max1363_state *st = iio_priv(indio_dev);
979
980 /*
981 * Need to figure out the current mode based upon the requested
982 * scan mask in iio_dev
983 */
984 st->current_mode = max1363_match_mode(scan_mask, st->chip_info);
985 if (!st->current_mode)
986 return -EINVAL;
987 max1363_set_scan_mode(st);
988 return 0;
989 }
990
991 static const struct iio_info max1238_info = {
992 .read_raw = &max1363_read_raw,
993 .driver_module = THIS_MODULE,
994 .update_scan_mode = &max1363_update_scan_mode,
995 };
996
997 static const struct iio_info max1363_info = {
998 .read_event_value = &max1363_read_thresh,
999 .write_event_value = &max1363_write_thresh,
1000 .read_event_config = &max1363_read_event_config,
1001 .write_event_config = &max1363_write_event_config,
1002 .read_raw = &max1363_read_raw,
1003 .update_scan_mode = &max1363_update_scan_mode,
1004 .driver_module = THIS_MODULE,
1005 .event_attrs = &max1363_event_attribute_group,
1006 };
1007
1008 /* max1363 and max1368 tested - rest from data sheet */
1009 static const struct max1363_chip_info max1363_chip_info_tbl[] = {
1010 [max1361] = {
1011 .bits = 10,
1012 .int_vref_mv = 2048,
1013 .mode_list = max1363_mode_list,
1014 .num_modes = ARRAY_SIZE(max1363_mode_list),
1015 .default_mode = s0to3,
1016 .channels = max1361_channels,
1017 .num_channels = ARRAY_SIZE(max1361_channels),
1018 .info = &max1363_info,
1019 },
1020 [max1362] = {
1021 .bits = 10,
1022 .int_vref_mv = 4096,
1023 .mode_list = max1363_mode_list,
1024 .num_modes = ARRAY_SIZE(max1363_mode_list),
1025 .default_mode = s0to3,
1026 .channels = max1361_channels,
1027 .num_channels = ARRAY_SIZE(max1361_channels),
1028 .info = &max1363_info,
1029 },
1030 [max1363] = {
1031 .bits = 12,
1032 .int_vref_mv = 2048,
1033 .mode_list = max1363_mode_list,
1034 .num_modes = ARRAY_SIZE(max1363_mode_list),
1035 .default_mode = s0to3,
1036 .channels = max1363_channels,
1037 .num_channels = ARRAY_SIZE(max1363_channels),
1038 .info = &max1363_info,
1039 },
1040 [max1364] = {
1041 .bits = 12,
1042 .int_vref_mv = 4096,
1043 .mode_list = max1363_mode_list,
1044 .num_modes = ARRAY_SIZE(max1363_mode_list),
1045 .default_mode = s0to3,
1046 .channels = max1363_channels,
1047 .num_channels = ARRAY_SIZE(max1363_channels),
1048 .info = &max1363_info,
1049 },
1050 [max1036] = {
1051 .bits = 8,
1052 .int_vref_mv = 4096,
1053 .mode_list = max1236_mode_list,
1054 .num_modes = ARRAY_SIZE(max1236_mode_list),
1055 .default_mode = s0to3,
1056 .info = &max1238_info,
1057 .channels = max1036_channels,
1058 .num_channels = ARRAY_SIZE(max1036_channels),
1059 },
1060 [max1037] = {
1061 .bits = 8,
1062 .int_vref_mv = 2048,
1063 .mode_list = max1236_mode_list,
1064 .num_modes = ARRAY_SIZE(max1236_mode_list),
1065 .default_mode = s0to3,
1066 .info = &max1238_info,
1067 .channels = max1036_channels,
1068 .num_channels = ARRAY_SIZE(max1036_channels),
1069 },
1070 [max1038] = {
1071 .bits = 8,
1072 .int_vref_mv = 4096,
1073 .mode_list = max1238_mode_list,
1074 .num_modes = ARRAY_SIZE(max1238_mode_list),
1075 .default_mode = s0to11,
1076 .info = &max1238_info,
1077 .channels = max1038_channels,
1078 .num_channels = ARRAY_SIZE(max1038_channels),
1079 },
1080 [max1039] = {
1081 .bits = 8,
1082 .int_vref_mv = 2048,
1083 .mode_list = max1238_mode_list,
1084 .num_modes = ARRAY_SIZE(max1238_mode_list),
1085 .default_mode = s0to11,
1086 .info = &max1238_info,
1087 .channels = max1038_channels,
1088 .num_channels = ARRAY_SIZE(max1038_channels),
1089 },
1090 [max1136] = {
1091 .bits = 10,
1092 .int_vref_mv = 4096,
1093 .mode_list = max1236_mode_list,
1094 .num_modes = ARRAY_SIZE(max1236_mode_list),
1095 .default_mode = s0to3,
1096 .info = &max1238_info,
1097 .channels = max1136_channels,
1098 .num_channels = ARRAY_SIZE(max1136_channels),
1099 },
1100 [max1137] = {
1101 .bits = 10,
1102 .int_vref_mv = 2048,
1103 .mode_list = max1236_mode_list,
1104 .num_modes = ARRAY_SIZE(max1236_mode_list),
1105 .default_mode = s0to3,
1106 .info = &max1238_info,
1107 .channels = max1136_channels,
1108 .num_channels = ARRAY_SIZE(max1136_channels),
1109 },
1110 [max1138] = {
1111 .bits = 10,
1112 .int_vref_mv = 4096,
1113 .mode_list = max1238_mode_list,
1114 .num_modes = ARRAY_SIZE(max1238_mode_list),
1115 .default_mode = s0to11,
1116 .info = &max1238_info,
1117 .channels = max1138_channels,
1118 .num_channels = ARRAY_SIZE(max1138_channels),
1119 },
1120 [max1139] = {
1121 .bits = 10,
1122 .int_vref_mv = 2048,
1123 .mode_list = max1238_mode_list,
1124 .num_modes = ARRAY_SIZE(max1238_mode_list),
1125 .default_mode = s0to11,
1126 .info = &max1238_info,
1127 .channels = max1138_channels,
1128 .num_channels = ARRAY_SIZE(max1138_channels),
1129 },
1130 [max1236] = {
1131 .bits = 12,
1132 .int_vref_mv = 4096,
1133 .mode_list = max1236_mode_list,
1134 .num_modes = ARRAY_SIZE(max1236_mode_list),
1135 .default_mode = s0to3,
1136 .info = &max1238_info,
1137 .channels = max1236_channels,
1138 .num_channels = ARRAY_SIZE(max1236_channels),
1139 },
1140 [max1237] = {
1141 .bits = 12,
1142 .int_vref_mv = 2048,
1143 .mode_list = max1236_mode_list,
1144 .num_modes = ARRAY_SIZE(max1236_mode_list),
1145 .default_mode = s0to3,
1146 .info = &max1238_info,
1147 .channels = max1236_channels,
1148 .num_channels = ARRAY_SIZE(max1236_channels),
1149 },
1150 [max1238] = {
1151 .bits = 12,
1152 .int_vref_mv = 4096,
1153 .mode_list = max1238_mode_list,
1154 .num_modes = ARRAY_SIZE(max1238_mode_list),
1155 .default_mode = s0to11,
1156 .info = &max1238_info,
1157 .channels = max1238_channels,
1158 .num_channels = ARRAY_SIZE(max1238_channels),
1159 },
1160 [max1239] = {
1161 .bits = 12,
1162 .int_vref_mv = 2048,
1163 .mode_list = max1238_mode_list,
1164 .num_modes = ARRAY_SIZE(max1238_mode_list),
1165 .default_mode = s0to11,
1166 .info = &max1238_info,
1167 .channels = max1238_channels,
1168 .num_channels = ARRAY_SIZE(max1238_channels),
1169 },
1170 [max11600] = {
1171 .bits = 8,
1172 .int_vref_mv = 4096,
1173 .mode_list = max11607_mode_list,
1174 .num_modes = ARRAY_SIZE(max11607_mode_list),
1175 .default_mode = s0to3,
1176 .info = &max1238_info,
1177 .channels = max1036_channels,
1178 .num_channels = ARRAY_SIZE(max1036_channels),
1179 },
1180 [max11601] = {
1181 .bits = 8,
1182 .int_vref_mv = 2048,
1183 .mode_list = max11607_mode_list,
1184 .num_modes = ARRAY_SIZE(max11607_mode_list),
1185 .default_mode = s0to3,
1186 .info = &max1238_info,
1187 .channels = max1036_channels,
1188 .num_channels = ARRAY_SIZE(max1036_channels),
1189 },
1190 [max11602] = {
1191 .bits = 8,
1192 .int_vref_mv = 4096,
1193 .mode_list = max11608_mode_list,
1194 .num_modes = ARRAY_SIZE(max11608_mode_list),
1195 .default_mode = s0to7,
1196 .info = &max1238_info,
1197 .channels = max11602_channels,
1198 .num_channels = ARRAY_SIZE(max11602_channels),
1199 },
1200 [max11603] = {
1201 .bits = 8,
1202 .int_vref_mv = 2048,
1203 .mode_list = max11608_mode_list,
1204 .num_modes = ARRAY_SIZE(max11608_mode_list),
1205 .default_mode = s0to7,
1206 .info = &max1238_info,
1207 .channels = max11602_channels,
1208 .num_channels = ARRAY_SIZE(max11602_channels),
1209 },
1210 [max11604] = {
1211 .bits = 8,
1212 .int_vref_mv = 4098,
1213 .mode_list = max1238_mode_list,
1214 .num_modes = ARRAY_SIZE(max1238_mode_list),
1215 .default_mode = s0to11,
1216 .info = &max1238_info,
1217 .channels = max1238_channels,
1218 .num_channels = ARRAY_SIZE(max1238_channels),
1219 },
1220 [max11605] = {
1221 .bits = 8,
1222 .int_vref_mv = 2048,
1223 .mode_list = max1238_mode_list,
1224 .num_modes = ARRAY_SIZE(max1238_mode_list),
1225 .default_mode = s0to11,
1226 .info = &max1238_info,
1227 .channels = max1238_channels,
1228 .num_channels = ARRAY_SIZE(max1238_channels),
1229 },
1230 [max11606] = {
1231 .bits = 10,
1232 .int_vref_mv = 4096,
1233 .mode_list = max11607_mode_list,
1234 .num_modes = ARRAY_SIZE(max11607_mode_list),
1235 .default_mode = s0to3,
1236 .info = &max1238_info,
1237 .channels = max1136_channels,
1238 .num_channels = ARRAY_SIZE(max1136_channels),
1239 },
1240 [max11607] = {
1241 .bits = 10,
1242 .int_vref_mv = 2048,
1243 .mode_list = max11607_mode_list,
1244 .num_modes = ARRAY_SIZE(max11607_mode_list),
1245 .default_mode = s0to3,
1246 .info = &max1238_info,
1247 .channels = max1136_channels,
1248 .num_channels = ARRAY_SIZE(max1136_channels),
1249 },
1250 [max11608] = {
1251 .bits = 10,
1252 .int_vref_mv = 4096,
1253 .mode_list = max11608_mode_list,
1254 .num_modes = ARRAY_SIZE(max11608_mode_list),
1255 .default_mode = s0to7,
1256 .info = &max1238_info,
1257 .channels = max11608_channels,
1258 .num_channels = ARRAY_SIZE(max11608_channels),
1259 },
1260 [max11609] = {
1261 .bits = 10,
1262 .int_vref_mv = 2048,
1263 .mode_list = max11608_mode_list,
1264 .num_modes = ARRAY_SIZE(max11608_mode_list),
1265 .default_mode = s0to7,
1266 .info = &max1238_info,
1267 .channels = max11608_channels,
1268 .num_channels = ARRAY_SIZE(max11608_channels),
1269 },
1270 [max11610] = {
1271 .bits = 10,
1272 .int_vref_mv = 4098,
1273 .mode_list = max1238_mode_list,
1274 .num_modes = ARRAY_SIZE(max1238_mode_list),
1275 .default_mode = s0to11,
1276 .info = &max1238_info,
1277 .channels = max1238_channels,
1278 .num_channels = ARRAY_SIZE(max1238_channels),
1279 },
1280 [max11611] = {
1281 .bits = 10,
1282 .int_vref_mv = 2048,
1283 .mode_list = max1238_mode_list,
1284 .num_modes = ARRAY_SIZE(max1238_mode_list),
1285 .default_mode = s0to11,
1286 .info = &max1238_info,
1287 .channels = max1238_channels,
1288 .num_channels = ARRAY_SIZE(max1238_channels),
1289 },
1290 [max11612] = {
1291 .bits = 12,
1292 .int_vref_mv = 4096,
1293 .mode_list = max11607_mode_list,
1294 .num_modes = ARRAY_SIZE(max11607_mode_list),
1295 .default_mode = s0to3,
1296 .info = &max1238_info,
1297 .channels = max1363_channels,
1298 .num_channels = ARRAY_SIZE(max1363_channels),
1299 },
1300 [max11613] = {
1301 .bits = 12,
1302 .int_vref_mv = 2048,
1303 .mode_list = max11607_mode_list,
1304 .num_modes = ARRAY_SIZE(max11607_mode_list),
1305 .default_mode = s0to3,
1306 .info = &max1238_info,
1307 .channels = max1363_channels,
1308 .num_channels = ARRAY_SIZE(max1363_channels),
1309 },
1310 [max11614] = {
1311 .bits = 12,
1312 .int_vref_mv = 4096,
1313 .mode_list = max11608_mode_list,
1314 .num_modes = ARRAY_SIZE(max11608_mode_list),
1315 .default_mode = s0to7,
1316 .info = &max1238_info,
1317 .channels = max11614_channels,
1318 .num_channels = ARRAY_SIZE(max11614_channels),
1319 },
1320 [max11615] = {
1321 .bits = 12,
1322 .int_vref_mv = 2048,
1323 .mode_list = max11608_mode_list,
1324 .num_modes = ARRAY_SIZE(max11608_mode_list),
1325 .default_mode = s0to7,
1326 .info = &max1238_info,
1327 .channels = max11614_channels,
1328 .num_channels = ARRAY_SIZE(max11614_channels),
1329 },
1330 [max11616] = {
1331 .bits = 12,
1332 .int_vref_mv = 4098,
1333 .mode_list = max1238_mode_list,
1334 .num_modes = ARRAY_SIZE(max1238_mode_list),
1335 .default_mode = s0to11,
1336 .info = &max1238_info,
1337 .channels = max1238_channels,
1338 .num_channels = ARRAY_SIZE(max1238_channels),
1339 },
1340 [max11617] = {
1341 .bits = 12,
1342 .int_vref_mv = 2048,
1343 .mode_list = max1238_mode_list,
1344 .num_modes = ARRAY_SIZE(max1238_mode_list),
1345 .default_mode = s0to11,
1346 .info = &max1238_info,
1347 .channels = max1238_channels,
1348 .num_channels = ARRAY_SIZE(max1238_channels),
1349 },
1350 [max11644] = {
1351 .bits = 12,
1352 .int_vref_mv = 2048,
1353 .mode_list = max11644_mode_list,
1354 .num_modes = ARRAY_SIZE(max11644_mode_list),
1355 .default_mode = s0to1,
1356 .info = &max1238_info,
1357 .channels = max11644_channels,
1358 .num_channels = ARRAY_SIZE(max11644_channels),
1359 },
1360 [max11645] = {
1361 .bits = 12,
1362 .int_vref_mv = 4096,
1363 .mode_list = max11644_mode_list,
1364 .num_modes = ARRAY_SIZE(max11644_mode_list),
1365 .default_mode = s0to1,
1366 .info = &max1238_info,
1367 .channels = max11644_channels,
1368 .num_channels = ARRAY_SIZE(max11644_channels),
1369 },
1370 [max11646] = {
1371 .bits = 10,
1372 .int_vref_mv = 2048,
1373 .mode_list = max11644_mode_list,
1374 .num_modes = ARRAY_SIZE(max11644_mode_list),
1375 .default_mode = s0to1,
1376 .info = &max1238_info,
1377 .channels = max11646_channels,
1378 .num_channels = ARRAY_SIZE(max11646_channels),
1379 },
1380 [max11647] = {
1381 .bits = 10,
1382 .int_vref_mv = 4096,
1383 .mode_list = max11644_mode_list,
1384 .num_modes = ARRAY_SIZE(max11644_mode_list),
1385 .default_mode = s0to1,
1386 .info = &max1238_info,
1387 .channels = max11646_channels,
1388 .num_channels = ARRAY_SIZE(max11646_channels),
1389 },
1390 };
1391
1392 static int max1363_initial_setup(struct max1363_state *st)
1393 {
1394 st->setupbyte = MAX1363_SETUP_INT_CLOCK
1395 | MAX1363_SETUP_UNIPOLAR
1396 | MAX1363_SETUP_NORESET;
1397
1398 if (st->vref)
1399 st->setupbyte |= MAX1363_SETUP_AIN3_IS_REF_EXT_TO_REF;
1400 else
1401 st->setupbyte |= MAX1363_SETUP_POWER_UP_INT_REF
1402 | MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_INT;
1403
1404 /* Set scan mode writes the config anyway so wait until then */
1405 st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte);
1406 st->current_mode = &max1363_mode_table[st->chip_info->default_mode];
1407 st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte);
1408
1409 return max1363_set_scan_mode(st);
1410 }
1411
1412 static int max1363_alloc_scan_masks(struct iio_dev *indio_dev)
1413 {
1414 struct max1363_state *st = iio_priv(indio_dev);
1415 unsigned long *masks;
1416 int i;
1417
1418 masks = devm_kzalloc(&indio_dev->dev,
1419 BITS_TO_LONGS(MAX1363_MAX_CHANNELS) * sizeof(long) *
1420 (st->chip_info->num_modes + 1), GFP_KERNEL);
1421 if (!masks)
1422 return -ENOMEM;
1423
1424 for (i = 0; i < st->chip_info->num_modes; i++)
1425 bitmap_copy(masks + BITS_TO_LONGS(MAX1363_MAX_CHANNELS)*i,
1426 max1363_mode_table[st->chip_info->mode_list[i]]
1427 .modemask, MAX1363_MAX_CHANNELS);
1428
1429 indio_dev->available_scan_masks = masks;
1430
1431 return 0;
1432 }
1433
1434 static irqreturn_t max1363_trigger_handler(int irq, void *p)
1435 {
1436 struct iio_poll_func *pf = p;
1437 struct iio_dev *indio_dev = pf->indio_dev;
1438 struct max1363_state *st = iio_priv(indio_dev);
1439 s64 time_ns;
1440 __u8 *rxbuf;
1441 int b_sent;
1442 size_t d_size;
1443 unsigned long numvals = bitmap_weight(st->current_mode->modemask,
1444 MAX1363_MAX_CHANNELS);
1445
1446 /* Ensure the timestamp is 8 byte aligned */
1447 if (st->chip_info->bits != 8)
1448 d_size = numvals*2;
1449 else
1450 d_size = numvals;
1451 if (indio_dev->scan_timestamp) {
1452 d_size += sizeof(s64);
1453 if (d_size % sizeof(s64))
1454 d_size += sizeof(s64) - (d_size % sizeof(s64));
1455 }
1456 /* Monitor mode prevents reading. Whilst not currently implemented
1457 * might as well have this test in here in the meantime as it does
1458 * no harm.
1459 */
1460 if (numvals == 0)
1461 goto done;
1462
1463 rxbuf = kmalloc(d_size, GFP_KERNEL);
1464 if (rxbuf == NULL)
1465 goto done;
1466 if (st->chip_info->bits != 8)
1467 b_sent = i2c_master_recv(st->client, rxbuf, numvals*2);
1468 else
1469 b_sent = i2c_master_recv(st->client, rxbuf, numvals);
1470 if (b_sent < 0)
1471 goto done_free;
1472
1473 time_ns = iio_get_time_ns();
1474
1475 if (indio_dev->scan_timestamp)
1476 memcpy(rxbuf + d_size - sizeof(s64), &time_ns, sizeof(time_ns));
1477 iio_push_to_buffers(indio_dev, rxbuf);
1478
1479 done_free:
1480 kfree(rxbuf);
1481 done:
1482 iio_trigger_notify_done(indio_dev->trig);
1483
1484 return IRQ_HANDLED;
1485 }
1486
1487 static const struct iio_buffer_setup_ops max1363_buffered_setup_ops = {
1488 .postenable = &iio_triggered_buffer_postenable,
1489 .preenable = &iio_sw_buffer_preenable,
1490 .predisable = &iio_triggered_buffer_predisable,
1491 };
1492
1493 static int max1363_probe(struct i2c_client *client,
1494 const struct i2c_device_id *id)
1495 {
1496 int ret;
1497 struct max1363_state *st;
1498 struct iio_dev *indio_dev;
1499 struct regulator *vref;
1500
1501 indio_dev = devm_iio_device_alloc(&client->dev,
1502 sizeof(struct max1363_state));
1503 if (!indio_dev)
1504 return -ENOMEM;
1505
1506 indio_dev->dev.of_node = client->dev.of_node;
1507 ret = iio_map_array_register(indio_dev, client->dev.platform_data);
1508 if (ret < 0)
1509 return ret;
1510
1511 st = iio_priv(indio_dev);
1512
1513 st->reg = devm_regulator_get(&client->dev, "vcc");
1514 if (IS_ERR(st->reg)) {
1515 ret = PTR_ERR(st->reg);
1516 goto error_unregister_map;
1517 }
1518
1519 ret = regulator_enable(st->reg);
1520 if (ret)
1521 goto error_unregister_map;
1522
1523 /* this is only used for device removal purposes */
1524 i2c_set_clientdata(client, indio_dev);
1525
1526 st->chip_info = &max1363_chip_info_tbl[id->driver_data];
1527 st->client = client;
1528
1529 st->vref_uv = st->chip_info->int_vref_mv * 1000;
1530 vref = devm_regulator_get(&client->dev, "vref");
1531 if (!IS_ERR(vref)) {
1532 int vref_uv;
1533
1534 ret = regulator_enable(vref);
1535 if (ret)
1536 goto error_disable_reg;
1537 st->vref = vref;
1538 vref_uv = regulator_get_voltage(vref);
1539 if (vref_uv <= 0) {
1540 ret = -EINVAL;
1541 goto error_disable_reg;
1542 }
1543 st->vref_uv = vref_uv;
1544 }
1545
1546 ret = max1363_alloc_scan_masks(indio_dev);
1547 if (ret)
1548 goto error_disable_reg;
1549
1550 /* Establish that the iio_dev is a child of the i2c device */
1551 indio_dev->dev.parent = &client->dev;
1552 indio_dev->name = id->name;
1553 indio_dev->channels = st->chip_info->channels;
1554 indio_dev->num_channels = st->chip_info->num_channels;
1555 indio_dev->info = st->chip_info->info;
1556 indio_dev->modes = INDIO_DIRECT_MODE;
1557 ret = max1363_initial_setup(st);
1558 if (ret < 0)
1559 goto error_disable_reg;
1560
1561 ret = iio_triggered_buffer_setup(indio_dev, NULL,
1562 &max1363_trigger_handler, &max1363_buffered_setup_ops);
1563 if (ret)
1564 goto error_disable_reg;
1565
1566 if (client->irq) {
1567 ret = devm_request_threaded_irq(&client->dev, st->client->irq,
1568 NULL,
1569 &max1363_event_handler,
1570 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1571 "max1363_event",
1572 indio_dev);
1573
1574 if (ret)
1575 goto error_uninit_buffer;
1576 }
1577
1578 ret = iio_device_register(indio_dev);
1579 if (ret < 0)
1580 goto error_uninit_buffer;
1581
1582 return 0;
1583
1584 error_uninit_buffer:
1585 iio_triggered_buffer_cleanup(indio_dev);
1586 error_disable_reg:
1587 if (st->vref)
1588 regulator_disable(st->vref);
1589 regulator_disable(st->reg);
1590 error_unregister_map:
1591 iio_map_array_unregister(indio_dev);
1592 return ret;
1593 }
1594
1595 static int max1363_remove(struct i2c_client *client)
1596 {
1597 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1598 struct max1363_state *st = iio_priv(indio_dev);
1599
1600 iio_device_unregister(indio_dev);
1601 iio_triggered_buffer_cleanup(indio_dev);
1602 if (st->vref)
1603 regulator_disable(st->vref);
1604 regulator_disable(st->reg);
1605 iio_map_array_unregister(indio_dev);
1606
1607 return 0;
1608 }
1609
1610 static const struct i2c_device_id max1363_id[] = {
1611 { "max1361", max1361 },
1612 { "max1362", max1362 },
1613 { "max1363", max1363 },
1614 { "max1364", max1364 },
1615 { "max1036", max1036 },
1616 { "max1037", max1037 },
1617 { "max1038", max1038 },
1618 { "max1039", max1039 },
1619 { "max1136", max1136 },
1620 { "max1137", max1137 },
1621 { "max1138", max1138 },
1622 { "max1139", max1139 },
1623 { "max1236", max1236 },
1624 { "max1237", max1237 },
1625 { "max1238", max1238 },
1626 { "max1239", max1239 },
1627 { "max11600", max11600 },
1628 { "max11601", max11601 },
1629 { "max11602", max11602 },
1630 { "max11603", max11603 },
1631 { "max11604", max11604 },
1632 { "max11605", max11605 },
1633 { "max11606", max11606 },
1634 { "max11607", max11607 },
1635 { "max11608", max11608 },
1636 { "max11609", max11609 },
1637 { "max11610", max11610 },
1638 { "max11611", max11611 },
1639 { "max11612", max11612 },
1640 { "max11613", max11613 },
1641 { "max11614", max11614 },
1642 { "max11615", max11615 },
1643 { "max11616", max11616 },
1644 { "max11617", max11617 },
1645 {}
1646 };
1647
1648 MODULE_DEVICE_TABLE(i2c, max1363_id);
1649
1650 static struct i2c_driver max1363_driver = {
1651 .driver = {
1652 .name = "max1363",
1653 },
1654 .probe = max1363_probe,
1655 .remove = max1363_remove,
1656 .id_table = max1363_id,
1657 };
1658 module_i2c_driver(max1363_driver);
1659
1660 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
1661 MODULE_DESCRIPTION("Maxim 1363 ADC");
1662 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support