This source file includes following definitions.
- nau7802_show_scales
- nau7802_set_gain
- nau7802_read_conversion
- nau7802_sync
- nau7802_eoc_trigger
- nau7802_read_irq
- nau7802_read_poll
- nau7802_read_raw
- nau7802_write_raw
- nau7802_write_raw_get_fmt
- nau7802_probe
- nau7802_remove
1
2
3
4
5
6
7
8 #include <linux/delay.h>
9 #include <linux/i2c.h>
10 #include <linux/interrupt.h>
11 #include <linux/module.h>
12 #include <linux/wait.h>
13 #include <linux/log2.h>
14 #include <linux/of.h>
15
16 #include <linux/iio/iio.h>
17 #include <linux/iio/sysfs.h>
18
19 #define NAU7802_REG_PUCTRL 0x00
20 #define NAU7802_PUCTRL_RR(x) (x << 0)
21 #define NAU7802_PUCTRL_RR_BIT NAU7802_PUCTRL_RR(1)
22 #define NAU7802_PUCTRL_PUD(x) (x << 1)
23 #define NAU7802_PUCTRL_PUD_BIT NAU7802_PUCTRL_PUD(1)
24 #define NAU7802_PUCTRL_PUA(x) (x << 2)
25 #define NAU7802_PUCTRL_PUA_BIT NAU7802_PUCTRL_PUA(1)
26 #define NAU7802_PUCTRL_PUR(x) (x << 3)
27 #define NAU7802_PUCTRL_PUR_BIT NAU7802_PUCTRL_PUR(1)
28 #define NAU7802_PUCTRL_CS(x) (x << 4)
29 #define NAU7802_PUCTRL_CS_BIT NAU7802_PUCTRL_CS(1)
30 #define NAU7802_PUCTRL_CR(x) (x << 5)
31 #define NAU7802_PUCTRL_CR_BIT NAU7802_PUCTRL_CR(1)
32 #define NAU7802_PUCTRL_AVDDS(x) (x << 7)
33 #define NAU7802_PUCTRL_AVDDS_BIT NAU7802_PUCTRL_AVDDS(1)
34 #define NAU7802_REG_CTRL1 0x01
35 #define NAU7802_CTRL1_VLDO(x) (x << 3)
36 #define NAU7802_CTRL1_GAINS(x) (x)
37 #define NAU7802_CTRL1_GAINS_BITS 0x07
38 #define NAU7802_REG_CTRL2 0x02
39 #define NAU7802_CTRL2_CHS(x) (x << 7)
40 #define NAU7802_CTRL2_CRS(x) (x << 4)
41 #define NAU7802_SAMP_FREQ_320 0x07
42 #define NAU7802_CTRL2_CHS_BIT NAU7802_CTRL2_CHS(1)
43 #define NAU7802_REG_ADC_B2 0x12
44 #define NAU7802_REG_ADC_B1 0x13
45 #define NAU7802_REG_ADC_B0 0x14
46 #define NAU7802_REG_ADC_CTRL 0x15
47
48 #define NAU7802_MIN_CONVERSIONS 6
49
50 struct nau7802_state {
51 struct i2c_client *client;
52 s32 last_value;
53 struct mutex lock;
54 struct mutex data_lock;
55 u32 vref_mv;
56 u32 conversion_count;
57 u32 min_conversions;
58 u8 sample_rate;
59 u32 scale_avail[8];
60 struct completion value_ok;
61 };
62
63 #define NAU7802_CHANNEL(chan) { \
64 .type = IIO_VOLTAGE, \
65 .indexed = 1, \
66 .channel = (chan), \
67 .scan_index = (chan), \
68 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
69 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
70 BIT(IIO_CHAN_INFO_SAMP_FREQ) \
71 }
72
73 static const struct iio_chan_spec nau7802_chan_array[] = {
74 NAU7802_CHANNEL(0),
75 NAU7802_CHANNEL(1),
76 };
77
78 static const u16 nau7802_sample_freq_avail[] = {10, 20, 40, 80,
79 10, 10, 10, 320};
80
81 static ssize_t nau7802_show_scales(struct device *dev,
82 struct device_attribute *attr, char *buf)
83 {
84 struct nau7802_state *st = iio_priv(dev_to_iio_dev(dev));
85 int i, len = 0;
86
87 for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
88 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%09d ",
89 st->scale_avail[i]);
90
91 buf[len-1] = '\n';
92
93 return len;
94 }
95
96 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("10 40 80 320");
97
98 static IIO_DEVICE_ATTR(in_voltage_scale_available, S_IRUGO, nau7802_show_scales,
99 NULL, 0);
100
101 static struct attribute *nau7802_attributes[] = {
102 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
103 &iio_dev_attr_in_voltage_scale_available.dev_attr.attr,
104 NULL
105 };
106
107 static const struct attribute_group nau7802_attribute_group = {
108 .attrs = nau7802_attributes,
109 };
110
111 static int nau7802_set_gain(struct nau7802_state *st, int gain)
112 {
113 int ret;
114
115 mutex_lock(&st->lock);
116 st->conversion_count = 0;
117
118 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_CTRL1);
119 if (ret < 0)
120 goto nau7802_sysfs_set_gain_out;
121 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_CTRL1,
122 (ret & (~NAU7802_CTRL1_GAINS_BITS)) |
123 gain);
124
125 nau7802_sysfs_set_gain_out:
126 mutex_unlock(&st->lock);
127
128 return ret;
129 }
130
131 static int nau7802_read_conversion(struct nau7802_state *st)
132 {
133 int data;
134
135 mutex_lock(&st->data_lock);
136 data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B2);
137 if (data < 0)
138 goto nau7802_read_conversion_out;
139 st->last_value = data << 16;
140
141 data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B1);
142 if (data < 0)
143 goto nau7802_read_conversion_out;
144 st->last_value |= data << 8;
145
146 data = i2c_smbus_read_byte_data(st->client, NAU7802_REG_ADC_B0);
147 if (data < 0)
148 goto nau7802_read_conversion_out;
149 st->last_value |= data;
150
151 st->last_value = sign_extend32(st->last_value, 23);
152
153 nau7802_read_conversion_out:
154 mutex_unlock(&st->data_lock);
155
156 return data;
157 }
158
159
160
161
162 static int nau7802_sync(struct nau7802_state *st)
163 {
164 int ret;
165
166 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
167 if (ret < 0)
168 return ret;
169 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL,
170 ret | NAU7802_PUCTRL_CS_BIT);
171
172 return ret;
173 }
174
175 static irqreturn_t nau7802_eoc_trigger(int irq, void *private)
176 {
177 struct iio_dev *indio_dev = private;
178 struct nau7802_state *st = iio_priv(indio_dev);
179 int status;
180
181 status = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
182 if (status < 0)
183 return IRQ_HANDLED;
184
185 if (!(status & NAU7802_PUCTRL_CR_BIT))
186 return IRQ_NONE;
187
188 if (nau7802_read_conversion(st) < 0)
189 return IRQ_HANDLED;
190
191
192
193
194
195
196 if (st->conversion_count < NAU7802_MIN_CONVERSIONS)
197 st->conversion_count++;
198 if (st->conversion_count >= NAU7802_MIN_CONVERSIONS)
199 complete(&st->value_ok);
200
201 return IRQ_HANDLED;
202 }
203
204 static int nau7802_read_irq(struct iio_dev *indio_dev,
205 struct iio_chan_spec const *chan,
206 int *val)
207 {
208 struct nau7802_state *st = iio_priv(indio_dev);
209 int ret;
210
211 reinit_completion(&st->value_ok);
212 enable_irq(st->client->irq);
213
214 nau7802_sync(st);
215
216
217 ret = nau7802_read_conversion(st);
218 if (ret < 0)
219 goto read_chan_info_failure;
220
221
222 ret = wait_for_completion_interruptible_timeout(&st->value_ok,
223 msecs_to_jiffies(1000));
224 if (ret == 0)
225 ret = -ETIMEDOUT;
226
227 if (ret < 0)
228 goto read_chan_info_failure;
229
230 disable_irq(st->client->irq);
231
232 *val = st->last_value;
233
234 return IIO_VAL_INT;
235
236 read_chan_info_failure:
237 disable_irq(st->client->irq);
238
239 return ret;
240 }
241
242 static int nau7802_read_poll(struct iio_dev *indio_dev,
243 struct iio_chan_spec const *chan,
244 int *val)
245 {
246 struct nau7802_state *st = iio_priv(indio_dev);
247 int ret;
248
249 nau7802_sync(st);
250
251
252 ret = nau7802_read_conversion(st);
253 if (ret < 0)
254 return ret;
255
256
257
258
259
260
261 do {
262 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
263 if (ret < 0)
264 return ret;
265
266 while (!(ret & NAU7802_PUCTRL_CR_BIT)) {
267 if (st->sample_rate != NAU7802_SAMP_FREQ_320)
268 msleep(20);
269 else
270 mdelay(4);
271 ret = i2c_smbus_read_byte_data(st->client,
272 NAU7802_REG_PUCTRL);
273 if (ret < 0)
274 return ret;
275 }
276
277 ret = nau7802_read_conversion(st);
278 if (ret < 0)
279 return ret;
280 if (st->conversion_count < NAU7802_MIN_CONVERSIONS)
281 st->conversion_count++;
282 } while (st->conversion_count < NAU7802_MIN_CONVERSIONS);
283
284 *val = st->last_value;
285
286 return IIO_VAL_INT;
287 }
288
289 static int nau7802_read_raw(struct iio_dev *indio_dev,
290 struct iio_chan_spec const *chan,
291 int *val, int *val2, long mask)
292 {
293 struct nau7802_state *st = iio_priv(indio_dev);
294 int ret;
295
296 switch (mask) {
297 case IIO_CHAN_INFO_RAW:
298 mutex_lock(&st->lock);
299
300
301
302
303
304 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_CTRL2);
305 if (ret < 0) {
306 mutex_unlock(&st->lock);
307 return ret;
308 }
309
310 if (((ret & NAU7802_CTRL2_CHS_BIT) && !chan->channel) ||
311 (!(ret & NAU7802_CTRL2_CHS_BIT) &&
312 chan->channel)) {
313 st->conversion_count = 0;
314 ret = i2c_smbus_write_byte_data(st->client,
315 NAU7802_REG_CTRL2,
316 NAU7802_CTRL2_CHS(chan->channel) |
317 NAU7802_CTRL2_CRS(st->sample_rate));
318
319 if (ret < 0) {
320 mutex_unlock(&st->lock);
321 return ret;
322 }
323 }
324
325 if (st->client->irq)
326 ret = nau7802_read_irq(indio_dev, chan, val);
327 else
328 ret = nau7802_read_poll(indio_dev, chan, val);
329
330 mutex_unlock(&st->lock);
331 return ret;
332
333 case IIO_CHAN_INFO_SCALE:
334 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_CTRL1);
335 if (ret < 0)
336 return ret;
337
338
339
340
341
342 *val = st->vref_mv;
343 *val2 = 23 + (ret & NAU7802_CTRL1_GAINS_BITS);
344
345 return IIO_VAL_FRACTIONAL_LOG2;
346
347 case IIO_CHAN_INFO_SAMP_FREQ:
348 *val = nau7802_sample_freq_avail[st->sample_rate];
349 *val2 = 0;
350 return IIO_VAL_INT;
351
352 default:
353 break;
354 }
355
356 return -EINVAL;
357 }
358
359 static int nau7802_write_raw(struct iio_dev *indio_dev,
360 struct iio_chan_spec const *chan,
361 int val, int val2, long mask)
362 {
363 struct nau7802_state *st = iio_priv(indio_dev);
364 int i, ret;
365
366 switch (mask) {
367 case IIO_CHAN_INFO_SCALE:
368 for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
369 if (val2 == st->scale_avail[i])
370 return nau7802_set_gain(st, i);
371
372 break;
373
374 case IIO_CHAN_INFO_SAMP_FREQ:
375 for (i = 0; i < ARRAY_SIZE(nau7802_sample_freq_avail); i++)
376 if (val == nau7802_sample_freq_avail[i]) {
377 mutex_lock(&st->lock);
378 st->sample_rate = i;
379 st->conversion_count = 0;
380 ret = i2c_smbus_write_byte_data(st->client,
381 NAU7802_REG_CTRL2,
382 NAU7802_CTRL2_CRS(st->sample_rate));
383 mutex_unlock(&st->lock);
384 return ret;
385 }
386
387 break;
388
389 default:
390 break;
391 }
392
393 return -EINVAL;
394 }
395
396 static int nau7802_write_raw_get_fmt(struct iio_dev *indio_dev,
397 struct iio_chan_spec const *chan,
398 long mask)
399 {
400 return IIO_VAL_INT_PLUS_NANO;
401 }
402
403 static const struct iio_info nau7802_info = {
404 .read_raw = &nau7802_read_raw,
405 .write_raw = &nau7802_write_raw,
406 .write_raw_get_fmt = nau7802_write_raw_get_fmt,
407 .attrs = &nau7802_attribute_group,
408 };
409
410 static int nau7802_probe(struct i2c_client *client,
411 const struct i2c_device_id *id)
412 {
413 struct iio_dev *indio_dev;
414 struct nau7802_state *st;
415 struct device_node *np = client->dev.of_node;
416 int i, ret;
417 u8 data;
418 u32 tmp = 0;
419
420 if (!client->dev.of_node) {
421 dev_err(&client->dev, "No device tree node available.\n");
422 return -EINVAL;
423 }
424
425 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st));
426 if (indio_dev == NULL)
427 return -ENOMEM;
428
429 st = iio_priv(indio_dev);
430
431 i2c_set_clientdata(client, indio_dev);
432
433 indio_dev->dev.parent = &client->dev;
434 indio_dev->dev.of_node = client->dev.of_node;
435 indio_dev->name = dev_name(&client->dev);
436 indio_dev->modes = INDIO_DIRECT_MODE;
437 indio_dev->info = &nau7802_info;
438
439 st->client = client;
440
441
442 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL,
443 NAU7802_PUCTRL_RR_BIT);
444 if (ret < 0)
445 return ret;
446
447
448 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL,
449 NAU7802_PUCTRL_PUD_BIT);
450 if (ret < 0)
451 return ret;
452
453
454
455
456
457 udelay(210);
458 ret = i2c_smbus_read_byte_data(st->client, NAU7802_REG_PUCTRL);
459 if (ret < 0)
460 return ret;
461 if (!(ret & NAU7802_PUCTRL_PUR_BIT))
462 return ret;
463
464 of_property_read_u32(np, "nuvoton,vldo", &tmp);
465 st->vref_mv = tmp;
466
467 data = NAU7802_PUCTRL_PUD_BIT | NAU7802_PUCTRL_PUA_BIT |
468 NAU7802_PUCTRL_CS_BIT;
469 if (tmp >= 2400)
470 data |= NAU7802_PUCTRL_AVDDS_BIT;
471
472 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_PUCTRL, data);
473 if (ret < 0)
474 return ret;
475 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_ADC_CTRL, 0x30);
476 if (ret < 0)
477 return ret;
478
479 if (tmp >= 2400) {
480 data = NAU7802_CTRL1_VLDO((4500 - tmp) / 300);
481 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_CTRL1,
482 data);
483 if (ret < 0)
484 return ret;
485 }
486
487
488 for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
489 st->scale_avail[i] = (((u64)st->vref_mv) * 1000000000ULL)
490 >> (23 + i);
491
492 init_completion(&st->value_ok);
493
494
495
496
497
498
499 if (client->irq) {
500 ret = request_threaded_irq(client->irq,
501 NULL,
502 nau7802_eoc_trigger,
503 IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
504 client->dev.driver->name,
505 indio_dev);
506 if (ret) {
507
508
509
510
511
512
513
514
515 dev_info(&client->dev,
516 "Failed to allocate IRQ, using polling mode\n");
517 client->irq = 0;
518 } else
519 disable_irq(client->irq);
520 }
521
522 if (!client->irq) {
523
524
525
526
527 st->sample_rate = NAU7802_SAMP_FREQ_320;
528 ret = i2c_smbus_write_byte_data(st->client, NAU7802_REG_CTRL2,
529 NAU7802_CTRL2_CRS(st->sample_rate));
530 if (ret)
531 goto error_free_irq;
532 }
533
534
535 indio_dev->num_channels = ARRAY_SIZE(nau7802_chan_array);
536 indio_dev->channels = nau7802_chan_array;
537
538 mutex_init(&st->lock);
539 mutex_init(&st->data_lock);
540
541 ret = iio_device_register(indio_dev);
542 if (ret < 0) {
543 dev_err(&client->dev, "Couldn't register the device.\n");
544 goto error_device_register;
545 }
546
547 return 0;
548
549 error_device_register:
550 mutex_destroy(&st->lock);
551 mutex_destroy(&st->data_lock);
552 error_free_irq:
553 if (client->irq)
554 free_irq(client->irq, indio_dev);
555
556 return ret;
557 }
558
559 static int nau7802_remove(struct i2c_client *client)
560 {
561 struct iio_dev *indio_dev = i2c_get_clientdata(client);
562 struct nau7802_state *st = iio_priv(indio_dev);
563
564 iio_device_unregister(indio_dev);
565 mutex_destroy(&st->lock);
566 mutex_destroy(&st->data_lock);
567 if (client->irq)
568 free_irq(client->irq, indio_dev);
569
570 return 0;
571 }
572
573 static const struct i2c_device_id nau7802_i2c_id[] = {
574 { "nau7802", 0 },
575 { }
576 };
577 MODULE_DEVICE_TABLE(i2c, nau7802_i2c_id);
578
579 static const struct of_device_id nau7802_dt_ids[] = {
580 { .compatible = "nuvoton,nau7802" },
581 {},
582 };
583 MODULE_DEVICE_TABLE(of, nau7802_dt_ids);
584
585 static struct i2c_driver nau7802_driver = {
586 .probe = nau7802_probe,
587 .remove = nau7802_remove,
588 .id_table = nau7802_i2c_id,
589 .driver = {
590 .name = "nau7802",
591 .of_match_table = nau7802_dt_ids,
592 },
593 };
594
595 module_i2c_driver(nau7802_driver);
596
597 MODULE_LICENSE("GPL");
598 MODULE_DESCRIPTION("Nuvoton NAU7802 ADC Driver");
599 MODULE_AUTHOR("Maxime Ripard <maxime.ripard@free-electrons.com>");
600 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");