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