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