target/linux/bcm27xx/patches-6.1/950-0897-hwmon-Add-RP1-ADC-and-temperature-driver.patch

   1 From cad3c92ff0c1a5fa539d08b695b0f6b326924890 Mon Sep 17 00:00:00 2001
   2 From: Phil Elwell <phil@raspberrypi.com>
   3 Date: Thu, 2 Mar 2023 18:04:42 +0000
   4 Subject: [PATCH] hwmon: Add RP1 ADC and temperature driver
   5
   6 Signed-off-by: Phil Elwell <phil@raspberrypi.com>
   7 ---
   8  drivers/hwmon/Kconfig   |   7 +
   9  drivers/hwmon/Makefile  |   1 +
  10  drivers/hwmon/rp1-adc.c | 301 ++++++++++++++++++++++++++++++++++++++++
  11  3 files changed, 309 insertions(+)
  12  create mode 100644 drivers/hwmon/rp1-adc.c
  13
  14 --- a/drivers/hwmon/Kconfig
  15 +++ b/drivers/hwmon/Kconfig
  16 @@ -2331,6 +2331,13 @@ config SENSORS_INTEL_M10_BMC_HWMON
  17           sensors monitor various telemetry data of different components on the
  18           card, e.g. board temperature, FPGA core temperature/voltage/current.
  19
  20 +config SENSORS_RP1_ADC
  21 +       tristate "RP1 ADC and temperature sensor driver"
  22 +       depends on MFD_RP1
  23 +       help
  24 +         Say yes here to enable support for the voltage and temperature
  25 +         sensors of the Raspberry Pi RP1 peripheral chip.
  26 +
  27  if ACPI
  28
  29  comment "ACPI drivers"
  30 --- a/drivers/hwmon/Makefile
  31 +++ b/drivers/hwmon/Makefile
  32 @@ -173,6 +173,7 @@ obj-$(CONFIG_SENSORS_PCF8591)       += pcf8591
  33  obj-$(CONFIG_SENSORS_POWR1220)  += powr1220.o
  34  obj-$(CONFIG_SENSORS_PWM_FAN)  += pwm-fan.o
  35  obj-$(CONFIG_SENSORS_RASPBERRYPI_HWMON)        += raspberrypi-hwmon.o
  36 +obj-$(CONFIG_SENSORS_RP1_ADC)  += rp1-adc.o
  37  obj-$(CONFIG_SENSORS_S3C)      += s3c-hwmon.o
  38  obj-$(CONFIG_SENSORS_SBTSI)    += sbtsi_temp.o
  39  obj-$(CONFIG_SENSORS_SBRMI)    += sbrmi.o
  40 --- /dev/null
  41 +++ b/drivers/hwmon/rp1-adc.c
  42 @@ -0,0 +1,301 @@
  43 +// SPDX-License-Identifier: GPL-2.0+
  44 +/*
  45 + * Driver for the RP1 ADC and temperature sensor
  46 + * Copyright (C) 2023 Raspberry Pi Ltd.
  47 + */
  48 +
  49 +#include <linux/clk.h>
  50 +#include <linux/err.h>
  51 +#include <linux/hwmon.h>
  52 +#include <linux/hwmon-sysfs.h>
  53 +#include <linux/io.h>
  54 +#include <linux/module.h>
  55 +#include <linux/mod_devicetable.h>
  56 +#include <linux/platform_device.h>
  57 +#include <linux/regulator/consumer.h>
  58 +
  59 +#define MODULE_NAME    "rp1-adc"
  60 +
  61 +#define RP1_ADC_CS             0x00
  62 +#define RP1_ADC_RESULT         0x04
  63 +#define RP1_ADC_FCS            0x08
  64 +#define RP1_ADC_FIFO           0x0c
  65 +#define RP1_ADC_DIV            0x10
  66 +
  67 +#define RP1_ADC_INTR           0x14
  68 +#define RP1_ADC_INTE           0x18
  69 +#define RP1_ADC_INTF           0x1c
  70 +#define RP1_ADC_INTS           0x20
  71 +
  72 +#define RP1_ADC_RWTYPE_SET     0x2000
  73 +#define RP1_ADC_RWTYPE_CLR     0x3000
  74 +
  75 +#define RP1_ADC_CS_RROBIN_MASK 0x1f
  76 +#define RP1_ADC_CS_RROBIN_SHIFT        16
  77 +#define RP1_ADC_CS_AINSEL_MASK 0x7
  78 +#define RP1_ADC_CS_AINSEL_SHIFT        12
  79 +#define RP1_ADC_CS_ERR_STICKY  0x400
  80 +#define RP1_ADC_CS_ERR         0x200
  81 +#define RP1_ADC_CS_READY       0x100
  82 +#define RP1_ADC_CS_START_MANY  0x8
  83 +#define RP1_ADC_CS_START_ONCE  0x4
  84 +#define RP1_ADC_CS_TS_EN       0x2
  85 +#define RP1_ADC_CS_EN          0x1
  86 +
  87 +#define RP1_ADC_FCS_THRESH_MASK        0xf
  88 +#define RP1_ADC_FCS_THRESH_SHIFT       24
  89 +#define RP1_ADC_FCS_LEVEL_MASK 0xf
  90 +#define RP1_ADC_FCS_LEVEL_SHIFT        16
  91 +#define RP1_ADC_FCS_OVER       0x800
  92 +#define RP1_ADC_FCS_UNDER      0x400
  93 +#define RP1_ADC_FCS_FULL       0x200
  94 +#define RP1_ADC_FCS_EMPTY      0x100
  95 +#define RP1_ADC_FCS_DREQ_EN    0x8
  96 +#define RP1_ADC_FCS_ERR                0x4
  97 +#define RP1_ADC_FCS_SHIFR      0x2
  98 +#define RP1_ADC_FCS_EN         0x1
  99 +
 100 +#define RP1_ADC_FIFO_ERR       0x8000
 101 +#define RP1_ADC_FIFO_VAL_MASK  0xfff
 102 +
 103 +#define RP1_ADC_DIV_INT_MASK   0xffff
 104 +#define RP1_ADC_DIV_INT_SHIFT  8
 105 +#define RP1_ADC_DIV_FRAC_MASK  0xff
 106 +#define RP1_ADC_DIV_FRAC_SHIFT 0
 107 +
 108 +struct rp1_adc_data {
 109 +       void __iomem *base;
 110 +       spinlock_t lock;
 111 +       struct device *hwmon_dev;
 112 +       int vref_mv;
 113 +};
 114 +
 115 +static int rp1_adc_ready_wait(struct rp1_adc_data *data)
 116 +{
 117 +       int retries = 10;
 118 +
 119 +       while (retries && !(readl(data->base + RP1_ADC_CS) & RP1_ADC_CS_READY))
 120 +               retries--;
 121 +
 122 +       return retries ? 0 : -EIO;
 123 +}
 124 +
 125 +static int rp1_adc_read(struct rp1_adc_data *data,
 126 +                       struct device_attribute *devattr, unsigned int *val)
 127 +{
 128 +       struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 129 +       int channel = attr->index;
 130 +       int ret;
 131 +
 132 +       spin_lock(&data->lock);
 133 +
 134 +       writel(RP1_ADC_CS_AINSEL_MASK << RP1_ADC_CS_AINSEL_SHIFT,
 135 +              data->base + RP1_ADC_RWTYPE_CLR + RP1_ADC_CS);
 136 +       writel(channel << RP1_ADC_CS_AINSEL_SHIFT,
 137 +              data->base + RP1_ADC_RWTYPE_SET + RP1_ADC_CS);
 138 +       writel(RP1_ADC_CS_START_ONCE,
 139 +              data->base + RP1_ADC_RWTYPE_SET + RP1_ADC_CS);
 140 +
 141 +       ret = rp1_adc_ready_wait(data);
 142 +       if (!ret)
 143 +               *val = readl(data->base + RP1_ADC_RESULT);
 144 +
 145 +       spin_unlock(&data->lock);
 146 +
 147 +       return ret;
 148 +}
 149 +
 150 +static int rp1_adc_to_mv(struct rp1_adc_data *data, unsigned int val)
 151 +{
 152 +       return ((u64)data->vref_mv * val) / 0xfff;
 153 +}
 154 +
 155 +static ssize_t rp1_adc_show(struct device *dev,
 156 +                           struct device_attribute *devattr,
 157 +                           char *buf)
 158 +{
 159 +       struct rp1_adc_data *data = dev_get_drvdata(dev);
 160 +       unsigned int val;
 161 +       int ret;
 162 +
 163 +       ret = rp1_adc_read(data, devattr, &val);
 164 +       if (ret)
 165 +               return ret;
 166 +
 167 +       return sprintf(buf, "%d\n", rp1_adc_to_mv(data, val));
 168 +}
 169 +
 170 +static ssize_t rp1_adc_temp_show(struct device *dev,
 171 +                                struct device_attribute *devattr,
 172 +                                char *buf)
 173 +{
 174 +       struct rp1_adc_data *data = dev_get_drvdata(dev);
 175 +       unsigned int val;
 176 +       int ret, mv, mc;
 177 +
 178 +       writel(RP1_ADC_CS_TS_EN,
 179 +              data->base + RP1_ADC_RWTYPE_SET + RP1_ADC_CS);
 180 +       ret = rp1_adc_read(data, devattr, &val);
 181 +       if (ret)
 182 +               return ret;
 183 +
 184 +       mv = rp1_adc_to_mv(data, val);
 185 +
 186 +       /* T = 27 - (ADC_voltage - 0.706)/0.001721 */
 187 +
 188 +       mc = 27000 - DIV_ROUND_CLOSEST((mv - 706) * (s64)1000000, 1721);
 189 +
 190 +       return sprintf(buf, "%d\n", mc);
 191 +}
 192 +
 193 +static ssize_t rp1_adc_raw_show(struct device *dev,
 194 +                               struct device_attribute *devattr,
 195 +                               char *buf)
 196 +{
 197 +       struct rp1_adc_data *data = dev_get_drvdata(dev);
 198 +       unsigned int val;
 199 +       int ret = rp1_adc_read(data, devattr, &val);
 200 +
 201 +       if (ret)
 202 +               return ret;
 203 +
 204 +       return sprintf(buf, "%u\n", val);
 205 +}
 206 +
 207 +static ssize_t rp1_adc_temp_raw_show(struct device *dev,
 208 +                                    struct device_attribute *devattr,
 209 +                                    char *buf)
 210 +{
 211 +       struct rp1_adc_data *data = dev_get_drvdata(dev);
 212 +       unsigned int val;
 213 +       int ret = rp1_adc_read(data, devattr, &val);
 214 +
 215 +       if (ret)
 216 +               return ret;
 217 +
 218 +       return sprintf(buf, "%u\n", val);
 219 +}
 220 +
 221 +static SENSOR_DEVICE_ATTR_RO(in1_input, rp1_adc, 0);
 222 +static SENSOR_DEVICE_ATTR_RO(in2_input, rp1_adc, 1);
 223 +static SENSOR_DEVICE_ATTR_RO(in3_input, rp1_adc, 2);
 224 +static SENSOR_DEVICE_ATTR_RO(in4_input, rp1_adc, 3);
 225 +static SENSOR_DEVICE_ATTR_RO(temp1_input, rp1_adc_temp, 4);
 226 +static SENSOR_DEVICE_ATTR_RO(in1_raw, rp1_adc_raw, 0);
 227 +static SENSOR_DEVICE_ATTR_RO(in2_raw, rp1_adc_raw, 1);
 228 +static SENSOR_DEVICE_ATTR_RO(in3_raw, rp1_adc_raw, 2);
 229 +static SENSOR_DEVICE_ATTR_RO(in4_raw, rp1_adc_raw, 3);
 230 +static SENSOR_DEVICE_ATTR_RO(temp1_raw, rp1_adc_temp_raw, 4);
 231 +
 232 +static struct attribute *rp1_adc_attrs[] = {
 233 +       &sensor_dev_attr_in1_input.dev_attr.attr,
 234 +       &sensor_dev_attr_in2_input.dev_attr.attr,
 235 +       &sensor_dev_attr_in3_input.dev_attr.attr,
 236 +       &sensor_dev_attr_in4_input.dev_attr.attr,
 237 +       &sensor_dev_attr_temp1_input.dev_attr.attr,
 238 +       &sensor_dev_attr_in1_raw.dev_attr.attr,
 239 +       &sensor_dev_attr_in2_raw.dev_attr.attr,
 240 +       &sensor_dev_attr_in3_raw.dev_attr.attr,
 241 +       &sensor_dev_attr_in4_raw.dev_attr.attr,
 242 +       &sensor_dev_attr_temp1_raw.dev_attr.attr,
 243 +       NULL
 244 +};
 245 +
 246 +static umode_t rp1_adc_is_visible(struct kobject *kobj,
 247 +                                 struct attribute *attr, int index)
 248 +{
 249 +       return 0444;
 250 +}
 251 +
 252 +static const struct attribute_group rp1_adc_group = {
 253 +       .attrs = rp1_adc_attrs,
 254 +       .is_visible = rp1_adc_is_visible,
 255 +};
 256 +__ATTRIBUTE_GROUPS(rp1_adc);
 257 +
 258 +static int __init rp1_adc_probe(struct platform_device *pdev)
 259 +{
 260 +       struct rp1_adc_data *data;
 261 +       struct regulator *reg;
 262 +       struct clk *clk;
 263 +       int vref_uv, ret;
 264 +
 265 +       data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 266 +       if (!data)
 267 +               return -ENOMEM;
 268 +
 269 +       spin_lock_init(&data->lock);
 270 +
 271 +       data->base = devm_platform_ioremap_resource(pdev, 0);
 272 +       if (IS_ERR(data->base))
 273 +               return PTR_ERR(data->base);
 274 +
 275 +       platform_set_drvdata(pdev, data);
 276 +
 277 +       clk = devm_clk_get(&pdev->dev, NULL);
 278 +       if (IS_ERR(clk))
 279 +               return -ENODEV;
 280 +
 281 +       clk_set_rate(clk, 50000000);
 282 +       clk_prepare_enable(clk);
 283 +
 284 +       reg = devm_regulator_get(&pdev->dev, "vref");
 285 +       if (IS_ERR(reg))
 286 +               return PTR_ERR(reg);
 287 +
 288 +       vref_uv = regulator_get_voltage(reg);
 289 +       data->vref_mv = DIV_ROUND_CLOSEST(vref_uv, 1000);
 290 +
 291 +       data->hwmon_dev =
 292 +           devm_hwmon_device_register_with_groups(&pdev->dev,
 293 +                                                  "rp1_adc",
 294 +                                                  data,
 295 +                                                  rp1_adc_groups);
 296 +       if (IS_ERR(data->hwmon_dev)) {
 297 +               ret = PTR_ERR(data->hwmon_dev);
 298 +               dev_err(&pdev->dev, "hwmon_device_register failed with %d.\n", ret);
 299 +               goto err_register;
 300 +       }
 301 +
 302 +       /* Disable interrupts */
 303 +       writel(0, data->base + RP1_ADC_INTE);
 304 +
 305 +       /* Enable the block, clearing any sticky error */
 306 +       writel(RP1_ADC_CS_EN | RP1_ADC_CS_ERR_STICKY, data->base + RP1_ADC_CS);
 307 +
 308 +       return 0;
 309 +
 310 +err_register:
 311 +       sysfs_remove_group(&pdev->dev.kobj, &rp1_adc_group);
 312 +
 313 +       return ret;
 314 +}
 315 +
 316 +static int rp1_adc_remove(struct platform_device *pdev)
 317 +{
 318 +       struct rp1_adc_data *data = platform_get_drvdata(pdev);
 319 +
 320 +       hwmon_device_unregister(data->hwmon_dev);
 321 +
 322 +       return 0;
 323 +}
 324 +
 325 +static const struct of_device_id rp1_adc_dt_ids[] = {
 326 +       { .compatible = "raspberrypi,rp1-adc", },
 327 +       { }
 328 +};
 329 +MODULE_DEVICE_TABLE(of, rp1_adc_dt_ids);
 330 +
 331 +static struct platform_driver rp1_adc_driver = {
 332 +       .remove         = rp1_adc_remove,
 333 +       .driver         = {
 334 +               .name   = MODULE_NAME,
 335 +               .of_match_table = rp1_adc_dt_ids,
 336 +       },
 337 +};
 338 +
 339 +module_platform_driver_probe(rp1_adc_driver, rp1_adc_probe);
 340 +
 341 +MODULE_DESCRIPTION("RP1 ADC driver");
 342 +MODULE_AUTHOR("Phil Elwell <phil@raspberrypi.com>");
 343 +MODULE_LICENSE("GPL");