]>
Commit | Line | Data |
---|---|---|
d1325cf4 JC |
1 | /* |
2 | * linux/drivers/industrialio/adc/max1363.c | |
3 | * Copyright (C) 2008 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 | * - Sysfs scan interface currently assumes unipolar mode. | |
24 | */ | |
25 | ||
26 | #include <linux/interrupt.h> | |
27 | #include <linux/gpio.h> | |
28 | #include <linux/workqueue.h> | |
29 | #include <linux/device.h> | |
30 | #include <linux/kernel.h> | |
31 | #include <linux/sysfs.h> | |
32 | #include <linux/list.h> | |
33 | #include <linux/i2c.h> | |
34 | #include <linux/rtc.h> | |
35 | #include <linux/regulator/consumer.h> | |
5a0e3ad6 | 36 | #include <linux/slab.h> |
d1325cf4 JC |
37 | |
38 | #include "../iio.h" | |
39 | #include "../sysfs.h" | |
40 | ||
41 | #include "max1363.h" | |
42 | ||
43 | /* Available scan modes. | |
44 | * Awkwardly the associated enum is in the header so it is available to | |
45 | * the ring buffer code. | |
46 | */ | |
47 | static const struct max1363_mode max1363_mode_table[] = { | |
48 | MAX1363_MODE_SINGLE(0), | |
49 | MAX1363_MODE_SINGLE(1), | |
50 | MAX1363_MODE_SINGLE(2), | |
51 | MAX1363_MODE_SINGLE(3), | |
52 | MAX1363_MODE_SINGLE(4), | |
53 | MAX1363_MODE_SINGLE(5), | |
54 | MAX1363_MODE_SINGLE(6), | |
55 | MAX1363_MODE_SINGLE(7), | |
56 | MAX1363_MODE_SINGLE(8), | |
57 | MAX1363_MODE_SINGLE(9), | |
58 | MAX1363_MODE_SINGLE(10), | |
59 | MAX1363_MODE_SINGLE(11), | |
60 | ||
61 | MAX1363_MODE_SINGLE_TIMES_8(0), | |
62 | MAX1363_MODE_SINGLE_TIMES_8(1), | |
63 | MAX1363_MODE_SINGLE_TIMES_8(2), | |
64 | MAX1363_MODE_SINGLE_TIMES_8(3), | |
65 | MAX1363_MODE_SINGLE_TIMES_8(4), | |
66 | MAX1363_MODE_SINGLE_TIMES_8(5), | |
67 | MAX1363_MODE_SINGLE_TIMES_8(6), | |
68 | MAX1363_MODE_SINGLE_TIMES_8(7), | |
69 | MAX1363_MODE_SINGLE_TIMES_8(8), | |
70 | MAX1363_MODE_SINGLE_TIMES_8(9), | |
71 | MAX1363_MODE_SINGLE_TIMES_8(10), | |
72 | MAX1363_MODE_SINGLE_TIMES_8(11), | |
73 | ||
74 | MAX1363_MODE_SCAN_TO_CHANNEL(1), | |
75 | MAX1363_MODE_SCAN_TO_CHANNEL(2), | |
76 | MAX1363_MODE_SCAN_TO_CHANNEL(3), | |
77 | MAX1363_MODE_SCAN_TO_CHANNEL(4), | |
78 | MAX1363_MODE_SCAN_TO_CHANNEL(5), | |
79 | MAX1363_MODE_SCAN_TO_CHANNEL(6), | |
80 | MAX1363_MODE_SCAN_TO_CHANNEL(7), | |
81 | MAX1363_MODE_SCAN_TO_CHANNEL(8), | |
82 | MAX1363_MODE_SCAN_TO_CHANNEL(9), | |
83 | MAX1363_MODE_SCAN_TO_CHANNEL(10), | |
84 | MAX1363_MODE_SCAN_TO_CHANNEL(11), | |
85 | ||
86 | MAX1363_MODE_DIFF_SINGLE(0, 1), | |
87 | MAX1363_MODE_DIFF_SINGLE(2, 3), | |
88 | MAX1363_MODE_DIFF_SINGLE(4, 5), | |
89 | MAX1363_MODE_DIFF_SINGLE(6, 7), | |
90 | MAX1363_MODE_DIFF_SINGLE(8, 9), | |
91 | MAX1363_MODE_DIFF_SINGLE(10, 11), | |
92 | MAX1363_MODE_DIFF_SINGLE(1, 0), | |
93 | MAX1363_MODE_DIFF_SINGLE(3, 2), | |
94 | MAX1363_MODE_DIFF_SINGLE(5, 4), | |
95 | MAX1363_MODE_DIFF_SINGLE(7, 6), | |
96 | MAX1363_MODE_DIFF_SINGLE(9, 8), | |
97 | MAX1363_MODE_DIFF_SINGLE(11, 10), | |
98 | ||
99 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(0, 1), | |
100 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(2, 3), | |
101 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(4, 5), | |
102 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(6, 7), | |
103 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(8, 9), | |
104 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(10, 11), | |
105 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(1, 0), | |
106 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(3, 2), | |
107 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(5, 4), | |
108 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(7, 6), | |
109 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(9, 8), | |
110 | MAX1363_MODE_DIFF_SINGLE_TIMES_8(11, 10), | |
111 | ||
112 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...2-3, 2, 2), | |
113 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...4-5, 4, 3), | |
114 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...6-7, 6, 4), | |
115 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...8-9, 8, 5), | |
116 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(0-1...10-11, 10, 6), | |
117 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...3-2, 3, 2), | |
118 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...5-4, 5, 3), | |
119 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...7-6, 7, 4), | |
120 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...9-8, 9, 5), | |
121 | MAX1363_MODE_DIFF_SCAN_TO_CHANNEL_NAMED(1-0...11-10, 11, 6), | |
122 | ||
123 | MAX1236_MODE_SCAN_MID_TO_CHANNEL(2, 3), | |
124 | MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 7), | |
125 | MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 8), | |
126 | MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 9), | |
127 | MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 10), | |
128 | MAX1236_MODE_SCAN_MID_TO_CHANNEL(6, 11), | |
129 | ||
130 | MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(6-7...8-9, 8, 2), | |
131 | MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(6-7...10-11, 10, 3), | |
132 | MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(7-6...9-8, 9, 2), | |
133 | MAX1236_MODE_DIFF_SCAN_MID_TO_CHANNEL_NAMED(7-6...11-10, 11, 3), | |
134 | }; | |
135 | ||
136 | /* Applies to max1363 */ | |
137 | static const enum max1363_modes max1363_mode_list[] = { | |
138 | _s0, _s1, _s2, _s3, | |
139 | se0, se1, se2, se3, | |
140 | s0to1, s0to2, s0to3, | |
141 | d0m1, d2m3, d1m0, d3m2, | |
142 | de0m1, de2m3, de1m0, de3m2, | |
143 | d0m1to2m3, d1m0to3m2, | |
144 | }; | |
145 | ||
146 | /* Appies to max1236, max1237 */ | |
147 | static const enum max1363_modes max1236_mode_list[] = { | |
148 | _s0, _s1, _s2, _s3, | |
149 | se0, se1, se2, se3, | |
150 | s0to1, s0to2, s0to3, | |
151 | d0m1, d2m3, d1m0, d3m2, | |
152 | de0m1, de2m3, de1m0, de3m2, | |
153 | d0m1to2m3, d1m0to3m2, | |
154 | s2to3, | |
155 | }; | |
156 | ||
157 | /* Applies to max1238, max1239 */ | |
158 | static const enum max1363_modes max1238_mode_list[] = { | |
159 | _s0, _s1, _s2, _s3, _s4, _s5, _s6, _s7, _s8, _s9, _s10, _s11, | |
160 | se0, se1, se2, se3, se4, se5, se6, se7, se8, se9, se10, se11, | |
161 | s0to1, s0to2, s0to3, s0to4, s0to5, s0to6, | |
162 | s0to7, s0to8, s0to9, s0to10, s0to11, | |
163 | d0m1, d2m3, d4m5, d6m7, d8m9, d10m11, | |
164 | d1m0, d3m2, d5m4, d7m6, d9m8, d11m10, | |
165 | de0m1, de2m3, de4m5, de6m7, de8m9, de10m11, | |
166 | de1m0, de3m2, de5m4, de7m6, de9m8, de11m10, | |
167 | d0m1to2m3, d0m1to4m5, d0m1to6m7, d0m1to8m9, d0m1to10m11, | |
168 | d1m0to3m2, d1m0to5m4, d1m0to7m6, d1m0to9m8, d1m0to11m10, | |
169 | s6to7, s6to8, s6to9, s6to10, s6to11, | |
170 | s6m7to8m9, s6m7to10m11, s7m6to9m8, s7m6to11m10, | |
171 | }; | |
172 | ||
173 | ||
174 | enum { max1361, | |
175 | max1362, | |
176 | max1363, | |
177 | max1364, | |
178 | max1136, | |
179 | max1137, | |
180 | max1138, | |
181 | max1139, | |
182 | max1236, | |
183 | max1237, | |
184 | max1238, | |
185 | max1239, | |
186 | }; | |
187 | ||
188 | /* max1363 and max1368 tested - rest from data sheet */ | |
189 | static const struct max1363_chip_info max1363_chip_info_tbl[] = { | |
190 | { | |
191 | .name = "max1361", | |
192 | .num_inputs = 4, | |
193 | .monitor_mode = 1, | |
194 | .mode_list = max1363_mode_list, | |
195 | .num_modes = ARRAY_SIZE(max1363_mode_list), | |
196 | .default_mode = s0to3, | |
197 | }, { | |
198 | .name = "max1362", | |
199 | .num_inputs = 4, | |
200 | .monitor_mode = 1, | |
201 | .mode_list = max1363_mode_list, | |
202 | .num_modes = ARRAY_SIZE(max1363_mode_list), | |
203 | .default_mode = s0to3, | |
204 | }, { | |
205 | .name = "max1363", | |
206 | .num_inputs = 4, | |
207 | .monitor_mode = 1, | |
208 | .mode_list = max1363_mode_list, | |
209 | .num_modes = ARRAY_SIZE(max1363_mode_list), | |
210 | .default_mode = s0to3, | |
211 | }, { | |
212 | .name = "max1364", | |
213 | .num_inputs = 4, | |
214 | .monitor_mode = 1, | |
215 | .mode_list = max1363_mode_list, | |
216 | .num_modes = ARRAY_SIZE(max1363_mode_list), | |
217 | .default_mode = s0to3, | |
218 | }, { | |
219 | .name = "max1136", | |
220 | .num_inputs = 4, | |
221 | .int_vref_mv = 4096, | |
222 | .mode_list = max1236_mode_list, | |
223 | .num_modes = ARRAY_SIZE(max1236_mode_list), | |
224 | .default_mode = s0to3, | |
225 | }, { | |
226 | .name = "max1137", | |
227 | .num_inputs = 4, | |
228 | .int_vref_mv = 2048, | |
229 | .mode_list = max1236_mode_list, | |
230 | .num_modes = ARRAY_SIZE(max1236_mode_list), | |
231 | .default_mode = s0to3, | |
232 | }, { | |
233 | .name = "max1138", | |
234 | .num_inputs = 12, | |
235 | .int_vref_mv = 4096, | |
236 | .mode_list = max1238_mode_list, | |
237 | .num_modes = ARRAY_SIZE(max1238_mode_list), | |
238 | .default_mode = s0to11, | |
239 | }, { | |
240 | .name = "max1139", | |
241 | .num_inputs = 12, | |
242 | .int_vref_mv = 2048, | |
243 | .mode_list = max1238_mode_list, | |
244 | .num_modes = ARRAY_SIZE(max1238_mode_list), | |
245 | .default_mode = s0to11, | |
246 | }, { | |
247 | .name = "max1236", | |
248 | .num_inputs = 4, | |
249 | .int_vref_mv = 4096, | |
250 | .mode_list = max1236_mode_list, | |
251 | .num_modes = ARRAY_SIZE(max1236_mode_list), | |
252 | .default_mode = s0to3, | |
253 | }, { | |
254 | .name = "max1237", | |
255 | .num_inputs = 4, | |
256 | .int_vref_mv = 2048, | |
257 | .mode_list = max1236_mode_list, | |
258 | .num_modes = ARRAY_SIZE(max1236_mode_list), | |
259 | .default_mode = s0to3, | |
260 | }, { | |
261 | .name = "max1238", | |
262 | .num_inputs = 12, | |
263 | .int_vref_mv = 4096, | |
264 | .mode_list = max1238_mode_list, | |
265 | .num_modes = ARRAY_SIZE(max1238_mode_list), | |
266 | .default_mode = s0to11, | |
267 | }, { | |
268 | .name = "max1239", | |
269 | .num_inputs = 12, | |
270 | .int_vref_mv = 2048, | |
271 | .mode_list = max1238_mode_list, | |
272 | .num_modes = ARRAY_SIZE(max1238_mode_list), | |
273 | .default_mode = s0to11, | |
274 | }, | |
275 | }; | |
276 | ||
277 | static int max1363_write_basic_config(struct i2c_client *client, | |
278 | unsigned char d1, | |
279 | unsigned char d2) | |
280 | { | |
281 | int ret; | |
282 | u8 *tx_buf = kmalloc(2 , GFP_KERNEL); | |
283 | if (!tx_buf) | |
284 | return -ENOMEM; | |
285 | tx_buf[0] = d1; | |
286 | tx_buf[1] = d2; | |
287 | ||
288 | ret = i2c_master_send(client, tx_buf, 2); | |
289 | kfree(tx_buf); | |
290 | return (ret > 0) ? 0 : ret; | |
291 | } | |
292 | ||
293 | static int max1363_set_scan_mode(struct max1363_state *st) | |
294 | { | |
295 | st->configbyte &= ~(MAX1363_CHANNEL_SEL_MASK | |
296 | | MAX1363_SCAN_MASK | |
297 | | MAX1363_SE_DE_MASK); | |
298 | st->configbyte |= st->current_mode->conf; | |
299 | ||
300 | return max1363_write_basic_config(st->client, | |
301 | st->setupbyte, | |
302 | st->configbyte); | |
303 | } | |
304 | ||
305 | static int max1363_initial_setup(struct max1363_state *st) | |
306 | { | |
307 | st->setupbyte = MAX1363_SETUP_AIN3_IS_AIN3_REF_IS_VDD | |
308 | | MAX1363_SETUP_POWER_UP_INT_REF | |
309 | | MAX1363_SETUP_INT_CLOCK | |
310 | | MAX1363_SETUP_UNIPOLAR | |
311 | | MAX1363_SETUP_NORESET; | |
312 | ||
313 | /* Set scan mode writes the config anyway so wait until then*/ | |
314 | st->setupbyte = MAX1363_SETUP_BYTE(st->setupbyte); | |
315 | st->current_mode = &max1363_mode_table[st->chip_info->default_mode]; | |
316 | st->configbyte = MAX1363_CONFIG_BYTE(st->configbyte); | |
317 | ||
318 | return max1363_set_scan_mode(st); | |
319 | } | |
320 | ||
321 | static ssize_t max1363_show_av_scan_modes(struct device *dev, | |
322 | struct device_attribute *attr, | |
323 | char *buf) | |
324 | { | |
325 | struct iio_dev *dev_info = dev_get_drvdata(dev); | |
326 | struct max1363_state *st = dev_info->dev_data; | |
327 | int i, len = 0; | |
328 | ||
329 | for (i = 0; i < st->chip_info->num_modes; i++) | |
330 | len += sprintf(buf + len, "%s ", | |
331 | max1363_mode_table[st->chip_info | |
332 | ->mode_list[i]].name); | |
333 | len += sprintf(buf + len, "\n"); | |
334 | ||
335 | return len; | |
336 | } | |
337 | ||
338 | ||
339 | /* The dev here is the sysfs related one, not the underlying i2c one */ | |
340 | static ssize_t max1363_scan_direct(struct device *dev, | |
341 | struct device_attribute *attr, | |
342 | char *buf) | |
343 | { | |
344 | struct iio_dev *dev_info = dev_get_drvdata(dev); | |
345 | struct max1363_state *st = dev_info->dev_data; | |
346 | int len = 0, ret, i; | |
347 | struct i2c_client *client = st->client; | |
348 | char *rxbuf; | |
349 | ||
350 | if (st->current_mode->numvals == 0) | |
351 | return 0; | |
352 | rxbuf = kmalloc(st->current_mode->numvals*2, GFP_KERNEL); | |
353 | if (rxbuf == NULL) | |
354 | return -ENOMEM; | |
355 | ||
356 | /* Interpretation depends on whether these are signed or not!*/ | |
357 | /* Assume not for now */ | |
358 | ret = i2c_master_recv(client, rxbuf, st->current_mode->numvals*2); | |
359 | ||
360 | if (ret < 0) | |
361 | return ret; | |
362 | for (i = 0; i < st->current_mode->numvals; i++) | |
363 | len += sprintf(buf+len, "%d ", | |
364 | ((int)(rxbuf[i*2+0]&0x0F) << 8) | |
365 | + ((int)(rxbuf[i*2+1]))); | |
366 | kfree(rxbuf); | |
367 | len += sprintf(buf + len, "\n"); | |
368 | ||
369 | return len; | |
370 | } | |
371 | ||
372 | static ssize_t max1363_scan(struct device *dev, | |
373 | struct device_attribute *attr, | |
374 | char *buf) | |
375 | { | |
376 | struct iio_dev *dev_info = dev_get_drvdata(dev); | |
377 | int ret; | |
378 | ||
379 | mutex_lock(&dev_info->mlock); | |
380 | if (dev_info->currentmode == INDIO_RING_TRIGGERED) | |
381 | ret = max1363_scan_from_ring(dev, attr, buf); | |
382 | else | |
383 | ret = max1363_scan_direct(dev, attr, buf); | |
384 | mutex_unlock(&dev_info->mlock); | |
385 | ||
386 | return ret; | |
387 | } | |
388 | ||
389 | /* Cannot query the device, so use local copy of state */ | |
390 | static ssize_t max1363_show_scan_mode(struct device *dev, | |
391 | struct device_attribute *attr, | |
392 | char *buf) | |
393 | { | |
394 | struct iio_dev *dev_info = dev_get_drvdata(dev); | |
395 | struct max1363_state *st = dev_info->dev_data; | |
396 | ||
397 | return sprintf(buf, "%s\n", st->current_mode->name); | |
398 | } | |
399 | ||
400 | static const struct max1363_mode | |
401 | *__max1363_find_mode_in_ci(const struct max1363_chip_info *info, | |
402 | const char *buf) | |
403 | { | |
404 | int i; | |
405 | for (i = 0; i < info->num_modes; i++) | |
406 | if (strcmp(max1363_mode_table[info->mode_list[i]].name, buf) | |
407 | == 0) | |
408 | return &max1363_mode_table[info->mode_list[i]]; | |
409 | return NULL; | |
410 | } | |
411 | ||
412 | static ssize_t max1363_store_scan_mode(struct device *dev, | |
413 | struct device_attribute *attr, | |
414 | const char *buf, | |
415 | size_t len) | |
416 | { | |
417 | struct iio_dev *dev_info = dev_get_drvdata(dev); | |
418 | struct max1363_state *st = dev_info->dev_data; | |
419 | const struct max1363_mode *new_mode; | |
420 | int ret; | |
421 | ||
422 | mutex_lock(&dev_info->mlock); | |
423 | new_mode = NULL; | |
424 | /* Avoid state changes if a ring buffer is enabled */ | |
425 | if (!iio_ring_enabled(dev_info)) { | |
426 | new_mode | |
427 | = __max1363_find_mode_in_ci(st->chip_info, buf); | |
428 | if (!new_mode) { | |
429 | ret = -EINVAL; | |
430 | goto error_ret; | |
431 | } | |
432 | st->current_mode = new_mode; | |
433 | ret = max1363_set_scan_mode(st); | |
434 | if (ret) | |
435 | goto error_ret; | |
436 | } else { | |
437 | ret = -EBUSY; | |
438 | goto error_ret; | |
439 | } | |
440 | mutex_unlock(&dev_info->mlock); | |
441 | ||
442 | return len; | |
443 | ||
444 | error_ret: | |
445 | mutex_unlock(&dev_info->mlock); | |
446 | ||
447 | return ret; | |
448 | } | |
449 | ||
450 | IIO_DEV_ATTR_AVAIL_SCAN_MODES(max1363_show_av_scan_modes); | |
451 | IIO_DEV_ATTR_SCAN_MODE(S_IRUGO | S_IWUSR, | |
452 | max1363_show_scan_mode, | |
453 | max1363_store_scan_mode); | |
454 | ||
455 | IIO_DEV_ATTR_SCAN(max1363_scan); | |
456 | ||
457 | static ssize_t max1363_show_name(struct device *dev, | |
458 | struct device_attribute *attr, | |
459 | char *buf) | |
460 | { | |
461 | struct iio_dev *dev_info = dev_get_drvdata(dev); | |
462 | struct max1363_state *st = dev_info->dev_data; | |
463 | return sprintf(buf, "%s\n", st->chip_info->name); | |
464 | } | |
465 | ||
466 | IIO_DEVICE_ATTR(name, S_IRUGO, max1363_show_name, NULL, 0); | |
467 | ||
468 | /*name export */ | |
469 | ||
470 | static struct attribute *max1363_attributes[] = { | |
471 | &iio_dev_attr_available_scan_modes.dev_attr.attr, | |
472 | &iio_dev_attr_scan_mode.dev_attr.attr, | |
473 | &iio_dev_attr_scan.dev_attr.attr, | |
474 | &iio_dev_attr_name.dev_attr.attr, | |
475 | NULL, | |
476 | }; | |
477 | ||
478 | static const struct attribute_group max1363_attribute_group = { | |
479 | .attrs = max1363_attributes, | |
480 | }; | |
481 | ||
482 | static int __devinit max1363_probe(struct i2c_client *client, | |
483 | const struct i2c_device_id *id) | |
484 | { | |
485 | int ret, i, regdone = 0; | |
486 | struct max1363_state *st = kzalloc(sizeof(*st), GFP_KERNEL); | |
487 | if (st == NULL) { | |
488 | ret = -ENOMEM; | |
489 | goto error_ret; | |
490 | } | |
491 | ||
492 | /* this is only used for device removal purposes */ | |
493 | i2c_set_clientdata(client, st); | |
494 | ||
495 | atomic_set(&st->protect_ring, 0); | |
496 | ||
497 | /* Find the chip model specific data */ | |
498 | for (i = 0; i < ARRAY_SIZE(max1363_chip_info_tbl); i++) | |
499 | if (!strcmp(max1363_chip_info_tbl[i].name, id->name)) { | |
500 | st->chip_info = &max1363_chip_info_tbl[i]; | |
501 | break; | |
502 | }; | |
503 | /* Unsupported chip */ | |
504 | if (!st->chip_info) { | |
505 | dev_err(&client->dev, "%s is not supported\n", id->name); | |
506 | ret = -ENODEV; | |
507 | goto error_free_st; | |
508 | } | |
509 | st->reg = regulator_get(&client->dev, "vcc"); | |
510 | if (!IS_ERR(st->reg)) { | |
511 | ret = regulator_enable(st->reg); | |
512 | if (ret) | |
513 | goto error_put_reg; | |
514 | } | |
515 | st->client = client; | |
516 | ||
517 | st->indio_dev = iio_allocate_device(); | |
518 | if (st->indio_dev == NULL) { | |
519 | ret = -ENOMEM; | |
520 | goto error_disable_reg; | |
521 | } | |
522 | ||
523 | /* Estabilish that the iio_dev is a child of the i2c device */ | |
524 | st->indio_dev->dev.parent = &client->dev; | |
525 | st->indio_dev->attrs = &max1363_attribute_group; | |
526 | st->indio_dev->dev_data = (void *)(st); | |
527 | st->indio_dev->driver_module = THIS_MODULE; | |
528 | st->indio_dev->modes = INDIO_DIRECT_MODE; | |
529 | ||
530 | ret = max1363_initial_setup(st); | |
531 | if (ret) | |
532 | goto error_free_device; | |
533 | ||
534 | ret = max1363_register_ring_funcs_and_init(st->indio_dev); | |
535 | if (ret) | |
536 | goto error_free_device; | |
537 | ||
538 | ret = iio_device_register(st->indio_dev); | |
539 | if (ret) | |
540 | goto error_cleanup_ring; | |
541 | regdone = 1; | |
542 | ret = max1363_initialize_ring(st->indio_dev->ring); | |
543 | if (ret) | |
544 | goto error_cleanup_ring; | |
545 | return 0; | |
546 | error_cleanup_ring: | |
547 | max1363_ring_cleanup(st->indio_dev); | |
548 | error_free_device: | |
549 | if (!regdone) | |
550 | iio_free_device(st->indio_dev); | |
551 | else | |
552 | iio_device_unregister(st->indio_dev); | |
553 | error_disable_reg: | |
554 | if (!IS_ERR(st->reg)) | |
555 | regulator_disable(st->reg); | |
556 | error_put_reg: | |
557 | if (!IS_ERR(st->reg)) | |
558 | regulator_put(st->reg); | |
559 | error_free_st: | |
560 | kfree(st); | |
561 | ||
562 | error_ret: | |
563 | return ret; | |
564 | } | |
565 | ||
566 | static int max1363_remove(struct i2c_client *client) | |
567 | { | |
568 | struct max1363_state *st = i2c_get_clientdata(client); | |
569 | struct iio_dev *indio_dev = st->indio_dev; | |
570 | max1363_uninitialize_ring(indio_dev->ring); | |
571 | max1363_ring_cleanup(indio_dev); | |
572 | iio_device_unregister(indio_dev); | |
573 | if (!IS_ERR(st->reg)) { | |
574 | regulator_disable(st->reg); | |
575 | regulator_put(st->reg); | |
576 | } | |
577 | kfree(st); | |
578 | ||
579 | return 0; | |
580 | } | |
581 | ||
582 | static const struct i2c_device_id max1363_id[] = { | |
583 | { "max1361", max1361 }, | |
584 | { "max1362", max1362 }, | |
585 | { "max1363", max1363 }, | |
586 | { "max1364", max1364 }, | |
587 | { "max1136", max1136 }, | |
588 | { "max1137", max1137 }, | |
589 | { "max1138", max1138 }, | |
590 | { "max1139", max1139 }, | |
591 | { "max1236", max1236 }, | |
592 | { "max1237", max1237 }, | |
593 | { "max1238", max1238 }, | |
594 | { "max1239", max1239 }, | |
595 | {} | |
596 | }; | |
597 | ||
598 | MODULE_DEVICE_TABLE(i2c, max1363_id); | |
599 | ||
600 | static struct i2c_driver max1363_driver = { | |
601 | .driver = { | |
602 | .name = "max1363", | |
603 | }, | |
604 | .probe = max1363_probe, | |
605 | .remove = max1363_remove, | |
606 | .id_table = max1363_id, | |
607 | }; | |
608 | ||
609 | static __init int max1363_init(void) | |
610 | { | |
611 | return i2c_add_driver(&max1363_driver); | |
612 | } | |
613 | ||
614 | static __exit void max1363_exit(void) | |
615 | { | |
616 | i2c_del_driver(&max1363_driver); | |
617 | } | |
618 | ||
619 | MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>"); | |
620 | MODULE_DESCRIPTION("Maxim 1363 ADC"); | |
621 | MODULE_LICENSE("GPL v2"); | |
622 | ||
623 | module_init(max1363_init); | |
624 | module_exit(max1363_exit); |