drivers/hwmon/max1111.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * max1111.c - +2.7V, Low-Power, Multichannel, Serial 8-bit ADCs
0004  *
0005  * Based on arch/arm/mach-pxa/corgi_ssp.c
0006  *
0007  * Copyright (C) 2004-2005 Richard Purdie
0008  *
0009  * Copyright (C) 2008 Marvell International Ltd.
0010  *  Eric Miao <eric.miao@marvell.com>
0011  */
0012
0013 #include <linux/module.h>
0014 #include <linux/kernel.h>
0015 #include <linux/init.h>
0016 #include <linux/err.h>
0017 #include <linux/hwmon.h>
0018 #include <linux/hwmon-sysfs.h>
0019 #include <linux/spi/spi.h>
0020 #include <linux/slab.h>
0021
0022 enum chips { max1110, max1111, max1112, max1113 };
0023
0024 #define MAX1111_TX_BUF_SIZE 1
0025 #define MAX1111_RX_BUF_SIZE 2
0026
0027 /* MAX1111 Commands */
0028 #define MAX1111_CTRL_PD0      (1u << 0)
0029 #define MAX1111_CTRL_PD1      (1u << 1)
0030 #define MAX1111_CTRL_SGL      (1u << 2)
0031 #define MAX1111_CTRL_UNI      (1u << 3)
0032 #define MAX1110_CTRL_SEL_SH   (4)
0033 #define MAX1111_CTRL_SEL_SH   (5)   /* NOTE: bit 4 is ignored */
0034 #define MAX1111_CTRL_STR      (1u << 7)
0035
0036 struct max1111_data {
0037     struct spi_device   *spi;
0038     struct device       *hwmon_dev;
0039     struct spi_message  msg;
0040     struct spi_transfer xfer[2];
0041     uint8_t tx_buf[MAX1111_TX_BUF_SIZE];
0042     uint8_t rx_buf[MAX1111_RX_BUF_SIZE];
0043     struct mutex        drvdata_lock;
0044     /* protect msg, xfer and buffers from multiple access */
0045     int         sel_sh;
0046     int         lsb;
0047 };
0048
0049 static int max1111_read(struct device *dev, int channel)
0050 {
0051     struct max1111_data *data = dev_get_drvdata(dev);
0052     uint8_t v1, v2;
0053     int err;
0054
0055     /* writing to drvdata struct is not thread safe, wait on mutex */
0056     mutex_lock(&data->drvdata_lock);
0057
0058     data->tx_buf[0] = (channel << data->sel_sh) |
0059         MAX1111_CTRL_PD0 | MAX1111_CTRL_PD1 |
0060         MAX1111_CTRL_SGL | MAX1111_CTRL_UNI | MAX1111_CTRL_STR;
0061
0062     err = spi_sync(data->spi, &data->msg);
0063     if (err < 0) {
0064         dev_err(dev, "spi_sync failed with %d\n", err);
0065         mutex_unlock(&data->drvdata_lock);
0066         return err;
0067     }
0068
0069     v1 = data->rx_buf[0];
0070     v2 = data->rx_buf[1];
0071
0072     mutex_unlock(&data->drvdata_lock);
0073
0074     if ((v1 & 0xc0) || (v2 & 0x3f))
0075         return -EINVAL;
0076
0077     return (v1 << 2) | (v2 >> 6);
0078 }
0079
0080 #ifdef CONFIG_SHARPSL_PM
0081 static struct max1111_data *the_max1111;
0082
0083 int max1111_read_channel(int channel)
0084 {
0085     if (!the_max1111 || !the_max1111->spi)
0086         return -ENODEV;
0087
0088     return max1111_read(&the_max1111->spi->dev, channel);
0089 }
0090 EXPORT_SYMBOL(max1111_read_channel);
0091 #endif
0092
0093 /*
0094  * NOTE: SPI devices do not have a default 'name' attribute, which is
0095  * likely to be used by hwmon applications to distinguish between
0096  * different devices, explicitly add a name attribute here.
0097  */
0098 static ssize_t name_show(struct device *dev,
0099              struct device_attribute *attr, char *buf)
0100 {
0101     return sprintf(buf, "%s\n", to_spi_device(dev)->modalias);
0102 }
0103
0104 static ssize_t show_adc(struct device *dev,
0105             struct device_attribute *attr, char *buf)
0106 {
0107     struct max1111_data *data = dev_get_drvdata(dev);
0108     int channel = to_sensor_dev_attr(attr)->index;
0109     int ret;
0110
0111     ret = max1111_read(dev, channel);
0112     if (ret < 0)
0113         return ret;
0114
0115     /*
0116      * Assume the reference voltage to be 2.048V or 4.096V, with an 8-bit
0117      * sample. The LSB weight is 8mV or 16mV depending on the chip type.
0118      */
0119     return sprintf(buf, "%d\n", ret * data->lsb);
0120 }
0121
0122 #define MAX1111_ADC_ATTR(_id)       \
0123     SENSOR_DEVICE_ATTR(in##_id##_input, S_IRUGO, show_adc, NULL, _id)
0124
0125 static DEVICE_ATTR_RO(name);
0126 static MAX1111_ADC_ATTR(0);
0127 static MAX1111_ADC_ATTR(1);
0128 static MAX1111_ADC_ATTR(2);
0129 static MAX1111_ADC_ATTR(3);
0130 static MAX1111_ADC_ATTR(4);
0131 static MAX1111_ADC_ATTR(5);
0132 static MAX1111_ADC_ATTR(6);
0133 static MAX1111_ADC_ATTR(7);
0134
0135 static struct attribute *max1111_attributes[] = {
0136     &dev_attr_name.attr,
0137     &sensor_dev_attr_in0_input.dev_attr.attr,
0138     &sensor_dev_attr_in1_input.dev_attr.attr,
0139     &sensor_dev_attr_in2_input.dev_attr.attr,
0140     &sensor_dev_attr_in3_input.dev_attr.attr,
0141     NULL,
0142 };
0143
0144 static const struct attribute_group max1111_attr_group = {
0145     .attrs  = max1111_attributes,
0146 };
0147
0148 static struct attribute *max1110_attributes[] = {
0149     &sensor_dev_attr_in4_input.dev_attr.attr,
0150     &sensor_dev_attr_in5_input.dev_attr.attr,
0151     &sensor_dev_attr_in6_input.dev_attr.attr,
0152     &sensor_dev_attr_in7_input.dev_attr.attr,
0153     NULL,
0154 };
0155
0156 static const struct attribute_group max1110_attr_group = {
0157     .attrs  = max1110_attributes,
0158 };
0159
0160 static int setup_transfer(struct max1111_data *data)
0161 {
0162     struct spi_message *m;
0163     struct spi_transfer *x;
0164
0165     m = &data->msg;
0166     x = &data->xfer[0];
0167
0168     spi_message_init(m);
0169
0170     x->tx_buf = &data->tx_buf[0];
0171     x->len = MAX1111_TX_BUF_SIZE;
0172     spi_message_add_tail(x, m);
0173
0174     x++;
0175     x->rx_buf = &data->rx_buf[0];
0176     x->len = MAX1111_RX_BUF_SIZE;
0177     spi_message_add_tail(x, m);
0178
0179     return 0;
0180 }
0181
0182 static int max1111_probe(struct spi_device *spi)
0183 {
0184     enum chips chip = spi_get_device_id(spi)->driver_data;
0185     struct max1111_data *data;
0186     int err;
0187
0188     spi->bits_per_word = 8;
0189     spi->mode = SPI_MODE_0;
0190     err = spi_setup(spi);
0191     if (err < 0)
0192         return err;
0193
0194     data = devm_kzalloc(&spi->dev, sizeof(struct max1111_data), GFP_KERNEL);
0195     if (data == NULL)
0196         return -ENOMEM;
0197
0198     switch (chip) {
0199     case max1110:
0200         data->lsb = 8;
0201         data->sel_sh = MAX1110_CTRL_SEL_SH;
0202         break;
0203     case max1111:
0204         data->lsb = 8;
0205         data->sel_sh = MAX1111_CTRL_SEL_SH;
0206         break;
0207     case max1112:
0208         data->lsb = 16;
0209         data->sel_sh = MAX1110_CTRL_SEL_SH;
0210         break;
0211     case max1113:
0212         data->lsb = 16;
0213         data->sel_sh = MAX1111_CTRL_SEL_SH;
0214         break;
0215     }
0216     err = setup_transfer(data);
0217     if (err)
0218         return err;
0219
0220     mutex_init(&data->drvdata_lock);
0221
0222     data->spi = spi;
0223     spi_set_drvdata(spi, data);
0224
0225     err = sysfs_create_group(&spi->dev.kobj, &max1111_attr_group);
0226     if (err) {
0227         dev_err(&spi->dev, "failed to create attribute group\n");
0228         return err;
0229     }
0230     if (chip == max1110 || chip == max1112) {
0231         err = sysfs_create_group(&spi->dev.kobj, &max1110_attr_group);
0232         if (err) {
0233             dev_err(&spi->dev,
0234                 "failed to create extended attribute group\n");
0235             goto err_remove;
0236         }
0237     }
0238
0239     data->hwmon_dev = hwmon_device_register(&spi->dev);
0240     if (IS_ERR(data->hwmon_dev)) {
0241         dev_err(&spi->dev, "failed to create hwmon device\n");
0242         err = PTR_ERR(data->hwmon_dev);
0243         goto err_remove;
0244     }
0245
0246 #ifdef CONFIG_SHARPSL_PM
0247     the_max1111 = data;
0248 #endif
0249     return 0;
0250
0251 err_remove:
0252     sysfs_remove_group(&spi->dev.kobj, &max1110_attr_group);
0253     sysfs_remove_group(&spi->dev.kobj, &max1111_attr_group);
0254     return err;
0255 }
0256
0257 static void max1111_remove(struct spi_device *spi)
0258 {
0259     struct max1111_data *data = spi_get_drvdata(spi);
0260
0261 #ifdef CONFIG_SHARPSL_PM
0262     the_max1111 = NULL;
0263 #endif
0264     hwmon_device_unregister(data->hwmon_dev);
0265     sysfs_remove_group(&spi->dev.kobj, &max1110_attr_group);
0266     sysfs_remove_group(&spi->dev.kobj, &max1111_attr_group);
0267     mutex_destroy(&data->drvdata_lock);
0268 }
0269
0270 static const struct spi_device_id max1111_ids[] = {
0271     { "max1110", max1110 },
0272     { "max1111", max1111 },
0273     { "max1112", max1112 },
0274     { "max1113", max1113 },
0275     { },
0276 };
0277 MODULE_DEVICE_TABLE(spi, max1111_ids);
0278
0279 static struct spi_driver max1111_driver = {
0280     .driver     = {
0281         .name   = "max1111",
0282     },
0283     .id_table   = max1111_ids,
0284     .probe      = max1111_probe,
0285     .remove     = max1111_remove,
0286 };
0287
0288 module_spi_driver(max1111_driver);
0289
0290 MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>");
0291 MODULE_DESCRIPTION("MAX1110/MAX1111/MAX1112/MAX1113 ADC Driver");
0292 MODULE_LICENSE("GPL");