iio/meter/ade7854-spi.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * ADE7854/58/68/78 Polyphase Multifunction Energy Metering IC Driver (SPI Bus)
0004  *
0005  * Copyright 2010 Analog Devices Inc.
0006  */
0007
0008 #include <linux/device.h>
0009 #include <linux/kernel.h>
0010 #include <linux/spi/spi.h>
0011 #include <linux/slab.h>
0012 #include <linux/module.h>
0013
0014 #include <linux/iio/iio.h>
0015 #include "ade7854.h"
0016
0017 static int ade7854_spi_write_reg(struct device *dev,
0018                  u16 reg_address,
0019                  u32 val,
0020                  int bits)
0021 {
0022     int ret;
0023     struct iio_dev *indio_dev = dev_to_iio_dev(dev);
0024     struct ade7854_state *st = iio_priv(indio_dev);
0025     struct spi_transfer xfer = {
0026         .tx_buf = st->tx,
0027         .bits_per_word = 8,
0028         .len = 4,
0029     };
0030
0031     mutex_lock(&st->buf_lock);
0032     st->tx[0] = ADE7854_WRITE_REG;
0033     st->tx[1] = (reg_address >> 8) & 0xFF;
0034     st->tx[2] = reg_address & 0xFF;
0035     switch (bits) {
0036     case 8:
0037         st->tx[3] = val & 0xFF;
0038         break;
0039     case 16:
0040         xfer.len = 5;
0041         st->tx[3] = (val >> 8) & 0xFF;
0042         st->tx[4] = val & 0xFF;
0043         break;
0044     case 24:
0045         xfer.len = 6;
0046         st->tx[3] = (val >> 16) & 0xFF;
0047         st->tx[4] = (val >> 8) & 0xFF;
0048         st->tx[5] = val & 0xFF;
0049         break;
0050     case 32:
0051         xfer.len = 7;
0052         st->tx[3] = (val >> 24) & 0xFF;
0053         st->tx[4] = (val >> 16) & 0xFF;
0054         st->tx[5] = (val >> 8) & 0xFF;
0055         st->tx[6] = val & 0xFF;
0056         break;
0057     default:
0058         ret = -EINVAL;
0059         goto unlock;
0060     }
0061
0062     ret = spi_sync_transfer(st->spi, &xfer, 1);
0063 unlock:
0064     mutex_unlock(&st->buf_lock);
0065
0066     return ret;
0067 }
0068
0069 static int ade7854_spi_read_reg(struct device *dev,
0070                 u16 reg_address,
0071                 u32 *val,
0072                 int bits)
0073 {
0074     struct iio_dev *indio_dev = dev_to_iio_dev(dev);
0075     struct ade7854_state *st = iio_priv(indio_dev);
0076     int ret;
0077     struct spi_transfer xfers[] = {
0078         {
0079             .tx_buf = st->tx,
0080             .bits_per_word = 8,
0081             .len = 3,
0082         }, {
0083             .rx_buf = st->rx,
0084             .bits_per_word = 8,
0085             .len = bits,
0086         }
0087     };
0088
0089     mutex_lock(&st->buf_lock);
0090
0091     st->tx[0] = ADE7854_READ_REG;
0092     st->tx[1] = (reg_address >> 8) & 0xFF;
0093     st->tx[2] = reg_address & 0xFF;
0094
0095     ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
0096     if (ret < 0) {
0097         dev_err(&st->spi->dev, "problem when reading register 0x%02X",
0098             reg_address);
0099         goto unlock;
0100     }
0101
0102     switch (bits) {
0103     case 8:
0104         *val = st->rx[0];
0105         break;
0106     case 16:
0107         *val = be16_to_cpup((const __be16 *)st->rx);
0108         break;
0109     case 24:
0110         *val = (st->rx[0] << 16) | (st->rx[1] << 8) | st->rx[2];
0111         break;
0112     case 32:
0113         *val = be32_to_cpup((const __be32 *)st->rx);
0114         break;
0115     }
0116
0117 unlock:
0118     mutex_unlock(&st->buf_lock);
0119     return ret;
0120 }
0121
0122 static int ade7854_spi_probe(struct spi_device *spi)
0123 {
0124     struct ade7854_state *st;
0125     struct iio_dev *indio_dev;
0126
0127     indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
0128     if (!indio_dev)
0129         return -ENOMEM;
0130     st = iio_priv(indio_dev);
0131     spi_set_drvdata(spi, indio_dev);
0132     st->read_reg = ade7854_spi_read_reg;
0133     st->write_reg = ade7854_spi_write_reg;
0134     st->irq = spi->irq;
0135     st->spi = spi;
0136
0137     return ade7854_probe(indio_dev, &spi->dev);
0138 }
0139
0140 static const struct spi_device_id ade7854_id[] = {
0141     { "ade7854", 0 },
0142     { "ade7858", 0 },
0143     { "ade7868", 0 },
0144     { "ade7878", 0 },
0145     { }
0146 };
0147 MODULE_DEVICE_TABLE(spi, ade7854_id);
0148
0149 static struct spi_driver ade7854_driver = {
0150     .driver = {
0151         .name = "ade7854",
0152     },
0153     .probe = ade7854_spi_probe,
0154     .id_table = ade7854_id,
0155 };
0156 module_spi_driver(ade7854_driver);
0157
0158 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
0159 MODULE_DESCRIPTION("Analog Devices ADE7854/58/68/78 SPI Driver");
0160 MODULE_LICENSE("GPL v2");