1
2
3
4
5
6
7
8
9#include <linux/interrupt.h>
10#include <linux/device.h>
11#include <linux/kernel.h>
12#include <linux/slab.h>
13#include <linux/i2c.h>
14#include <linux/module.h>
15
16#include <linux/iio/iio.h>
17#include <linux/iio/sysfs.h>
18#include <linux/iio/events.h>
19
20
21
22
23#define AD7150_STATUS 0
24#define AD7150_STATUS_OUT1 (1 << 3)
25#define AD7150_STATUS_OUT2 (1 << 5)
26#define AD7150_CH1_DATA_HIGH 1
27#define AD7150_CH2_DATA_HIGH 3
28#define AD7150_CH1_AVG_HIGH 5
29#define AD7150_CH2_AVG_HIGH 7
30#define AD7150_CH1_SENSITIVITY 9
31#define AD7150_CH1_THR_HOLD_H 9
32#define AD7150_CH1_TIMEOUT 10
33#define AD7150_CH1_SETUP 11
34#define AD7150_CH2_SENSITIVITY 12
35#define AD7150_CH2_THR_HOLD_H 12
36#define AD7150_CH2_TIMEOUT 13
37#define AD7150_CH2_SETUP 14
38#define AD7150_CFG 15
39#define AD7150_CFG_FIX (1 << 7)
40#define AD7150_PD_TIMER 16
41#define AD7150_CH1_CAPDAC 17
42#define AD7150_CH2_CAPDAC 18
43#define AD7150_SN3 19
44#define AD7150_SN2 20
45#define AD7150_SN1 21
46#define AD7150_SN0 22
47#define AD7150_ID 23
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71struct ad7150_chip_info {
72 struct i2c_client *client;
73 u64 current_event;
74 u16 threshold[2][2];
75 u8 thresh_sensitivity[2][2];
76 u8 mag_sensitivity[2][2];
77 u8 thresh_timeout[2][2];
78 u8 mag_timeout[2][2];
79 int old_state;
80 char *conversion_mode;
81 struct mutex state_lock;
82};
83
84
85
86
87
88static const u8 ad7150_addresses[][6] = {
89 { AD7150_CH1_DATA_HIGH, AD7150_CH1_AVG_HIGH,
90 AD7150_CH1_SETUP, AD7150_CH1_THR_HOLD_H,
91 AD7150_CH1_SENSITIVITY, AD7150_CH1_TIMEOUT },
92 { AD7150_CH2_DATA_HIGH, AD7150_CH2_AVG_HIGH,
93 AD7150_CH2_SETUP, AD7150_CH2_THR_HOLD_H,
94 AD7150_CH2_SENSITIVITY, AD7150_CH2_TIMEOUT },
95};
96
97static int ad7150_read_raw(struct iio_dev *indio_dev,
98 struct iio_chan_spec const *chan,
99 int *val,
100 int *val2,
101 long mask)
102{
103 int ret;
104 struct ad7150_chip_info *chip = iio_priv(indio_dev);
105
106 switch (mask) {
107 case IIO_CHAN_INFO_RAW:
108 ret = i2c_smbus_read_word_data(chip->client,
109 ad7150_addresses[chan->channel][0]);
110 if (ret < 0)
111 return ret;
112 *val = swab16(ret);
113 return IIO_VAL_INT;
114 case IIO_CHAN_INFO_AVERAGE_RAW:
115 ret = i2c_smbus_read_word_data(chip->client,
116 ad7150_addresses[chan->channel][1]);
117 if (ret < 0)
118 return ret;
119 *val = swab16(ret);
120 return IIO_VAL_INT;
121 default:
122 return -EINVAL;
123 }
124}
125
126static int ad7150_read_event_config(struct iio_dev *indio_dev, u64 event_code)
127{
128 int ret;
129 u8 threshtype;
130 bool adaptive;
131 struct ad7150_chip_info *chip = iio_priv(indio_dev);
132 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
133 IIO_EV_DIR_RISING);
134
135 ret = i2c_smbus_read_byte_data(chip->client, AD7150_CFG);
136 if (ret < 0)
137 return ret;
138
139 threshtype = (ret >> 5) & 0x03;
140 adaptive = !!(ret & 0x80);
141
142 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
143 case IIO_EV_TYPE_MAG_ADAPTIVE:
144 if (rising)
145 return adaptive && (threshtype == 0x1);
146 else
147 return adaptive && (threshtype == 0x0);
148 case IIO_EV_TYPE_THRESH_ADAPTIVE:
149 if (rising)
150 return adaptive && (threshtype == 0x3);
151 else
152 return adaptive && (threshtype == 0x2);
153
154 case IIO_EV_TYPE_THRESH:
155 if (rising)
156 return !adaptive && (threshtype == 0x1);
157 else
158 return !adaptive && (threshtype == 0x0);
159 }
160 return -EINVAL;
161}
162
163
164static int ad7150_write_event_params(struct iio_dev *indio_dev, u64 event_code)
165{
166 int ret;
167 u16 value;
168 u8 sens, timeout;
169 struct ad7150_chip_info *chip = iio_priv(indio_dev);
170 int chan = IIO_EVENT_CODE_EXTRACT_CHAN(event_code);
171 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
172 IIO_EV_DIR_RISING);
173
174 if (event_code != chip->current_event)
175 return 0;
176
177 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
178
179 case IIO_EV_TYPE_THRESH:
180 value = chip->threshold[rising][chan];
181 ret = i2c_smbus_write_word_data(chip->client,
182 ad7150_addresses[chan][3],
183 swab16(value));
184 if (ret < 0)
185 return ret;
186 return 0;
187 case IIO_EV_TYPE_MAG_ADAPTIVE:
188 sens = chip->mag_sensitivity[rising][chan];
189 timeout = chip->mag_timeout[rising][chan];
190 break;
191 case IIO_EV_TYPE_THRESH_ADAPTIVE:
192 sens = chip->thresh_sensitivity[rising][chan];
193 timeout = chip->thresh_timeout[rising][chan];
194 break;
195 default:
196 return -EINVAL;
197 }
198 ret = i2c_smbus_write_byte_data(chip->client,
199 ad7150_addresses[chan][4],
200 sens);
201 if (ret < 0)
202 return ret;
203
204 ret = i2c_smbus_write_byte_data(chip->client,
205 ad7150_addresses[chan][5],
206 timeout);
207 if (ret < 0)
208 return ret;
209
210 return 0;
211}
212
213static int ad7150_write_event_config(struct iio_dev *indio_dev,
214 u64 event_code, int state)
215{
216 u8 thresh_type, cfg, adaptive;
217 int ret;
218 struct ad7150_chip_info *chip = iio_priv(indio_dev);
219 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
220 IIO_EV_DIR_RISING);
221
222
223 if (state == 0)
224 return -EINVAL;
225
226 if (event_code == chip->current_event)
227 return 0;
228 mutex_lock(&chip->state_lock);
229 ret = i2c_smbus_read_byte_data(chip->client, AD7150_CFG);
230 if (ret < 0)
231 goto error_ret;
232
233 cfg = ret & ~((0x03 << 5) | (0x1 << 7));
234
235 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
236 case IIO_EV_TYPE_MAG_ADAPTIVE:
237 adaptive = 1;
238 if (rising)
239 thresh_type = 0x1;
240 else
241 thresh_type = 0x0;
242 break;
243 case IIO_EV_TYPE_THRESH_ADAPTIVE:
244 adaptive = 1;
245 if (rising)
246 thresh_type = 0x3;
247 else
248 thresh_type = 0x2;
249 break;
250 case IIO_EV_TYPE_THRESH:
251 adaptive = 0;
252 if (rising)
253 thresh_type = 0x1;
254 else
255 thresh_type = 0x0;
256 break;
257 default:
258 ret = -EINVAL;
259 goto error_ret;
260 }
261
262 cfg |= (!adaptive << 7) | (thresh_type << 5);
263
264 ret = i2c_smbus_write_byte_data(chip->client, AD7150_CFG, cfg);
265 if (ret < 0)
266 goto error_ret;
267
268 chip->current_event = event_code;
269
270
271 ret = ad7150_write_event_params(indio_dev, event_code);
272error_ret:
273 mutex_unlock(&chip->state_lock);
274
275 return 0;
276}
277
278static int ad7150_read_event_value(struct iio_dev *indio_dev,
279 u64 event_code,
280 int *val)
281{
282 int chan = IIO_EVENT_CODE_EXTRACT_CHAN(event_code);
283 struct ad7150_chip_info *chip = iio_priv(indio_dev);
284 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
285 IIO_EV_DIR_RISING);
286
287
288 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
289 case IIO_EV_TYPE_MAG_ADAPTIVE:
290 *val = chip->mag_sensitivity[rising][chan];
291 return 0;
292
293 case IIO_EV_TYPE_THRESH_ADAPTIVE:
294 *val = chip->thresh_sensitivity[rising][chan];
295 return 0;
296
297 case IIO_EV_TYPE_THRESH:
298 *val = chip->threshold[rising][chan];
299 return 0;
300
301 default:
302 return -EINVAL;
303 };
304}
305
306static int ad7150_write_event_value(struct iio_dev *indio_dev,
307 u64 event_code,
308 int val)
309{
310 int ret;
311 struct ad7150_chip_info *chip = iio_priv(indio_dev);
312 int chan = IIO_EVENT_CODE_EXTRACT_CHAN(event_code);
313 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
314 IIO_EV_DIR_RISING);
315
316 mutex_lock(&chip->state_lock);
317 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
318 case IIO_EV_TYPE_MAG_ADAPTIVE:
319 chip->mag_sensitivity[rising][chan] = val;
320 break;
321 case IIO_EV_TYPE_THRESH_ADAPTIVE:
322 chip->thresh_sensitivity[rising][chan] = val;
323 break;
324 case IIO_EV_TYPE_THRESH:
325 chip->threshold[rising][chan] = val;
326 break;
327 default:
328 ret = -EINVAL;
329 goto error_ret;
330 }
331
332
333 ret = ad7150_write_event_params(indio_dev, event_code);
334
335error_ret:
336 mutex_unlock(&chip->state_lock);
337 return ret;
338}
339
340static ssize_t ad7150_show_timeout(struct device *dev,
341 struct device_attribute *attr,
342 char *buf)
343{
344 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
345 struct ad7150_chip_info *chip = iio_priv(indio_dev);
346 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
347 u8 value;
348
349
350 int chan = IIO_EVENT_CODE_EXTRACT_CHAN(this_attr->address);
351 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(this_attr->address)
352 == IIO_EV_DIR_RISING);
353
354 switch (IIO_EVENT_CODE_EXTRACT_TYPE(this_attr->address)) {
355 case IIO_EV_TYPE_MAG_ADAPTIVE:
356 value = chip->mag_timeout[rising][chan];
357 break;
358 case IIO_EV_TYPE_THRESH_ADAPTIVE:
359 value = chip->thresh_timeout[rising][chan];
360 break;
361 default:
362 return -EINVAL;
363 }
364
365 return sprintf(buf, "%d\n", value);
366}
367
368static ssize_t ad7150_store_timeout(struct device *dev,
369 struct device_attribute *attr,
370 const char *buf,
371 size_t len)
372{
373 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
374 struct ad7150_chip_info *chip = iio_priv(indio_dev);
375 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
376 int chan = IIO_EVENT_CODE_EXTRACT_CHAN(this_attr->address);
377 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(this_attr->address) ==
378 IIO_EV_DIR_RISING);
379 u8 data;
380 int ret;
381
382 ret = kstrtou8(buf, 10, &data);
383 if (ret < 0)
384 return ret;
385
386 mutex_lock(&chip->state_lock);
387 switch (IIO_EVENT_CODE_EXTRACT_TYPE(this_attr->address)) {
388 case IIO_EV_TYPE_MAG_ADAPTIVE:
389 chip->mag_timeout[rising][chan] = data;
390 break;
391 case IIO_EV_TYPE_THRESH_ADAPTIVE:
392 chip->thresh_timeout[rising][chan] = data;
393 break;
394 default:
395 ret = -EINVAL;
396 goto error_ret;
397 }
398
399 ret = ad7150_write_event_params(indio_dev, this_attr->address);
400error_ret:
401 mutex_unlock(&chip->state_lock);
402
403 if (ret < 0)
404 return ret;
405
406 return len;
407}
408
409#define AD7150_TIMEOUT(chan, type, dir, ev_type, ev_dir) \
410 IIO_DEVICE_ATTR(in_capacitance##chan##_##type##_##dir##_timeout, \
411 S_IRUGO | S_IWUSR, \
412 &ad7150_show_timeout, \
413 &ad7150_store_timeout, \
414 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE, \
415 chan, \
416 IIO_EV_TYPE_##ev_type, \
417 IIO_EV_DIR_##ev_dir))
418static AD7150_TIMEOUT(0, mag_adaptive, rising, MAG_ADAPTIVE, RISING);
419static AD7150_TIMEOUT(0, mag_adaptive, falling, MAG_ADAPTIVE, FALLING);
420static AD7150_TIMEOUT(1, mag_adaptive, rising, MAG_ADAPTIVE, RISING);
421static AD7150_TIMEOUT(1, mag_adaptive, falling, MAG_ADAPTIVE, FALLING);
422static AD7150_TIMEOUT(0, thresh_adaptive, rising, THRESH_ADAPTIVE, RISING);
423static AD7150_TIMEOUT(0, thresh_adaptive, falling, THRESH_ADAPTIVE, FALLING);
424static AD7150_TIMEOUT(1, thresh_adaptive, rising, THRESH_ADAPTIVE, RISING);
425static AD7150_TIMEOUT(1, thresh_adaptive, falling, THRESH_ADAPTIVE, FALLING);
426
427static const struct iio_chan_spec ad7150_channels[] = {
428 {
429 .type = IIO_CAPACITANCE,
430 .indexed = 1,
431 .channel = 0,
432 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
433 BIT(IIO_CHAN_INFO_AVERAGE_RAW),
434 .event_mask =
435 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
436 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
437 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
438 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
439 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
440 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
441 }, {
442 .type = IIO_CAPACITANCE,
443 .indexed = 1,
444 .channel = 1,
445 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
446 BIT(IIO_CHAN_INFO_AVERAGE_RAW),
447 .event_mask =
448 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
449 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
450 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
451 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
452 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
453 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
454 },
455};
456
457
458
459
460
461static irqreturn_t ad7150_event_handler(int irq, void *private)
462{
463 struct iio_dev *indio_dev = private;
464 struct ad7150_chip_info *chip = iio_priv(indio_dev);
465 u8 int_status;
466 s64 timestamp = iio_get_time_ns();
467 int ret;
468
469 ret = i2c_smbus_read_byte_data(chip->client, AD7150_STATUS);
470 if (ret < 0)
471 return IRQ_HANDLED;
472
473 int_status = ret;
474
475 if ((int_status & AD7150_STATUS_OUT1) &&
476 !(chip->old_state & AD7150_STATUS_OUT1))
477 iio_push_event(indio_dev,
478 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
479 0,
480 IIO_EV_TYPE_THRESH,
481 IIO_EV_DIR_RISING),
482 timestamp);
483 else if ((!(int_status & AD7150_STATUS_OUT1)) &&
484 (chip->old_state & AD7150_STATUS_OUT1))
485 iio_push_event(indio_dev,
486 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
487 0,
488 IIO_EV_TYPE_THRESH,
489 IIO_EV_DIR_FALLING),
490 timestamp);
491
492 if ((int_status & AD7150_STATUS_OUT2) &&
493 !(chip->old_state & AD7150_STATUS_OUT2))
494 iio_push_event(indio_dev,
495 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
496 1,
497 IIO_EV_TYPE_THRESH,
498 IIO_EV_DIR_RISING),
499 timestamp);
500 else if ((!(int_status & AD7150_STATUS_OUT2)) &&
501 (chip->old_state & AD7150_STATUS_OUT2))
502 iio_push_event(indio_dev,
503 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
504 1,
505 IIO_EV_TYPE_THRESH,
506 IIO_EV_DIR_FALLING),
507 timestamp);
508
509 chip->old_state = int_status;
510
511 return IRQ_HANDLED;
512}
513
514
515static struct attribute *ad7150_event_attributes[] = {
516 &iio_dev_attr_in_capacitance0_mag_adaptive_rising_timeout
517 .dev_attr.attr,
518 &iio_dev_attr_in_capacitance0_mag_adaptive_falling_timeout
519 .dev_attr.attr,
520 &iio_dev_attr_in_capacitance1_mag_adaptive_rising_timeout
521 .dev_attr.attr,
522 &iio_dev_attr_in_capacitance1_mag_adaptive_falling_timeout
523 .dev_attr.attr,
524 &iio_dev_attr_in_capacitance0_thresh_adaptive_rising_timeout
525 .dev_attr.attr,
526 &iio_dev_attr_in_capacitance0_thresh_adaptive_falling_timeout
527 .dev_attr.attr,
528 &iio_dev_attr_in_capacitance1_thresh_adaptive_rising_timeout
529 .dev_attr.attr,
530 &iio_dev_attr_in_capacitance1_thresh_adaptive_falling_timeout
531 .dev_attr.attr,
532 NULL,
533};
534
535static struct attribute_group ad7150_event_attribute_group = {
536 .attrs = ad7150_event_attributes,
537 .name = "events",
538};
539
540static const struct iio_info ad7150_info = {
541 .event_attrs = &ad7150_event_attribute_group,
542 .driver_module = THIS_MODULE,
543 .read_raw = &ad7150_read_raw,
544 .read_event_config = &ad7150_read_event_config,
545 .write_event_config = &ad7150_write_event_config,
546 .read_event_value = &ad7150_read_event_value,
547 .write_event_value = &ad7150_write_event_value,
548};
549
550
551
552
553
554static int ad7150_probe(struct i2c_client *client,
555 const struct i2c_device_id *id)
556{
557 int ret;
558 struct ad7150_chip_info *chip;
559 struct iio_dev *indio_dev;
560
561 indio_dev = iio_device_alloc(sizeof(*chip));
562 if (indio_dev == NULL) {
563 ret = -ENOMEM;
564 goto error_ret;
565 }
566 chip = iio_priv(indio_dev);
567 mutex_init(&chip->state_lock);
568
569 i2c_set_clientdata(client, indio_dev);
570
571 chip->client = client;
572
573 indio_dev->name = id->name;
574 indio_dev->channels = ad7150_channels;
575 indio_dev->num_channels = ARRAY_SIZE(ad7150_channels);
576
577 indio_dev->dev.parent = &client->dev;
578
579 indio_dev->info = &ad7150_info;
580
581 indio_dev->modes = INDIO_DIRECT_MODE;
582
583 if (client->irq) {
584 ret = request_threaded_irq(client->irq,
585 NULL,
586 &ad7150_event_handler,
587 IRQF_TRIGGER_RISING |
588 IRQF_TRIGGER_FALLING |
589 IRQF_ONESHOT,
590 "ad7150_irq1",
591 indio_dev);
592 if (ret)
593 goto error_free_dev;
594 }
595
596 if (client->dev.platform_data) {
597 ret = request_threaded_irq(*(unsigned int *)
598 client->dev.platform_data,
599 NULL,
600 &ad7150_event_handler,
601 IRQF_TRIGGER_RISING |
602 IRQF_TRIGGER_FALLING |
603 IRQF_ONESHOT,
604 "ad7150_irq2",
605 indio_dev);
606 if (ret)
607 goto error_free_irq;
608 }
609
610 ret = iio_device_register(indio_dev);
611 if (ret)
612 goto error_free_irq2;
613
614 dev_info(&client->dev, "%s capacitive sensor registered,irq: %d\n",
615 id->name, client->irq);
616
617 return 0;
618error_free_irq2:
619 if (client->dev.platform_data)
620 free_irq(*(unsigned int *)client->dev.platform_data,
621 indio_dev);
622error_free_irq:
623 if (client->irq)
624 free_irq(client->irq, indio_dev);
625error_free_dev:
626 iio_device_free(indio_dev);
627error_ret:
628 return ret;
629}
630
631static int ad7150_remove(struct i2c_client *client)
632{
633 struct iio_dev *indio_dev = i2c_get_clientdata(client);
634
635 iio_device_unregister(indio_dev);
636 if (client->irq)
637 free_irq(client->irq, indio_dev);
638
639 if (client->dev.platform_data)
640 free_irq(*(unsigned int *)client->dev.platform_data, indio_dev);
641
642 iio_device_free(indio_dev);
643
644 return 0;
645}
646
647static const struct i2c_device_id ad7150_id[] = {
648 { "ad7150", 0 },
649 { "ad7151", 0 },
650 { "ad7156", 0 },
651 {}
652};
653
654MODULE_DEVICE_TABLE(i2c, ad7150_id);
655
656static struct i2c_driver ad7150_driver = {
657 .driver = {
658 .name = "ad7150",
659 },
660 .probe = ad7150_probe,
661 .remove = ad7150_remove,
662 .id_table = ad7150_id,
663};
664module_i2c_driver(ad7150_driver);
665
666MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
667MODULE_DESCRIPTION("Analog Devices AD7150/1/6 capacitive sensor driver");
668MODULE_LICENSE("GPL v2");
669
