projects / deliverable / linux.git / blob
? search:


fa91cc14c64f02db94395821863a4071ec9c7d0e
[deliverable/linux.git] / drivers / staging / iio / adc / max1363_core.c
1 /*
2 * iio/adc/max1363.c
3 * Copyright (C) 2008-2010 Jonathan Cameron
4 *
5 * based on linux/drivers/i2c/chips/max123x
6 * Copyright (C) 2002-2004 Stefan Eletzhofer
7 *
8 * based on linux/drivers/acron/char/pcf8583.c
9 * Copyright (C) 2000 Russell King
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 *
15 * max1363.c
16 *
17 * Partial support for max1363 and similar chips.
18 *
19 * Not currently implemented.
20 *
21 * - Monitor interrrupt generation.
22 * - Control of internal reference.
23 */
24
25 #include <linux/interrupt.h>
26 #include <linux/gpio.h>
27 #include <linux/workqueue.h>
28 #include <linux/device.h>
29 #include <linux/kernel.h>
30 #include <linux/sysfs.h>
31 #include <linux/list.h>
32 #include <linux/i2c.h>
33 #include <linux/rtc.h>
34 #include <linux/regulator/consumer.h>
35 #include <linux/slab.h>
36
37 #include "../iio.h"
38 #include "../sysfs.h"
39
40 #include "../ring_generic.h"
41 #include "adc.h"
42 #include "max1363.h"
43
44 /* Here we claim all are 16 bits. This currently does no harm and saves
45 * us a lot of scan element listings */
46
47 #define MAX1363_SCAN_EL(number) \
48 IIO_SCAN_EL_C(in##number, number, IIO_UNSIGNED(16), 0, NULL);
49 #define MAX1363_SCAN_EL_D(p, n, number) \
50 IIO_SCAN_NAMED_EL_C(in##p##m##in##n, in##p-in##n, \
51 number, IIO_SIGNED(16), 0 , NULL);
52
53 static MAX1363_SCAN_EL(0);
54 static MAX1363_SCAN_EL(1);
55 static MAX1363_SCAN_EL(2);
56 static MAX1363_SCAN_EL(3);
57 static MAX1363_SCAN_EL(4);
58 static MAX1363_SCAN_EL(5);
59 static MAX1363_SCAN_EL(6);
60 static MAX1363_SCAN_EL(7);
61 static MAX1363_SCAN_EL(8);
62 static MAX1363_SCAN_EL(9);
63 static MAX1363_SCAN_EL(10);
64 static MAX1363_SCAN_EL(11);
65 static MAX1363_SCAN_EL_D(0, 1, 12);
66 static MAX1363_SCAN_EL_D(2, 3, 13);
67 static MAX1363_SCAN_EL_D(4, 5, 14);
68 static MAX1363_SCAN_EL_D(6, 7, 15);
69 static MAX1363_SCAN_EL_D(8, 9, 16);
70 static MAX1363_SCAN_EL_D(10, 11, 17);
71 static MAX1363_SCAN_EL_D(1, 0, 18);
72 static MAX1363_SCAN_EL_D(3, 2, 19);
73 static MAX1363_SCAN_EL_D(5, 4, 20);
74 static MAX1363_SCAN_EL_D(7, 6, 21);
75 static MAX1363_SCAN_EL_D(9, 8, 22);
76 static MAX1363_SCAN_EL_D(11, 10, 23);
77
78 static const struct max1363_mode max1363_mode_table[] = {
79 /* All of the single channel options first */
80 MAX1363_MODE_SINGLE(0, 1 << 0),
81 MAX1363_MODE_SINGLE(1, 1 << 1),
82 MAX1363_MODE_SINGLE(2, 1 << 2),
83 MAX1363_MODE_SINGLE(3, 1 << 3),
84 MAX1363_MODE_SINGLE(4, 1 << 4),
85 MAX1363_MODE_SINGLE(5, 1 << 5),
86 MAX1363_MODE_SINGLE(6, 1 << 6),
87 MAX1363_MODE_SINGLE(7, 1 << 7),
88 MAX1363_MODE_SINGLE(8, 1 << 8),
89 MAX1363_MODE_SINGLE(9, 1 << 9),
90 MAX1363_MODE_SINGLE(10, 1 << 10),
91 MAX1363_MODE_SINGLE(11, 1 << 11),
92
93 MAX1363_MODE_DIFF_SINGLE(0, 1, 1 << 12),
94 MAX1363_MODE_DIFF_SINGLE(2, 3, 1 << 13),
95 MAX1363_MODE_DIFF_SINGLE(4, 5, 1 << 14),
96 MAX1363_MODE_DIFF_SINGLE(6, 7, 1 << 15),
97 MAX1363_MODE_DIFF_SINGLE(8, 9, 1 << 16),
98 MAX1363_MODE_DIFF_SINGLE(10, 11, 1 << 17),
99 MAX1363_MODE_DIFF_SINGLE(1, 0, 1 << 18),
100 MAX1363_MODE_DIFF_SINGLE(3, 2, 1 << 19),
101 MAX1363_MODE_DIFF_SINGLE(5, 4, 1 << 20),
102 MAX1363_MODE_DIFF_SINGLE(7, 6, 1 << 21),
103 MAX1363_MODE_DIFF_SINGLE(9, 8, 1 << 22),
104 MAX1363_MODE_DIFF_SINGLE(11, 10, 1 << 23),
105
106 /* The multichannel scans next */
107 MAX1363_MODE_SCAN_TO_CHANNEL(1, 0x003),
108 MAX1363_MODE_SCAN_TO_CHANNEL(2, 0x007),
109 MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3, 0x00C),
110 MAX1363_MODE_SCAN_TO_CHANNEL(3, 0x00F),
111 MAX1363_MODE_SCAN_TO_CHANNEL(4, 0x01F),
112 MAX1363_MODE_SCAN_TO_CHANNEL(5, 0x03F),
113 MAX1363_MODE_SCAN_TO_CHANNEL(6, 0x07F),
114 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7, 0x0C0),
115 MAX1363_MODE_SCAN_TO_CHANNEL(7, 0x0FF),
116 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8, 0x1C0),
117 MAX1363_MODE_SCAN_TO_CHANNEL(8, 0x1FF),
118 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9, 0x3C0),
119 MAX1363_MODE_SCAN_TO_CHANNEL(9, 0x3FF),
120 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10, 0x7C0),
121 MAX1363_MODE_SCAN_TO_CHANNEL(10, 0x7FF),
122 MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11, 0xFC0),
123 MAX1363_MODE_SCAN_TO_CHANNEL(11, 0xFFF),
124
125 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(2, 2, 0x003000),
126 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(4, 3, 0x007000),
127 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(6, 4, 0x00F000),
128 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(8, 2, 0x018000),
129 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(8, 5, 0x01F000),
130 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(10, 3, 0x038000),
131 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(10, 6, 0x3F000),
132 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(3, 2, 0x0C0000),
133 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(5, 3, 0x1C0000),
134 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(7, 4, 0x3C0000),
135 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(9, 2, 0x600000),
136 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(9, 5, 0x7C0000),
137 MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL(11, 3, 0xE00000),
138 MAX1363_MODE_DIFF_SCAN_TO_CHANNEL(11, 6, 0xFC0000),
139 };
140
141 const struct max1363_mode
142 *max1363_match_mode(u32 mask, const struct max1363_chip_info *ci) {
143 int i;
144 if (mask)
145 for (i = 0; i < ci->num_modes; i++)
146 if (!((~max1363_mode_table[ci->mode_list[i]]
147 .modemask) &
148 mask))
149 return &max1363_mode_table[ci
150 ->mode_list[i]];
151 return 0;
152 };
153
154 static ssize_t max1363_show_precision(struct device *dev,
155 struct device_attribute *attr,
156 char *buf)
157 {
158 struct iio_dev *dev_info = dev_get_drvdata(dev);
159 struct max1363_state *st = iio_dev_get_devdata(dev_info);
160 return sprintf(buf, "%d\n", st->chip_info->bits);
161 }
162
163 static IIO_DEVICE_ATTR(in_precision, S_IRUGO, max1363_show_precision,
164 NULL, 0);
165
166 static int max1363_write_basic_config(struct i2c_client *client,
167 unsigned char d1,
168 unsigned char d2)
169 {
170 int ret;
171 u8 *tx_buf = kmalloc(2 , GFP_KERNEL);
172
173 if (!tx_buf)
174 return -ENOMEM;
175 tx_buf[0] = d1;
176 tx_buf[1] = d2;
177
178 ret = i2c_master_send(client, tx_buf, 2);
179 kfree(tx_buf);
180
181 return (ret > 0) ? 0 : ret;
182 }
183
184 int max1363_set_scan_mode(struct max1363_state *st)
185 {
186 st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK
187 | MAX1363_SCAN_MASK
188 | MAX1363_SE_DE_MASK);
189 st->configbyte |= st->current_mode->conf;
190
191 return max1363_write_basic_config(st->client,
192 st->setupbyte,
193 st->configbyte);
194 }
195
196 static ssize_t max1363_read_single_channel(struct device *dev,
197 struct device_attribute *attr,
198 char *buf)
199 {
200 struct iio_dev *dev_info = dev_get_drvdata(dev);
201 struct max1363_state *st = iio_dev_get_devdata(dev_info);
202 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
203 struct i2c_client *client = st->client;
204 int ret = 0, len = 0;
205 s32 data ;
206 char rxbuf[2];
207 long mask;
208
209 mutex_lock(&dev_info->mlock);
210 /* If ring buffer capture is occuring, query the buffer */
211 if (iio_ring_enabled(dev_info)) {
212 mask = max1363_mode_table[this_attr->address].modemask;
213 data = max1363_single_channel_from_ring(mask, st);
214 if (data < 0) {
215 ret = data;
216 goto error_ret;
217 }
218 } else {
219 /* Check to see if current scan mode is correct */
220 if (st->current_mode !=
221 &max1363_mode_table[this_attr->address]) {
222 /* Update scan mode if needed */
223 st->current_mode
224 = &max1363_mode_table[this_attr->address];
225 ret = max1363_set_scan_mode(st);
226 if (ret)
227 goto error_ret;
228 }
229 if (st->chip_info->bits != 8) {
230 /* Get reading */
231 data = i2c_master_recv(client, rxbuf, 2);
232 if (data < 0) {
233 ret = data;
234 goto error_ret;
235 }
236
237 data = (s32)(rxbuf[1]) | ((s32)(rxbuf[0] & 0x0F)) << 8;
238 } else {
239 /* Get reading */
240 data = i2c_master_recv(client, rxbuf, 1);
241 if (data < 0) {
242 ret = data;
243 goto error_ret;
244 }
245 data = rxbuf[0];
246 }
247 }
248 /* Pretty print the result */
249 len = sprintf(buf, "%u\n", data);
250
251 error_ret:
252 mutex_unlock(&dev_info->mlock);
253 return ret ? ret : len;
254 }
255
256 /* Direct read attribtues */
257 static IIO_DEV_ATTR_IN_RAW(0, max1363_read_single_channel, _s0);
258 static IIO_DEV_ATTR_IN_RAW(1, max1363_read_single_channel, _s1);
259 static IIO_DEV_ATTR_IN_RAW(2, max1363_read_single_channel, _s2);
260 static IIO_DEV_ATTR_IN_RAW(3, max1363_read_single_channel, _s3);
261 static IIO_DEV_ATTR_IN_RAW(4, max1363_read_single_channel, _s4);
262 static IIO_DEV_ATTR_IN_RAW(5, max1363_read_single_channel, _s5);
263 static IIO_DEV_ATTR_IN_RAW(6, max1363_read_single_channel, _s6);
264 static IIO_DEV_ATTR_IN_RAW(7, max1363_read_single_channel, _s7);
265 static IIO_DEV_ATTR_IN_RAW(8, max1363_read_single_channel, _s8);
266 static IIO_DEV_ATTR_IN_RAW(9, max1363_read_single_channel, _s9);
267 static IIO_DEV_ATTR_IN_RAW(10, max1363_read_single_channel, _s10);
268 static IIO_DEV_ATTR_IN_RAW(11, max1363_read_single_channel, _s11);
269
270 static IIO_DEV_ATTR_IN_DIFF_RAW(0, 1, max1363_read_single_channel, d0m1);
271 static IIO_DEV_ATTR_IN_DIFF_RAW(2, 3, max1363_read_single_channel, d2m3);
272 static IIO_DEV_ATTR_IN_DIFF_RAW(4, 5, max1363_read_single_channel, d4m5);
273 static IIO_DEV_ATTR_IN_DIFF_RAW(6, 7, max1363_read_single_channel, d6m7);
274 static IIO_DEV_ATTR_IN_DIFF_RAW(8, 9, max1363_read_single_channel, d8m9);
275 static IIO_DEV_ATTR_IN_DIFF_RAW(10, 11, max1363_read_single_channel, d10m11);
276 static IIO_DEV_ATTR_IN_DIFF_RAW(1, 0, max1363_read_single_channel, d1m0);
277 static IIO_DEV_ATTR_IN_DIFF_RAW(3, 2, max1363_read_single_channel, d3m2);
278 static IIO_DEV_ATTR_IN_DIFF_RAW(5, 4, max1363_read_single_channel, d5m4);
279 static IIO_DEV_ATTR_IN_DIFF_RAW(7, 6, max1363_read_single_channel, d7m6);
280 static IIO_DEV_ATTR_IN_DIFF_RAW(9, 8, max1363_read_single_channel, d9m8);
281 static IIO_DEV_ATTR_IN_DIFF_RAW(11, 10, max1363_read_single_channel, d11m10);
282
283
284 static ssize_t max1363_show_scale(struct device *dev,
285 struct device_attribute *attr,
286 char *buf)
287 {
288 /* Driver currently only support internal vref */
289 struct iio_dev *dev_info = dev_get_drvdata(dev);
290 struct max1363_state *st = iio_dev_get_devdata(dev_info);
291 /* Corresponds to Vref / 2^(bits) */
292
293 if ((1 << (st->chip_info->bits + 1))
294 > st->chip_info->int_vref_mv)
295 return sprintf(buf, "0.5\n");
296 else
297 return sprintf(buf, "%d\n",
298 st->chip_info->int_vref_mv >> st->chip_info->bits);
299 }
300
301 IIO_DEVICE_ATTR(in_scale, S_IRUGO, max1363_show_scale, NULL, 0);
302
303 static ssize_t max1363_show_name(struct device *dev,
304 struct device_attribute *attr,
305 char *buf)
306 {
307 struct iio_dev *dev_info = dev_get_drvdata(dev);
308 struct max1363_state *st = iio_dev_get_devdata(dev_info);
309 return sprintf(buf, "%s\n", st->chip_info->name);
310 }
311
312 IIO_DEVICE_ATTR(name, S_IRUGO, max1363_show_name, NULL, 0);
313
314 /* Applies to max1363 */
315 static const enum max1363_modes max1363_mode_list[] = {
316 _s0, _s1, _s2, _s3,
317 s0to1, s0to2, s0to3,
318 d0m1, d2m3, d1m0, d3m2,
319 d0m1to2m3, d1m0to3m2,
320 };
321
322 static struct attribute *max1363_device_attrs[] = {
323 &iio_dev_attr_in0_raw.dev_attr.attr,
324 &iio_dev_attr_in1_raw.dev_attr.attr,
325 &iio_dev_attr_in2_raw.dev_attr.attr,
326 &iio_dev_attr_in3_raw.dev_attr.attr,
327 &iio_dev_attr_in0min1_raw.dev_attr.attr,
328 &iio_dev_attr_in2min3_raw.dev_attr.attr,
329 &iio_dev_attr_in1min0_raw.dev_attr.attr,
330 &iio_dev_attr_in3min2_raw.dev_attr.attr,
331 &iio_dev_attr_name.dev_attr.attr,
332 &iio_dev_attr_in_scale.dev_attr.attr,
333 NULL
334 };
335
336 static struct attribute_group max1363_dev_attr_group = {
337 .attrs = max1363_device_attrs,
338 };
339
340 static struct attribute *max1363_scan_el_attrs[] = {
341 &iio_scan_el_in0.dev_attr.attr,
342 &iio_scan_el_in1.dev_attr.attr,
343 &iio_scan_el_in2.dev_attr.attr,
344 &iio_scan_el_in3.dev_attr.attr,
345 &iio_scan_el_in0min1.dev_attr.attr,
346 &iio_scan_el_in2min3.dev_attr.attr,
347 &iio_scan_el_in1min0.dev_attr.attr,
348 &iio_scan_el_in3min2.dev_attr.attr,
349 &iio_dev_attr_in_precision.dev_attr.attr,
350 NULL,
351 };
352
353 static struct attribute_group max1363_scan_el_group = {
354 .name = "scan_elements",
355 .attrs = max1363_scan_el_attrs,
356 };
357
358 /* Appies to max1236, max1237 */
359 static const enum max1363_modes max1236_mode_list[] = {
360 _s0, _s1, _s2, _s3,
361 s0to1, s0to2, s0to3,
362 d0m1, d2m3, d1m0, d3m2,
363 d0m1to2m3, d1m0to3m2,
364 s2to3,
365 };
366
367 /* Applies to max1238, max1239 */
368 static const enum max1363_modes max1238_mode_list[] = {
369 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11,
370 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6,
371 s0to7, s0to8, s0to9, s0to10, s0to11,
372 d0m1, d2m3, d4m5, d6m7, d8m9, d10m11,
373 d1m0, d3m2, d5m4, d7m6, d9m8, d11m10,
374 d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11,
375 d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10,
376 s6to7, s6to8, s6to9, s6to10, s6to11,
377 d6m7to8m9, d6m7to10m11, d7m6to9m8, d7m6to11m10,
378 };
379
380 static struct attribute *max1238_device_attrs[] = {
381 &iio_dev_attr_in0_raw.dev_attr.attr,
382 &iio_dev_attr_in1_raw.dev_attr.attr,
383 &iio_dev_attr_in2_raw.dev_attr.attr,
384 &iio_dev_attr_in3_raw.dev_attr.attr,
385 &iio_dev_attr_in4_raw.dev_attr.attr,
386 &iio_dev_attr_in5_raw.dev_attr.attr,
387 &iio_dev_attr_in6_raw.dev_attr.attr,
388 &iio_dev_attr_in7_raw.dev_attr.attr,
389 &iio_dev_attr_in8_raw.dev_attr.attr,
390 &iio_dev_attr_in9_raw.dev_attr.attr,
391 &iio_dev_attr_in10_raw.dev_attr.attr,
392 &iio_dev_attr_in11_raw.dev_attr.attr,
393 &iio_dev_attr_in0min1_raw.dev_attr.attr,
394 &iio_dev_attr_in2min3_raw.dev_attr.attr,
395 &iio_dev_attr_in4min5_raw.dev_attr.attr,
396 &iio_dev_attr_in6min7_raw.dev_attr.attr,
397 &iio_dev_attr_in8min9_raw.dev_attr.attr,
398 &iio_dev_attr_in10min11_raw.dev_attr.attr,
399 &iio_dev_attr_in1min0_raw.dev_attr.attr,
400 &iio_dev_attr_in3min2_raw.dev_attr.attr,
401 &iio_dev_attr_in5min4_raw.dev_attr.attr,
402 &iio_dev_attr_in7min6_raw.dev_attr.attr,
403 &iio_dev_attr_in9min8_raw.dev_attr.attr,
404 &iio_dev_attr_in11min10_raw.dev_attr.attr,
405 &iio_dev_attr_name.dev_attr.attr,
406 &iio_dev_attr_in_scale.dev_attr.attr,
407 NULL
408 };
409
410 static struct attribute_group max1238_dev_attr_group = {
411 .attrs = max1238_device_attrs,
412 };
413
414 static struct attribute *max1238_scan_el_attrs[] = {
415 &iio_scan_el_in0.dev_attr.attr,
416 &iio_scan_el_in1.dev_attr.attr,
417 &iio_scan_el_in2.dev_attr.attr,
418 &iio_scan_el_in3.dev_attr.attr,
419 &iio_scan_el_in4.dev_attr.attr,
420 &iio_scan_el_in5.dev_attr.attr,
421 &iio_scan_el_in6.dev_attr.attr,
422 &iio_scan_el_in7.dev_attr.attr,
423 &iio_scan_el_in8.dev_attr.attr,
424 &iio_scan_el_in9.dev_attr.attr,
425 &iio_scan_el_in10.dev_attr.attr,
426 &iio_scan_el_in11.dev_attr.attr,
427 &iio_scan_el_in0min1.dev_attr.attr,
428 &iio_scan_el_in2min3.dev_attr.attr,
429 &iio_scan_el_in4min5.dev_attr.attr,
430 &iio_scan_el_in6min7.dev_attr.attr,
431 &iio_scan_el_in8min9.dev_attr.attr,
432 &iio_scan_el_in10min11.dev_attr.attr,
433 &iio_scan_el_in1min0.dev_attr.attr,
434 &iio_scan_el_in3min2.dev_attr.attr,
435 &iio_scan_el_in5min4.dev_attr.attr,
436 &iio_scan_el_in7min6.dev_attr.attr,
437 &iio_scan_el_in9min8.dev_attr.attr,
438 &iio_scan_el_in11min10.dev_attr.attr,
439 &iio_dev_attr_in_precision.dev_attr.attr,
440 NULL,
441 };
442
443 static struct attribute_group max1238_scan_el_group = {
444 .name = "scan_elements",
445 .attrs = max1238_scan_el_attrs,
446 };
447
448
449 static const enum max1363_modes max11607_mode_list[] = {
450 _s0, _s1, _s2, _s3,
451 s0to1, s0to2, s0to3,
452 s2to3,
453 d0m1, d2m3, d1m0, d3m2,
454 d0m1to2m3, d1m0to3m2,
455 };
456
457 static const enum max1363_modes max11608_mode_list[] = {
458 _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7,
459 s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, s0to7,
460 s6to7,
461 d0m1, d2m3, d4m5, d6m7,
462 d1m0, d3m2, d5m4, d7m6,
463 d0m1to2m3, d0m1to4m5, d0m1to6m7,
464 d1m0to3m2, d1m0to5m4, d1m0to7m6,
465 };
466
467 static struct attribute *max11608_device_attrs[] = {
468 &iio_dev_attr_in0_raw.dev_attr.attr,
469 &iio_dev_attr_in1_raw.dev_attr.attr,
470 &iio_dev_attr_in2_raw.dev_attr.attr,
471 &iio_dev_attr_in3_raw.dev_attr.attr,
472 &iio_dev_attr_in4_raw.dev_attr.attr,
473 &iio_dev_attr_in5_raw.dev_attr.attr,
474 &iio_dev_attr_in6_raw.dev_attr.attr,
475 &iio_dev_attr_in7_raw.dev_attr.attr,
476 &iio_dev_attr_in0min1_raw.dev_attr.attr,
477 &iio_dev_attr_in2min3_raw.dev_attr.attr,
478 &iio_dev_attr_in4min5_raw.dev_attr.attr,
479 &iio_dev_attr_in6min7_raw.dev_attr.attr,
480 &iio_dev_attr_in1min0_raw.dev_attr.attr,
481 &iio_dev_attr_in3min2_raw.dev_attr.attr,
482 &iio_dev_attr_in5min4_raw.dev_attr.attr,
483 &iio_dev_attr_in7min6_raw.dev_attr.attr,
484 &iio_dev_attr_name.dev_attr.attr,
485 &iio_dev_attr_in_scale.dev_attr.attr,
486 NULL
487 };
488
489 static struct attribute_group max11608_dev_attr_group = {
490 .attrs = max11608_device_attrs,
491 };
492
493 static struct attribute *max11608_scan_el_attrs[] = {
494 &iio_scan_el_in0.dev_attr.attr,
495 &iio_scan_el_in1.dev_attr.attr,
496 &iio_scan_el_in2.dev_attr.attr,
497 &iio_scan_el_in3.dev_attr.attr,
498 &iio_scan_el_in4.dev_attr.attr,
499 &iio_scan_el_in5.dev_attr.attr,
500 &iio_scan_el_in6.dev_attr.attr,
501 &iio_scan_el_in7.dev_attr.attr,
502 &iio_scan_el_in0min1.dev_attr.attr,
503 &iio_scan_el_in2min3.dev_attr.attr,
504 &iio_scan_el_in4min5.dev_attr.attr,
505 &iio_scan_el_in6min7.dev_attr.attr,
506 &iio_scan_el_in1min0.dev_attr.attr,
507 &iio_scan_el_in3min2.dev_attr.attr,
508 &iio_scan_el_in5min4.dev_attr.attr,
509 &iio_scan_el_in7min6.dev_attr.attr,
510 &iio_dev_attr_in_precision.dev_attr.attr,
511 };
512
513 static struct attribute_group max11608_scan_el_group = {
514 .name = "scan_elements",
515 .attrs = max11608_scan_el_attrs,
516 };
517
518 enum { max1361,
519 max1362,
520 max1363,
521 max1364,
522 max1036,
523 max1037,
524 max1038,
525 max1039,
526 max1136,
527 max1137,
528 max1138,
529 max1139,
530 max1236,
531 max1237,
532 max1238,
533 max1239,
534 max11600,
535 max11601,
536 max11602,
537 max11603,
538 max11604,
539 max11605,
540 max11606,
541 max11607,
542 max11608,
543 max11609,
544 max11610,
545 max11611,
546 max11612,
547 max11613,
548 max11614,
549 max11615,
550 max11616,
551 max11617,
552 };
553
554 /* max1363 and max1368 tested - rest from data sheet */
555 static const struct max1363_chip_info max1363_chip_info_tbl[] = {
556 {
557 .name = "max1361",
558 .num_inputs = 4,
559 .bits = 10,
560 .int_vref_mv = 2048,
561 .monitor_mode = 1,
562 .mode_list = max1363_mode_list,
563 .num_modes = ARRAY_SIZE(max1363_mode_list),
564 .default_mode = s0to3,
565 .dev_attrs = &max1363_dev_attr_group,
566 .scan_attrs = &max1363_scan_el_group,
567 }, {
568 .name = "max1362",
569 .num_inputs = 4,
570 .bits = 10,
571 .int_vref_mv = 4096,
572 .monitor_mode = 1,
573 .mode_list = max1363_mode_list,
574 .num_modes = ARRAY_SIZE(max1363_mode_list),
575 .default_mode = s0to3,
576 .dev_attrs = &max1363_dev_attr_group,
577 .scan_attrs = &max1363_scan_el_group,
578 }, {
579 .name = "max1363",
580 .num_inputs = 4,
581 .bits = 12,
582 .int_vref_mv = 2048,
583 .monitor_mode = 1,
584 .mode_list = max1363_mode_list,
585 .num_modes = ARRAY_SIZE(max1363_mode_list),
586 .default_mode = s0to3,
587 .dev_attrs = &max1363_dev_attr_group,
588 .scan_attrs = &max1363_scan_el_group,
589 }, {
590 .name = "max1364",
591 .num_inputs = 4,
592 .bits = 12,
593 .int_vref_mv = 4096,
594 .monitor_mode = 1,
595 .mode_list = max1363_mode_list,
596 .num_modes = ARRAY_SIZE(max1363_mode_list),
597 .default_mode = s0to3,
598 .dev_attrs = &max1363_dev_attr_group,
599 .scan_attrs = &max1363_scan_el_group,
600 }, {
601 .name = "max1036",
602 .num_inputs = 4,
603 .bits = 8,
604 .int_vref_mv = 4096,
605 .mode_list = max1236_mode_list,
606 .num_modes = ARRAY_SIZE(max1236_mode_list),
607 .default_mode = s0to3,
608 .dev_attrs = &max1363_dev_attr_group,
609 .scan_attrs = &max1363_scan_el_group,
610 }, {
611 .name = "max1037",
612 .num_inputs = 4,
613 .bits = 8,
614 .int_vref_mv = 2048,
615 .mode_list = max1236_mode_list,
616 .num_modes = ARRAY_SIZE(max1236_mode_list),
617 .default_mode = s0to3,
618 .dev_attrs = &max1363_dev_attr_group,
619 .scan_attrs = &max1363_scan_el_group,
620 }, {
621 .name = "max1038",
622 .num_inputs = 12,
623 .bits = 8,
624 .int_vref_mv = 4096,
625 .mode_list = max1238_mode_list,
626 .num_modes = ARRAY_SIZE(max1238_mode_list),
627 .default_mode = s0to11,
628 .dev_attrs = &max1238_dev_attr_group,
629 .scan_attrs = &max1238_scan_el_group,
630 }, {
631 .name = "max1039",
632 .num_inputs = 12,
633 .bits = 8,
634 .int_vref_mv = 2048,
635 .mode_list = max1238_mode_list,
636 .num_modes = ARRAY_SIZE(max1238_mode_list),
637 .default_mode = s0to11,
638 .dev_attrs = &max1238_dev_attr_group,
639 .scan_attrs = &max1238_scan_el_group,
640 }, {
641 .name = "max1136",
642 .num_inputs = 4,
643 .bits = 10,
644 .int_vref_mv = 4096,
645 .mode_list = max1236_mode_list,
646 .num_modes = ARRAY_SIZE(max1236_mode_list),
647 .default_mode = s0to3,
648 .dev_attrs = &max1363_dev_attr_group,
649 .scan_attrs = &max1363_scan_el_group,
650 }, {
651 .name = "max1137",
652 .num_inputs = 4,
653 .bits = 10,
654 .int_vref_mv = 2048,
655 .mode_list = max1236_mode_list,
656 .num_modes = ARRAY_SIZE(max1236_mode_list),
657 .default_mode = s0to3,
658 .dev_attrs = &max1363_dev_attr_group,
659 .scan_attrs = &max1363_scan_el_group,
660 }, {
661 .name = "max1138",
662 .num_inputs = 12,
663 .bits = 10,
664 .int_vref_mv = 4096,
665 .mode_list = max1238_mode_list,
666 .num_modes = ARRAY_SIZE(max1238_mode_list),
667 .default_mode = s0to11,
668 .dev_attrs = &max1238_dev_attr_group,
669 .scan_attrs = &max1238_scan_el_group,
670 }, {
671 .name = "max1139",
672 .num_inputs = 12,
673 .bits = 10,
674 .int_vref_mv = 2048,
675 .mode_list = max1238_mode_list,
676 .num_modes = ARRAY_SIZE(max1238_mode_list),
677 .default_mode = s0to11,
678 .dev_attrs = &max1238_dev_attr_group,
679 .scan_attrs = &max1238_scan_el_group,
680 }, {
681 .name = "max1236",
682 .num_inputs = 4,
683 .bits = 12,
684 .int_vref_mv = 4096,
685 .mode_list = max1236_mode_list,
686 .num_modes = ARRAY_SIZE(max1236_mode_list),
687 .default_mode = s0to3,
688 .dev_attrs = &max1363_dev_attr_group,
689 .scan_attrs = &max1363_scan_el_group,
690 }, {
691 .name = "max1237",
692 .num_inputs = 4,
693 .bits = 12,
694 .int_vref_mv = 2048,
695 .mode_list = max1236_mode_list,
696 .num_modes = ARRAY_SIZE(max1236_mode_list),
697 .default_mode = s0to3,
698 .dev_attrs = &max1363_dev_attr_group,
699 .scan_attrs = &max1363_scan_el_group,
700 }, {
701 .name = "max1238",
702 .num_inputs = 12,
703 .bits = 12,
704 .int_vref_mv = 4096,
705 .mode_list = max1238_mode_list,
706 .num_modes = ARRAY_SIZE(max1238_mode_list),
707 .default_mode = s0to11,
708 .dev_attrs = &max1238_dev_attr_group,
709 .scan_attrs = &max1238_scan_el_group,
710 }, {
711 .name = "max1239",
712 .num_inputs = 12,
713 .bits = 12,
714 .int_vref_mv = 2048,
715 .mode_list = max1238_mode_list,
716 .num_modes = ARRAY_SIZE(max1238_mode_list),
717 .default_mode = s0to11,
718 .dev_attrs = &max1238_dev_attr_group,
719 .scan_attrs = &max1238_scan_el_group,
720 }, {
721 .name = "max11600",
722 .num_inputs = 4,
723 .bits = 8,
724 .int_vref_mv = 4096,
725 .mode_list = max11607_mode_list,
726 .num_modes = ARRAY_SIZE(max11607_mode_list),
727 .default_mode = s0to3,
728 .dev_attrs = &max1363_dev_attr_group,
729 .scan_attrs = &max1363_scan_el_group,
730 }, {
731 .name = "max11601",
732 .num_inputs = 4,
733 .bits = 8,
734 .int_vref_mv = 2048,
735 .mode_list = max11607_mode_list,
736 .num_modes = ARRAY_SIZE(max11607_mode_list),
737 .default_mode = s0to3,
738 .dev_attrs = &max1363_dev_attr_group,
739 .scan_attrs = &max1363_scan_el_group,
740 }, {
741 .name = "max11602",
742 .num_inputs = 8,
743 .bits = 8,
744 .int_vref_mv = 4096,
745 .mode_list = max11608_mode_list,
746 .num_modes = ARRAY_SIZE(max11608_mode_list),
747 .default_mode = s0to7,
748 .dev_attrs = &max11608_dev_attr_group,
749 .scan_attrs = &max11608_scan_el_group,
750 }, {
751 .name = "max11603",
752 .num_inputs = 8,
753 .bits = 8,
754 .int_vref_mv = 2048,
755 .mode_list = max11608_mode_list,
756 .num_modes = ARRAY_SIZE(max11608_mode_list),
757 .default_mode = s0to7,
758 .dev_attrs = &max11608_dev_attr_group,
759 .scan_attrs = &max11608_scan_el_group,
760 }, {
761 .name = "max11604",
762 .num_inputs = 12,
763 .bits = 8,
764 .int_vref_mv = 4098,
765 .mode_list = max1238_mode_list,
766 .num_modes = ARRAY_SIZE(max1238_mode_list),
767 .default_mode = s0to11,
768 .dev_attrs = &max1238_dev_attr_group,
769 .scan_attrs = &max1238_scan_el_group,
770 }, {
771 .name = "max11605",
772 .num_inputs = 12,
773 .bits = 8,
774 .int_vref_mv = 2048,
775 .mode_list = max1238_mode_list,
776 .num_modes = ARRAY_SIZE(max1238_mode_list),
777 .default_mode = s0to11,
778 .dev_attrs = &max1238_dev_attr_group,
779 .scan_attrs = &max1238_scan_el_group,
780 }, {
781 .name = "max11606",
782 .num_inputs = 4,
783 .bits = 10,
784 .int_vref_mv = 4096,
785 .mode_list = max11607_mode_list,
786 .num_modes = ARRAY_SIZE(max11607_mode_list),
787 .default_mode = s0to3,
788 .dev_attrs = &max1363_dev_attr_group,
789 .scan_attrs = &max1363_scan_el_group,
790 }, {
791 .name = "max11607",
792 .num_inputs = 4,
793 .bits = 10,
794 .int_vref_mv = 2048,
795 .mode_list = max11607_mode_list,
796 .num_modes = ARRAY_SIZE(max11607_mode_list),
797 .default_mode = s0to3,
798 .dev_attrs = &max1363_dev_attr_group,
799 .scan_attrs = &max1363_scan_el_group,
800 }, {
801 .name = "max11608",
802 .num_inputs = 8,
803 .bits = 10,
804 .int_vref_mv = 4096,
805 .mode_list = max11608_mode_list,
806 .num_modes = ARRAY_SIZE(max11608_mode_list),
807 .default_mode = s0to7,
808 .dev_attrs = &max11608_dev_attr_group,
809 .scan_attrs = &max11608_scan_el_group,
810 }, {
811 .name = "max11609",
812 .num_inputs = 8,
813 .bits = 10,
814 .int_vref_mv = 2048,
815 .mode_list = max11608_mode_list,
816 .num_modes = ARRAY_SIZE(max11608_mode_list),
817 .default_mode = s0to7,
818 .dev_attrs = &max11608_dev_attr_group,
819 .scan_attrs = &max11608_scan_el_group,
820 }, {
821 .name = "max11610",
822 .num_inputs = 12,
823 .bits = 10,
824 .int_vref_mv = 4098,
825 .mode_list = max1238_mode_list,
826 .num_modes = ARRAY_SIZE(max1238_mode_list),
827 .default_mode = s0to11,
828 .dev_attrs = &max1238_dev_attr_group,
829 .scan_attrs = &max1238_scan_el_group,
830 }, {
831 .name = "max11611",
832 .num_inputs = 12,
833 .bits = 10,
834 .int_vref_mv = 2048,
835 .mode_list = max1238_mode_list,
836 .num_modes = ARRAY_SIZE(max1238_mode_list),
837 .default_mode = s0to11,
838 .dev_attrs = &max1238_dev_attr_group,
839 .scan_attrs = &max1238_scan_el_group,
840 }, {
841 .name = "max11612",
842 .num_inputs = 4,
843 .bits = 12,
844 .int_vref_mv = 4096,
845 .mode_list = max11607_mode_list,
846 .num_modes = ARRAY_SIZE(max11607_mode_list),
847 .default_mode = s0to3,
848 .dev_attrs = &max1363_dev_attr_group,
849 .scan_attrs = &max1363_scan_el_group,
850 }, {
851 .name = "max11613",
852 .num_inputs = 4,
853 .bits = 12,
854 .int_vref_mv = 2048,
855 .mode_list = max11607_mode_list,
856 .num_modes = ARRAY_SIZE(max11607_mode_list),
857 .default_mode = s0to3,
858 .dev_attrs = &max1363_dev_attr_group,
859 .scan_attrs = &max1363_scan_el_group,
860 }, {
861 .name = "max11614",
862 .num_inputs = 8,
863 .bits = 12,
864 .int_vref_mv = 4096,
865 .mode_list = max11608_mode_list,
866 .num_modes = ARRAY_SIZE(max11608_mode_list),
867 .default_mode = s0to7,
868 .dev_attrs = &max11608_dev_attr_group,
869 .scan_attrs = &max11608_scan_el_group,
870 }, {
871 .name = "max11615",
872 .num_inputs = 8,
873 .bits = 12,
874 .int_vref_mv = 2048,
875 .mode_list = max11608_mode_list,
876 .num_modes = ARRAY_SIZE(max11608_mode_list),
877 .default_mode = s0to7,
878 .dev_attrs = &max11608_dev_attr_group,
879 .scan_attrs = &max11608_scan_el_group,
880 }, {
881 .name = "max11616",
882 .num_inputs = 12,
883 .bits = 12,
884 .int_vref_mv = 4098,
885 .mode_list = max1238_mode_list,
886 .num_modes = ARRAY_SIZE(max1238_mode_list),
887 .default_mode = s0to11,
888 .dev_attrs = &max1238_dev_attr_group,
889 .scan_attrs = &max1238_scan_el_group,
890 }, {
891 .name = "max11617",
892 .num_inputs = 12,
893 .bits = 12,
894 .int_vref_mv = 2048,
895 .mode_list = max1238_mode_list,
896 .num_modes = ARRAY_SIZE(max1238_mode_list),
897 .default_mode = s0to11,
898 .dev_attrs = &max1238_dev_attr_group,
899 .scan_attrs = &max1238_scan_el_group,
900 }
901 };
902
903 static int max1363_initial_setup(struct max1363_state *st)
904 {
905 st->setupbyte = MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD
906 | MAX1363_SETUP_POWER_UP_INT_REF
907 | MAX1363_SETUP_INT_CLOCK
908 | MAX1363_SETUP_UNIPOLAR
909 | MAX1363_SETUP_NORESET;
910
911 /* Set scan mode writes the config anyway so wait until then*/
912 st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte);
913 st->current_mode = &max1363_mode_table[st->chip_info->default_mode];
914 st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte);
915
916 return max1363_set_scan_mode(st);
917 }
918
919 static int __devinit max1363_probe(struct i2c_client *client,
920 const struct i2c_device_id *id)
921 {
922 int ret, i, regdone = 0;
923 struct max1363_state *st = kzalloc(sizeof(*st), GFP_KERNEL);
924 if (st == NULL) {
925 ret = -ENOMEM;
926 goto error_ret;
927 }
928
929 /* this is only used for device removal purposes */
930 i2c_set_clientdata(client, st);
931
932 atomic_set(&st->protect_ring, 0);
933
934 /* Find the chip model specific data */
935 for (i = 0; i < ARRAY_SIZE(max1363_chip_info_tbl); i++)
936 if (!strcmp(max1363_chip_info_tbl[i].name, id->name)) {
937 st->chip_info = &max1363_chip_info_tbl[i];
938 break;
939 };
940 /* Unsupported chip */
941 if (!st->chip_info) {
942 dev_err(&client->dev, "%s is not supported\n", id->name);
943 ret = -ENODEV;
944 goto error_free_st;
945 }
946
947 st->reg = regulator_get(&client->dev, "vcc");
948 if (!IS_ERR(st->reg)) {
949 ret = regulator_enable(st->reg);
950 if (ret)
951 goto error_put_reg;
952 }
953 st->client = client;
954
955 st->indio_dev = iio_allocate_device();
956 if (st->indio_dev == NULL) {
957 ret = -ENOMEM;
958 goto error_disable_reg;
959 }
960
961 st->indio_dev->available_scan_masks
962 = kzalloc(GFP_KERNEL,
963 sizeof(*st->indio_dev->available_scan_masks)*
964 (st->chip_info->num_modes + 1));
965 if (!st->indio_dev->available_scan_masks) {
966 ret = -ENOMEM;
967 goto error_free_device;
968 }
969
970 for (i = 0; i < st->chip_info->num_modes; i++)
971 st->indio_dev->available_scan_masks[i] =
972 max1363_mode_table[st->chip_info->mode_list[i]]
973 .modemask;
974 /* Estabilish that the iio_dev is a child of the i2c device */
975 st->indio_dev->dev.parent = &client->dev;
976 st->indio_dev->attrs = st->chip_info->dev_attrs;
977
978 /* Todo: this shouldn't be here. */
979 st->indio_dev->scan_el_attrs = st->chip_info->scan_attrs;
980 st->indio_dev->dev_data = (void *)(st);
981 st->indio_dev->driver_module = THIS_MODULE;
982 st->indio_dev->modes = INDIO_DIRECT_MODE;
983
984 ret = max1363_initial_setup(st);
985 if (ret)
986 goto error_free_available_scan_masks;
987
988 ret = max1363_register_ring_funcs_and_init(st->indio_dev);
989 if (ret)
990 goto error_free_available_scan_masks;
991
992 ret = iio_device_register(st->indio_dev);
993 if (ret)
994 goto error_cleanup_ring;
995 regdone = 1;
996 ret = max1363_initialize_ring(st->indio_dev->ring);
997 if (ret)
998 goto error_cleanup_ring;
999 return 0;
1000 error_cleanup_ring:
1001 max1363_ring_cleanup(st->indio_dev);
1002 error_free_available_scan_masks:
1003 kfree(st->indio_dev->available_scan_masks);
1004 error_free_device:
1005 if (!regdone)
1006 iio_free_device(st->indio_dev);
1007 else
1008 iio_device_unregister(st->indio_dev);
1009 error_disable_reg:
1010 if (!IS_ERR(st->reg))
1011 regulator_disable(st->reg);
1012 error_put_reg:
1013 if (!IS_ERR(st->reg))
1014 regulator_put(st->reg);
1015 error_free_st:
1016 kfree(st);
1017
1018 error_ret:
1019 return ret;
1020 }
1021
1022 static int max1363_remove(struct i2c_client *client)
1023 {
1024 struct max1363_state *st = i2c_get_clientdata(client);
1025 struct iio_dev *indio_dev = st->indio_dev;
1026 max1363_uninitialize_ring(indio_dev->ring);
1027 max1363_ring_cleanup(indio_dev);
1028 kfree(st->indio_dev->available_scan_masks);
1029 iio_device_unregister(indio_dev);
1030 if (!IS_ERR(st->reg)) {
1031 regulator_disable(st->reg);
1032 regulator_put(st->reg);
1033 }
1034 kfree(st);
1035
1036 return 0;
1037 }
1038
1039 static const struct i2c_device_id max1363_id[] = {
1040 { "max1361", max1361 },
1041 { "max1362", max1362 },
1042 { "max1363", max1363 },
1043 { "max1364", max1364 },
1044 { "max1036", max1036 },
1045 { "max1037", max1037 },
1046 { "max1038", max1038 },
1047 { "max1039", max1039 },
1048 { "max1136", max1136 },
1049 { "max1137", max1137 },
1050 { "max1138", max1138 },
1051 { "max1139", max1139 },
1052 { "max1236", max1236 },
1053 { "max1237", max1237 },
1054 { "max1238", max1238 },
1055 { "max1239", max1239 },
1056 { "max11600", max11600 },
1057 { "max11601", max11601 },
1058 { "max11602", max11602 },
1059 { "max11603", max11603 },
1060 { "max11604", max11604 },
1061 { "max11605", max11605 },
1062 { "max11606", max11606 },
1063 { "max11607", max11607 },
1064 { "max11608", max11608 },
1065 { "max11609", max11609 },
1066 { "max11610", max11610 },
1067 { "max11611", max11611 },
1068 { "max11612", max11612 },
1069 { "max11613", max11613 },
1070 { "max11614", max11614 },
1071 { "max11615", max11615 },
1072 { "max11616", max11616 },
1073 { "max11617", max11617 },
1074 {}
1075 };
1076
1077 MODULE_DEVICE_TABLE(i2c, max1363_id);
1078
1079 static struct i2c_driver max1363_driver = {
1080 .driver = {
1081 .name = "max1363",
1082 },
1083 .probe = max1363_probe,
1084 .remove = max1363_remove,
1085 .id_table = max1363_id,
1086 };
1087
1088 static __init int max1363_init(void)
1089 {
1090 return i2c_add_driver(&max1363_driver);
1091 }
1092
1093 static __exit void max1363_exit(void)
1094 {
1095 i2c_del_driver(&max1363_driver);
1096 }
1097
1098 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
1099 MODULE_DESCRIPTION("Maxim 1363 ADC");
1100 MODULE_LICENSE("GPL v2");
1101
1102 module_init(max1363_init);
1103 module_exit(max1363_exit);
Linux kernel - Deliverables
This page took 0.068869 seconds and 4 git commands to generate.