2 * ADE7758 Polyphase Multifunction Energy Metering IC Driver
4 * Copyright 2010 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
9 #include <linux/interrupt.h>
10 #include <linux/irq.h>
11 #include <linux/gpio.h>
12 #include <linux/delay.h>
13 #include <linux/mutex.h>
14 #include <linux/device.h>
15 #include <linux/kernel.h>
16 #include <linux/spi/spi.h>
17 #include <linux/slab.h>
18 #include <linux/sysfs.h>
19 #include <linux/list.h>
26 int ade7758_spi_write_reg_8(struct device *dev,
31 struct iio_dev *indio_dev = dev_get_drvdata(dev);
32 struct ade7758_state *st = iio_dev_get_devdata(indio_dev);
34 mutex_lock(&st->buf_lock);
35 st->tx[0] = ADE7758_WRITE_REG(reg_address);
38 ret = spi_write(st->us, st->tx, 2);
39 mutex_unlock(&st->buf_lock);
44 static int ade7758_spi_write_reg_16(struct device *dev,
49 struct spi_message msg;
50 struct iio_dev *indio_dev = dev_get_drvdata(dev);
51 struct ade7758_state *st = iio_dev_get_devdata(indio_dev);
52 struct spi_transfer xfers[] = {
60 mutex_lock(&st->buf_lock);
61 st->tx[0] = ADE7758_WRITE_REG(reg_address);
62 st->tx[1] = (value >> 8) & 0xFF;
63 st->tx[2] = value & 0xFF;
65 spi_message_init(&msg);
66 spi_message_add_tail(xfers, &msg);
67 ret = spi_sync(st->us, &msg);
68 mutex_unlock(&st->buf_lock);
73 static int ade7758_spi_write_reg_24(struct device *dev,
78 struct spi_message msg;
79 struct iio_dev *indio_dev = dev_get_drvdata(dev);
80 struct ade7758_state *st = iio_dev_get_devdata(indio_dev);
81 struct spi_transfer xfers[] = {
89 mutex_lock(&st->buf_lock);
90 st->tx[0] = ADE7758_WRITE_REG(reg_address);
91 st->tx[1] = (value >> 16) & 0xFF;
92 st->tx[2] = (value >> 8) & 0xFF;
93 st->tx[3] = value & 0xFF;
95 spi_message_init(&msg);
96 spi_message_add_tail(xfers, &msg);
97 ret = spi_sync(st->us, &msg);
98 mutex_unlock(&st->buf_lock);
103 static int ade7758_spi_read_reg_8(struct device *dev,
107 struct spi_message msg;
108 struct iio_dev *indio_dev = dev_get_drvdata(dev);
109 struct ade7758_state *st = iio_dev_get_devdata(indio_dev);
111 struct spi_transfer xfers[] = {
120 mutex_lock(&st->buf_lock);
121 st->tx[0] = ADE7758_READ_REG(reg_address);
124 spi_message_init(&msg);
125 spi_message_add_tail(xfers, &msg);
126 ret = spi_sync(st->us, &msg);
128 dev_err(&st->us->dev, "problem when reading 8 bit register 0x%02X",
135 mutex_unlock(&st->buf_lock);
139 static int ade7758_spi_read_reg_16(struct device *dev,
143 struct spi_message msg;
144 struct iio_dev *indio_dev = dev_get_drvdata(dev);
145 struct ade7758_state *st = iio_dev_get_devdata(indio_dev);
147 struct spi_transfer xfers[] = {
156 mutex_lock(&st->buf_lock);
157 st->tx[0] = ADE7758_READ_REG(reg_address);
161 spi_message_init(&msg);
162 spi_message_add_tail(xfers, &msg);
163 ret = spi_sync(st->us, &msg);
165 dev_err(&st->us->dev, "problem when reading 16 bit register 0x%02X",
169 *val = (st->rx[1] << 8) | st->rx[2];
172 mutex_unlock(&st->buf_lock);
176 static int ade7758_spi_read_reg_24(struct device *dev,
180 struct spi_message msg;
181 struct iio_dev *indio_dev = dev_get_drvdata(dev);
182 struct ade7758_state *st = iio_dev_get_devdata(indio_dev);
184 struct spi_transfer xfers[] = {
193 mutex_lock(&st->buf_lock);
194 st->tx[0] = ADE7758_READ_REG(reg_address);
199 spi_message_init(&msg);
200 spi_message_add_tail(xfers, &msg);
201 ret = spi_sync(st->us, &msg);
203 dev_err(&st->us->dev, "problem when reading 24 bit register 0x%02X",
207 *val = (st->rx[1] << 16) | (st->rx[2] << 8) | st->rx[3];
210 mutex_unlock(&st->buf_lock);
214 static ssize_t ade7758_read_8bit(struct device *dev,
215 struct device_attribute *attr,
220 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
222 ret = ade7758_spi_read_reg_8(dev, this_attr->address, &val);
226 return sprintf(buf, "%u\n", val);
229 static ssize_t ade7758_read_16bit(struct device *dev,
230 struct device_attribute *attr,
235 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
237 ret = ade7758_spi_read_reg_16(dev, this_attr->address, &val);
241 return sprintf(buf, "%u\n", val);
244 static ssize_t ade7758_read_24bit(struct device *dev,
245 struct device_attribute *attr,
250 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
252 ret = ade7758_spi_read_reg_24(dev, this_attr->address, &val);
256 return sprintf(buf, "%u\n", val & 0xFFFFFF);
259 static ssize_t ade7758_write_8bit(struct device *dev,
260 struct device_attribute *attr,
264 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
268 ret = strict_strtol(buf, 10, &val);
271 ret = ade7758_spi_write_reg_8(dev, this_attr->address, val);
274 return ret ? ret : len;
277 static ssize_t ade7758_write_16bit(struct device *dev,
278 struct device_attribute *attr,
282 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
286 ret = strict_strtol(buf, 10, &val);
289 ret = ade7758_spi_write_reg_16(dev, this_attr->address, val);
292 return ret ? ret : len;
295 int ade7758_reset(struct device *dev)
299 ade7758_spi_read_reg_8(dev,
302 val |= 1 << 6; /* Software Chip Reset */
303 ret = ade7758_spi_write_reg_8(dev,
310 static ssize_t ade7758_write_reset(struct device *dev,
311 struct device_attribute *attr,
312 const char *buf, size_t len)
320 return ade7758_reset(dev);
325 static IIO_DEV_ATTR_VPEAK(S_IWUSR | S_IRUGO,
329 static IIO_DEV_ATTR_IPEAK(S_IWUSR | S_IRUGO,
333 static IIO_DEV_ATTR_APHCAL(S_IWUSR | S_IRUGO,
337 static IIO_DEV_ATTR_BPHCAL(S_IWUSR | S_IRUGO,
341 static IIO_DEV_ATTR_CPHCAL(S_IWUSR | S_IRUGO,
345 static IIO_DEV_ATTR_WDIV(S_IWUSR | S_IRUGO,
349 static IIO_DEV_ATTR_VADIV(S_IWUSR | S_IRUGO,
353 static IIO_DEV_ATTR_AIRMS(S_IRUGO,
357 static IIO_DEV_ATTR_BIRMS(S_IRUGO,
361 static IIO_DEV_ATTR_CIRMS(S_IRUGO,
365 static IIO_DEV_ATTR_AVRMS(S_IRUGO,
369 static IIO_DEV_ATTR_BVRMS(S_IRUGO,
373 static IIO_DEV_ATTR_CVRMS(S_IRUGO,
377 static IIO_DEV_ATTR_AIRMSOS(S_IWUSR | S_IRUGO,
381 static IIO_DEV_ATTR_BIRMSOS(S_IWUSR | S_IRUGO,
385 static IIO_DEV_ATTR_CIRMSOS(S_IWUSR | S_IRUGO,
389 static IIO_DEV_ATTR_AVRMSOS(S_IWUSR | S_IRUGO,
393 static IIO_DEV_ATTR_BVRMSOS(S_IWUSR | S_IRUGO,
397 static IIO_DEV_ATTR_CVRMSOS(S_IWUSR | S_IRUGO,
401 static IIO_DEV_ATTR_AIGAIN(S_IWUSR | S_IRUGO,
405 static IIO_DEV_ATTR_BIGAIN(S_IWUSR | S_IRUGO,
409 static IIO_DEV_ATTR_CIGAIN(S_IWUSR | S_IRUGO,
413 static IIO_DEV_ATTR_AVRMSGAIN(S_IWUSR | S_IRUGO,
417 static IIO_DEV_ATTR_BVRMSGAIN(S_IWUSR | S_IRUGO,
421 static IIO_DEV_ATTR_CVRMSGAIN(S_IWUSR | S_IRUGO,
426 int ade7758_set_irq(struct device *dev, bool enable)
430 ret = ade7758_spi_read_reg_24(dev, ADE7758_MASK, &irqen);
435 irqen |= 1 << 16; /* Enables an interrupt when a data is
436 present in the waveform register */
440 ret = ade7758_spi_write_reg_24(dev, ADE7758_MASK, irqen);
448 /* Power down the device */
449 static int ade7758_stop_device(struct device *dev)
453 ade7758_spi_read_reg_8(dev,
456 val |= 7 << 3; /* ADE7758 powered down */
457 ret = ade7758_spi_write_reg_8(dev,
464 static int ade7758_initial_setup(struct ade7758_state *st)
467 struct device *dev = &st->indio_dev->dev;
469 /* use low spi speed for init */
470 st->us->mode = SPI_MODE_3;
474 ret = ade7758_set_irq(dev, false);
476 dev_err(dev, "disable irq failed");
481 msleep(ADE7758_STARTUP_DELAY);
487 static ssize_t ade7758_read_frequency(struct device *dev,
488 struct device_attribute *attr,
494 ret = ade7758_spi_read_reg_8(dev,
501 sps = 26040 / (1 << t);
503 len = sprintf(buf, "%d SPS\n", sps);
507 static ssize_t ade7758_write_frequency(struct device *dev,
508 struct device_attribute *attr,
512 struct iio_dev *indio_dev = dev_get_drvdata(dev);
513 struct ade7758_state *st = iio_dev_get_devdata(indio_dev);
518 ret = strict_strtol(buf, 10, &val);
522 mutex_lock(&indio_dev->mlock);
529 st->us->max_speed_hz = ADE7758_SPI_SLOW;
531 st->us->max_speed_hz = ADE7758_SPI_FAST;
533 ret = ade7758_spi_read_reg_8(dev,
542 ret = ade7758_spi_write_reg_8(dev,
547 mutex_unlock(&indio_dev->mlock);
549 return ret ? ret : len;
552 static ssize_t ade7758_read_waveform_type(struct device *dev,
553 struct device_attribute *attr,
558 ret = ade7758_spi_read_reg_8(dev,
566 len = sprintf(buf, "%d\n", t);
571 static ssize_t ade7758_write_waveform_type(struct device *dev,
572 struct device_attribute *attr,
576 struct iio_dev *indio_dev = dev_get_drvdata(dev);
581 ret = strict_strtol(buf, 10, &val);
588 mutex_lock(&indio_dev->mlock);
590 ret = ade7758_spi_read_reg_8(dev,
599 ret = ade7758_spi_write_reg_8(dev,
604 mutex_unlock(&indio_dev->mlock);
606 return ret ? ret : len;
609 static IIO_DEV_ATTR_TEMP_RAW(ade7758_read_8bit);
610 static IIO_CONST_ATTR(temp_offset, "129 C");
611 static IIO_CONST_ATTR(temp_scale, "4 C");
613 static IIO_DEV_ATTR_AWATTHR(ade7758_read_16bit,
615 static IIO_DEV_ATTR_BWATTHR(ade7758_read_16bit,
617 static IIO_DEV_ATTR_CWATTHR(ade7758_read_16bit,
619 static IIO_DEV_ATTR_AVARHR(ade7758_read_16bit,
621 static IIO_DEV_ATTR_BVARHR(ade7758_read_16bit,
623 static IIO_DEV_ATTR_CVARHR(ade7758_read_16bit,
625 static IIO_DEV_ATTR_AVAHR(ade7758_read_16bit,
627 static IIO_DEV_ATTR_BVAHR(ade7758_read_16bit,
629 static IIO_DEV_ATTR_CVAHR(ade7758_read_16bit,
632 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
633 ade7758_read_frequency,
634 ade7758_write_frequency);
637 * IIO_DEV_ATTR_WAVEFORM_TYPE - set the type of waveform.
638 * @_mode: sysfs file mode/permissions
639 * @_show: output method for the attribute
640 * @_store: input method for the attribute
642 #define IIO_DEV_ATTR_WAVEFORM_TYPE(_mode, _show, _store) \
643 IIO_DEVICE_ATTR(waveform_type, _mode, _show, _store, 0)
645 static IIO_DEV_ATTR_WAVEFORM_TYPE(S_IWUSR | S_IRUGO,
646 ade7758_read_waveform_type,
647 ade7758_write_waveform_type);
649 static IIO_DEV_ATTR_RESET(ade7758_write_reset);
651 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("26000 13000 65000 33000");
653 static IIO_CONST_ATTR(name, "ade7758");
655 static struct attribute *ade7758_event_attributes[] = {
659 static struct attribute_group ade7758_event_attribute_group = {
660 .attrs = ade7758_event_attributes,
663 static struct attribute *ade7758_attributes[] = {
664 &iio_dev_attr_temp_raw.dev_attr.attr,
665 &iio_const_attr_temp_offset.dev_attr.attr,
666 &iio_const_attr_temp_scale.dev_attr.attr,
667 &iio_dev_attr_sampling_frequency.dev_attr.attr,
668 &iio_dev_attr_waveform_type.dev_attr.attr,
669 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
670 &iio_dev_attr_reset.dev_attr.attr,
671 &iio_const_attr_name.dev_attr.attr,
672 &iio_dev_attr_awatthr.dev_attr.attr,
673 &iio_dev_attr_bwatthr.dev_attr.attr,
674 &iio_dev_attr_cwatthr.dev_attr.attr,
675 &iio_dev_attr_avarhr.dev_attr.attr,
676 &iio_dev_attr_bvarhr.dev_attr.attr,
677 &iio_dev_attr_cvarhr.dev_attr.attr,
678 &iio_dev_attr_avahr.dev_attr.attr,
679 &iio_dev_attr_bvahr.dev_attr.attr,
680 &iio_dev_attr_cvahr.dev_attr.attr,
681 &iio_dev_attr_vpeak.dev_attr.attr,
682 &iio_dev_attr_ipeak.dev_attr.attr,
683 &iio_dev_attr_aphcal.dev_attr.attr,
684 &iio_dev_attr_bphcal.dev_attr.attr,
685 &iio_dev_attr_cphcal.dev_attr.attr,
686 &iio_dev_attr_wdiv.dev_attr.attr,
687 &iio_dev_attr_vadiv.dev_attr.attr,
688 &iio_dev_attr_airms.dev_attr.attr,
689 &iio_dev_attr_birms.dev_attr.attr,
690 &iio_dev_attr_cirms.dev_attr.attr,
691 &iio_dev_attr_avrms.dev_attr.attr,
692 &iio_dev_attr_bvrms.dev_attr.attr,
693 &iio_dev_attr_cvrms.dev_attr.attr,
694 &iio_dev_attr_aigain.dev_attr.attr,
695 &iio_dev_attr_bigain.dev_attr.attr,
696 &iio_dev_attr_cigain.dev_attr.attr,
697 &iio_dev_attr_avrmsgain.dev_attr.attr,
698 &iio_dev_attr_bvrmsgain.dev_attr.attr,
699 &iio_dev_attr_cvrmsgain.dev_attr.attr,
700 &iio_dev_attr_airmsos.dev_attr.attr,
701 &iio_dev_attr_birmsos.dev_attr.attr,
702 &iio_dev_attr_cirmsos.dev_attr.attr,
703 &iio_dev_attr_avrmsos.dev_attr.attr,
704 &iio_dev_attr_bvrmsos.dev_attr.attr,
705 &iio_dev_attr_cvrmsos.dev_attr.attr,
709 static const struct attribute_group ade7758_attribute_group = {
710 .attrs = ade7758_attributes,
715 static int __devinit ade7758_probe(struct spi_device *spi)
717 int ret, regdone = 0;
718 struct ade7758_state *st = kzalloc(sizeof *st, GFP_KERNEL);
723 /* this is only used for removal purposes */
724 spi_set_drvdata(spi, st);
726 /* Allocate the comms buffers */
727 st->rx = kzalloc(sizeof(*st->rx)*ADE7758_MAX_RX, GFP_KERNEL);
728 if (st->rx == NULL) {
732 st->tx = kzalloc(sizeof(*st->tx)*ADE7758_MAX_TX, GFP_KERNEL);
733 if (st->tx == NULL) {
738 mutex_init(&st->buf_lock);
739 /* setup the industrialio driver allocated elements */
740 st->indio_dev = iio_allocate_device();
741 if (st->indio_dev == NULL) {
746 st->indio_dev->dev.parent = &spi->dev;
747 st->indio_dev->num_interrupt_lines = 1;
748 st->indio_dev->event_attrs = &ade7758_event_attribute_group;
749 st->indio_dev->attrs = &ade7758_attribute_group;
750 st->indio_dev->dev_data = (void *)(st);
751 st->indio_dev->driver_module = THIS_MODULE;
752 st->indio_dev->modes = INDIO_DIRECT_MODE;
754 ret = ade7758_configure_ring(st->indio_dev);
758 ret = iio_device_register(st->indio_dev);
760 goto error_unreg_ring_funcs;
763 ret = ade7758_initialize_ring(st->indio_dev->ring);
765 printk(KERN_ERR "failed to initialize the ring\n");
766 goto error_unreg_ring_funcs;
770 ret = iio_register_interrupt_line(spi->irq,
773 IRQF_TRIGGER_FALLING,
776 goto error_uninitialize_ring;
778 ret = ade7758_probe_trigger(st->indio_dev);
780 goto error_unregister_line;
783 /* Get the device into a sane initial state */
784 ret = ade7758_initial_setup(st);
786 goto error_remove_trigger;
789 error_remove_trigger:
790 if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
791 ade7758_remove_trigger(st->indio_dev);
792 error_unregister_line:
793 if (st->indio_dev->modes & INDIO_RING_TRIGGERED)
794 iio_unregister_interrupt_line(st->indio_dev, 0);
795 error_uninitialize_ring:
796 ade7758_uninitialize_ring(st->indio_dev->ring);
797 error_unreg_ring_funcs:
798 ade7758_unconfigure_ring(st->indio_dev);
801 iio_device_unregister(st->indio_dev);
803 iio_free_device(st->indio_dev);
814 static int ade7758_remove(struct spi_device *spi)
817 struct ade7758_state *st = spi_get_drvdata(spi);
818 struct iio_dev *indio_dev = st->indio_dev;
820 ret = ade7758_stop_device(&(indio_dev->dev));
824 flush_scheduled_work();
826 ade7758_remove_trigger(indio_dev);
827 if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0)
828 iio_unregister_interrupt_line(indio_dev, 0);
830 ade7758_uninitialize_ring(indio_dev->ring);
831 iio_device_unregister(indio_dev);
832 ade7758_unconfigure_ring(indio_dev);
843 static struct spi_driver ade7758_driver = {
846 .owner = THIS_MODULE,
848 .probe = ade7758_probe,
849 .remove = __devexit_p(ade7758_remove),
852 static __init int ade7758_init(void)
854 return spi_register_driver(&ade7758_driver);
856 module_init(ade7758_init);
858 static __exit void ade7758_exit(void)
860 spi_unregister_driver(&ade7758_driver);
862 module_exit(ade7758_exit);
864 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
865 MODULE_DESCRIPTION("Analog Devices ADE7758 Polyphase Multifunction Energy Metering IC Driver");
866 MODULE_LICENSE("GPL v2");