drivers/hwmon/mc13783-adc.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Driver for the ADC on Freescale Semiconductor MC13783 and MC13892 PMICs.
0004  *
0005  * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
0006  * Copyright (C) 2009 Sascha Hauer, Pengutronix
0007  */
0008
0009 #include <linux/mfd/mc13xxx.h>
0010 #include <linux/platform_device.h>
0011 #include <linux/hwmon-sysfs.h>
0012 #include <linux/kernel.h>
0013 #include <linux/module.h>
0014 #include <linux/mod_devicetable.h>
0015 #include <linux/hwmon.h>
0016 #include <linux/slab.h>
0017 #include <linux/init.h>
0018 #include <linux/err.h>
0019
0020 #define DRIVER_NAME "mc13783-adc"
0021
0022 /* platform device id driver data */
0023 #define MC13783_ADC_16CHANS 1
0024 #define MC13783_ADC_BPDIV2  2
0025
0026 struct mc13783_adc_priv {
0027     struct mc13xxx *mc13xxx;
0028     struct device *hwmon_dev;
0029     char name[PLATFORM_NAME_SIZE];
0030 };
0031
0032 static ssize_t name_show(struct device *dev, struct device_attribute *devattr,
0033              char *buf)
0034 {
0035     struct mc13783_adc_priv *priv = dev_get_drvdata(dev);
0036
0037     return sprintf(buf, "%s\n", priv->name);
0038 }
0039
0040 static int mc13783_adc_read(struct device *dev,
0041         struct device_attribute *devattr, unsigned int *val)
0042 {
0043     struct mc13783_adc_priv *priv = dev_get_drvdata(dev);
0044     struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
0045     unsigned int channel = attr->index;
0046     unsigned int sample[4];
0047     int ret;
0048
0049     ret = mc13xxx_adc_do_conversion(priv->mc13xxx,
0050             MC13XXX_ADC_MODE_MULT_CHAN,
0051             channel, 0, 0, sample);
0052     if (ret)
0053         return ret;
0054
0055     /* ADIN7 subchannels */
0056     if (channel >= 16)
0057         channel = 7;
0058
0059     channel &= 0x7;
0060
0061     *val = (sample[channel % 4] >> (channel > 3 ? 14 : 2)) & 0x3ff;
0062
0063     return 0;
0064 }
0065
0066 static ssize_t mc13783_adc_bp_show(struct device *dev,
0067                    struct device_attribute *devattr,
0068                    char *buf)
0069 {
0070     unsigned val;
0071     struct platform_device *pdev = to_platform_device(dev);
0072     kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;
0073     int ret = mc13783_adc_read(dev, devattr, &val);
0074
0075     if (ret)
0076         return ret;
0077
0078     if (driver_data & MC13783_ADC_BPDIV2)
0079         val = DIV_ROUND_CLOSEST(val * 9, 2);
0080     else
0081         /*
0082          * BP (channel 2) reports with offset 2.4V to the actual value
0083          * to fit the input range of the ADC.  unit = 2.25mV = 9/4 mV.
0084          */
0085         val = DIV_ROUND_CLOSEST(val * 9, 4) + 2400;
0086
0087     return sprintf(buf, "%u\n", val);
0088 }
0089
0090 static ssize_t mc13783_adc_gp_show(struct device *dev,
0091                    struct device_attribute *devattr,
0092                    char *buf)
0093 {
0094     unsigned val;
0095     int ret = mc13783_adc_read(dev, devattr, &val);
0096
0097     if (ret)
0098         return ret;
0099
0100     /*
0101      * input range is [0, 2.3V], val has 10 bits, so each bit
0102      * is worth 9/4 mV.
0103      */
0104     val = DIV_ROUND_CLOSEST(val * 9, 4);
0105
0106     return sprintf(buf, "%u\n", val);
0107 }
0108
0109 static ssize_t mc13783_adc_uid_show(struct device *dev,
0110                     struct device_attribute *devattr,
0111                     char *buf)
0112 {
0113     unsigned int val;
0114     struct platform_device *pdev = to_platform_device(dev);
0115     kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;
0116     int ret = mc13783_adc_read(dev, devattr, &val);
0117
0118     if (ret)
0119         return ret;
0120
0121     if (driver_data & MC13783_ADC_BPDIV2)
0122         /* MC13892 have 1/2 divider, input range is [0, 4.800V] */
0123         val = DIV_ROUND_CLOSEST(val * 4800, 1024);
0124     else
0125         /* MC13783 have 0.9 divider, input range is [0, 2.555V] */
0126         val = DIV_ROUND_CLOSEST(val * 2555, 1024);
0127
0128     return sprintf(buf, "%u\n", val);
0129 }
0130
0131 static ssize_t mc13783_adc_temp_show(struct device *dev,
0132                      struct device_attribute *devattr,
0133                      char *buf)
0134 {
0135     unsigned int val;
0136     struct platform_device *pdev = to_platform_device(dev);
0137     kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;
0138     int ret = mc13783_adc_read(dev, devattr, &val);
0139
0140     if (ret)
0141         return ret;
0142
0143     if (driver_data & MC13783_ADC_BPDIV2) {
0144         /*
0145          * MC13892:
0146          * Die Temperature Read Out Code at 25C 680
0147          * Temperature change per LSB +0.4244C
0148          */
0149         ret = DIV_ROUND_CLOSEST(-2635920 + val * 4244, 10);
0150     } else {
0151         /*
0152          * MC13783:
0153          * Die Temperature Read Out Code at 25C 282
0154          * Temperature change per LSB -1.14C
0155          */
0156         ret = 346480 - 1140 * val;
0157     }
0158
0159     return sprintf(buf, "%d\n", ret);
0160 }
0161
0162 static DEVICE_ATTR_RO(name);
0163 static SENSOR_DEVICE_ATTR_RO(in2_input, mc13783_adc_bp, 2);
0164 static SENSOR_DEVICE_ATTR_RO(in5_input, mc13783_adc_gp, 5);
0165 static SENSOR_DEVICE_ATTR_RO(in6_input, mc13783_adc_gp, 6);
0166 static SENSOR_DEVICE_ATTR_RO(in7_input, mc13783_adc_gp, 7);
0167 static SENSOR_DEVICE_ATTR_RO(in8_input, mc13783_adc_gp, 8);
0168 static SENSOR_DEVICE_ATTR_RO(in9_input, mc13783_adc_gp, 9);
0169 static SENSOR_DEVICE_ATTR_RO(in10_input, mc13783_adc_gp, 10);
0170 static SENSOR_DEVICE_ATTR_RO(in11_input, mc13783_adc_gp, 11);
0171 static SENSOR_DEVICE_ATTR_RO(in12_input, mc13783_adc_gp, 12);
0172 static SENSOR_DEVICE_ATTR_RO(in13_input, mc13783_adc_gp, 13);
0173 static SENSOR_DEVICE_ATTR_RO(in14_input, mc13783_adc_gp, 14);
0174 static SENSOR_DEVICE_ATTR_RO(in15_input, mc13783_adc_gp, 15);
0175 static SENSOR_DEVICE_ATTR_RO(in16_input, mc13783_adc_uid, 16);
0176 static SENSOR_DEVICE_ATTR_RO(temp1_input, mc13783_adc_temp, 17);
0177
0178 static struct attribute *mc13783_attr_base[] = {
0179     &dev_attr_name.attr,
0180     &sensor_dev_attr_in2_input.dev_attr.attr,
0181     &sensor_dev_attr_in5_input.dev_attr.attr,
0182     &sensor_dev_attr_in6_input.dev_attr.attr,
0183     &sensor_dev_attr_in7_input.dev_attr.attr,
0184     &sensor_dev_attr_in16_input.dev_attr.attr,
0185     &sensor_dev_attr_temp1_input.dev_attr.attr,
0186     NULL
0187 };
0188
0189 static const struct attribute_group mc13783_group_base = {
0190     .attrs = mc13783_attr_base,
0191 };
0192
0193 /* these are only used if MC13783_ADC_16CHANS is provided in driver data */
0194 static struct attribute *mc13783_attr_16chans[] = {
0195     &sensor_dev_attr_in8_input.dev_attr.attr,
0196     &sensor_dev_attr_in9_input.dev_attr.attr,
0197     &sensor_dev_attr_in10_input.dev_attr.attr,
0198     &sensor_dev_attr_in11_input.dev_attr.attr,
0199     NULL
0200 };
0201
0202 static const struct attribute_group mc13783_group_16chans = {
0203     .attrs = mc13783_attr_16chans,
0204 };
0205
0206 /* last four channels may be occupied by the touchscreen */
0207 static struct attribute *mc13783_attr_ts[] = {
0208     &sensor_dev_attr_in12_input.dev_attr.attr,
0209     &sensor_dev_attr_in13_input.dev_attr.attr,
0210     &sensor_dev_attr_in14_input.dev_attr.attr,
0211     &sensor_dev_attr_in15_input.dev_attr.attr,
0212     NULL
0213 };
0214
0215 static const struct attribute_group mc13783_group_ts = {
0216     .attrs = mc13783_attr_ts,
0217 };
0218
0219 static int mc13783_adc_use_touchscreen(struct platform_device *pdev)
0220 {
0221     struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
0222     unsigned flags = mc13xxx_get_flags(priv->mc13xxx);
0223
0224     return flags & MC13XXX_USE_TOUCHSCREEN;
0225 }
0226
0227 static int __init mc13783_adc_probe(struct platform_device *pdev)
0228 {
0229     struct mc13783_adc_priv *priv;
0230     int ret;
0231     const struct platform_device_id *id = platform_get_device_id(pdev);
0232     char *dash;
0233
0234     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
0235     if (!priv)
0236         return -ENOMEM;
0237
0238     priv->mc13xxx = dev_get_drvdata(pdev->dev.parent);
0239     snprintf(priv->name, ARRAY_SIZE(priv->name), "%s", id->name);
0240     dash = strchr(priv->name, '-');
0241     if (dash)
0242         *dash = '\0';
0243
0244     platform_set_drvdata(pdev, priv);
0245
0246     /* Register sysfs hooks */
0247     ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_base);
0248     if (ret)
0249         return ret;
0250
0251     if (id->driver_data & MC13783_ADC_16CHANS) {
0252         ret = sysfs_create_group(&pdev->dev.kobj,
0253                 &mc13783_group_16chans);
0254         if (ret)
0255             goto out_err_create_16chans;
0256     }
0257
0258     if (!mc13783_adc_use_touchscreen(pdev)) {
0259         ret = sysfs_create_group(&pdev->dev.kobj, &mc13783_group_ts);
0260         if (ret)
0261             goto out_err_create_ts;
0262     }
0263
0264     priv->hwmon_dev = hwmon_device_register(&pdev->dev);
0265     if (IS_ERR(priv->hwmon_dev)) {
0266         ret = PTR_ERR(priv->hwmon_dev);
0267         dev_err(&pdev->dev,
0268                 "hwmon_device_register failed with %d.\n", ret);
0269         goto out_err_register;
0270     }
0271
0272     return 0;
0273
0274 out_err_register:
0275
0276     if (!mc13783_adc_use_touchscreen(pdev))
0277         sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);
0278 out_err_create_ts:
0279
0280     if (id->driver_data & MC13783_ADC_16CHANS)
0281         sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_16chans);
0282 out_err_create_16chans:
0283
0284     sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_base);
0285     return ret;
0286 }
0287
0288 static int mc13783_adc_remove(struct platform_device *pdev)
0289 {
0290     struct mc13783_adc_priv *priv = platform_get_drvdata(pdev);
0291     kernel_ulong_t driver_data = platform_get_device_id(pdev)->driver_data;
0292
0293     hwmon_device_unregister(priv->hwmon_dev);
0294
0295     if (!mc13783_adc_use_touchscreen(pdev))
0296         sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_ts);
0297
0298     if (driver_data & MC13783_ADC_16CHANS)
0299         sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_16chans);
0300
0301     sysfs_remove_group(&pdev->dev.kobj, &mc13783_group_base);
0302
0303     return 0;
0304 }
0305
0306 static const struct platform_device_id mc13783_adc_idtable[] = {
0307     {
0308         .name = "mc13783-adc",
0309         .driver_data = MC13783_ADC_16CHANS,
0310     }, {
0311         .name = "mc13892-adc",
0312         .driver_data = MC13783_ADC_BPDIV2,
0313     }, {
0314         /* sentinel */
0315     }
0316 };
0317 MODULE_DEVICE_TABLE(platform, mc13783_adc_idtable);
0318
0319 static struct platform_driver mc13783_adc_driver = {
0320     .remove     = mc13783_adc_remove,
0321     .driver     = {
0322         .name   = DRIVER_NAME,
0323     },
0324     .id_table   = mc13783_adc_idtable,
0325 };
0326
0327 module_platform_driver_probe(mc13783_adc_driver, mc13783_adc_probe);
0328
0329 MODULE_DESCRIPTION("MC13783 ADC driver");
0330 MODULE_AUTHOR("Luotao Fu <l.fu@pengutronix.de>");
0331 MODULE_LICENSE("GPL");