drivers/hwmon/adm1177.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * ADM1177 Hot Swap Controller and Digital Power Monitor with Soft Start Pin
   4  *
   5  * Copyright 2015-2019 Analog Devices Inc.
   6  */
   7
   8 #include <linux/bits.h>
   9 #include <linux/device.h>
  10 #include <linux/hwmon.h>
  11 #include <linux/i2c.h>
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/regulator/consumer.h>
  15
  16 /*  Command Byte Operations */
  17 #define ADM1177_CMD_V_CONT      BIT(0)
  18 #define ADM1177_CMD_I_CONT      BIT(2)
  19 #define ADM1177_CMD_VRANGE      BIT(4)
  20
  21 /* Extended Register */
  22 #define ADM1177_REG_ALERT_TH    2
  23
  24 #define ADM1177_BITS            12
  25
  26 /**
  27  * struct adm1177_state - driver instance specific data
  28  * @client:             pointer to i2c client
  29  * @reg:                regulator info for the power supply of the device
  30  * @r_sense_uohm:       current sense resistor value
  31  * @alert_threshold_ua: current limit for shutdown
  32  * @vrange_high:        internal voltage divider
  33  */
  34 struct adm1177_state {
  35         struct i2c_client       *client;
  36         struct regulator        *reg;
  37         u32                     r_sense_uohm;
  38         u32                     alert_threshold_ua;
  39         bool                    vrange_high;
  40 };
  41
  42 static int adm1177_read_raw(struct adm1177_state *st, u8 num, u8 *data)
  43 {
  44         return i2c_master_recv(st->client, data, num);
  45 }
  46
  47 static int adm1177_write_cmd(struct adm1177_state *st, u8 cmd)
  48 {
  49         return i2c_smbus_write_byte(st->client, cmd);
  50 }
  51
  52 static int adm1177_write_alert_thr(struct adm1177_state *st,
  53                                    u32 alert_threshold_ua)
  54 {
  55         u64 val;
  56         int ret;
  57
  58         val = 0xFFULL * alert_threshold_ua * st->r_sense_uohm;
  59         val = div_u64(val, 105840000U);
  60         val = div_u64(val, 1000U);
  61         if (val > 0xFF)
  62                 val = 0xFF;
  63
  64         ret = i2c_smbus_write_byte_data(st->client, ADM1177_REG_ALERT_TH,
  65                                         val);
  66         if (ret)
  67                 return ret;
  68
  69         st->alert_threshold_ua = alert_threshold_ua;
  70         return 0;
  71 }
  72
  73 static int adm1177_read(struct device *dev, enum hwmon_sensor_types type,
  74                         u32 attr, int channel, long *val)
  75 {
  76         struct adm1177_state *st = dev_get_drvdata(dev);
  77         u8 data[3];
  78         long dummy;
  79         int ret;
  80
  81         switch (type) {
  82         case hwmon_curr:
  83                 switch (attr) {
  84                 case hwmon_curr_input:
  85                         ret = adm1177_read_raw(st, 3, data);
  86                         if (ret < 0)
  87                                 return ret;
  88                         dummy = (data[1] << 4) | (data[2] & 0xF);
  89                         /*
  90                          * convert to milliamperes
  91                          * ((105.84mV / 4096) x raw) / senseResistor(ohm)
  92                          */
  93                         *val = div_u64((105840000ull * dummy),
  94                                        4096 * st->r_sense_uohm);
  95                         return 0;
  96                 case hwmon_curr_max_alarm:
  97                         *val = st->alert_threshold_ua;
  98                         return 0;
  99                 default:
 100                         return -EOPNOTSUPP;
 101                 }
 102         case hwmon_in:
 103                 ret = adm1177_read_raw(st, 3, data);
 104                 if (ret < 0)
 105                         return ret;
 106                 dummy = (data[0] << 4) | (data[2] >> 4);
 107                 /*
 108                  * convert to millivolts based on resistor devision
 109                  * (V_fullscale / 4096) * raw
 110                  */
 111                 if (st->vrange_high)
 112                         dummy *= 26350;
 113                 else
 114                         dummy *= 6650;
 115
 116                 *val = DIV_ROUND_CLOSEST(dummy, 4096);
 117                 return 0;
 118         default:
 119                 return -EOPNOTSUPP;
 120         }
 121 }
 122
 123 static int adm1177_write(struct device *dev, enum hwmon_sensor_types type,
 124                          u32 attr, int channel, long val)
 125 {
 126         struct adm1177_state *st = dev_get_drvdata(dev);
 127
 128         switch (type) {
 129         case hwmon_curr:
 130                 switch (attr) {
 131                 case hwmon_curr_max_alarm:
 132                         adm1177_write_alert_thr(st, val);
 133                         return 0;
 134                 default:
 135                         return -EOPNOTSUPP;
 136                 }
 137         default:
 138                 return -EOPNOTSUPP;
 139         }
 140 }
 141
 142 static umode_t adm1177_is_visible(const void *data,
 143                                   enum hwmon_sensor_types type,
 144                                   u32 attr, int channel)
 145 {
 146         const struct adm1177_state *st = data;
 147
 148         switch (type) {
 149         case hwmon_in:
 150                 switch (attr) {
 151                 case hwmon_in_input:
 152                         return 0444;
 153                 }
 154                 break;
 155         case hwmon_curr:
 156                 switch (attr) {
 157                 case hwmon_curr_input:
 158                         if (st->r_sense_uohm)
 159                                 return 0444;
 160                         return 0;
 161                 case hwmon_curr_max_alarm:
 162                         if (st->r_sense_uohm)
 163                                 return 0644;
 164                         return 0;
 165                 }
 166                 break;
 167         default:
 168                 break;
 169         }
 170         return 0;
 171 }
 172
 173 static const struct hwmon_channel_info *adm1177_info[] = {
 174         HWMON_CHANNEL_INFO(curr,
 175                            HWMON_C_INPUT | HWMON_C_MAX_ALARM),
 176         HWMON_CHANNEL_INFO(in,
 177                            HWMON_I_INPUT),
 178         NULL
 179 };
 180
 181 static const struct hwmon_ops adm1177_hwmon_ops = {
 182         .is_visible = adm1177_is_visible,
 183         .read = adm1177_read,
 184         .write = adm1177_write,
 185 };
 186
 187 static const struct hwmon_chip_info adm1177_chip_info = {
 188         .ops = &adm1177_hwmon_ops,
 189         .info = adm1177_info,
 190 };
 191
 192 static void adm1177_remove(void *data)
 193 {
 194         struct adm1177_state *st = data;
 195
 196         regulator_disable(st->reg);
 197 }
 198
 199 static int adm1177_probe(struct i2c_client *client)
 200 {
 201         struct device *dev = &client->dev;
 202         struct device *hwmon_dev;
 203         struct adm1177_state *st;
 204         u32 alert_threshold_ua;
 205         int ret;
 206
 207         st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL);
 208         if (!st)
 209                 return -ENOMEM;
 210
 211         st->client = client;
 212
 213         st->reg = devm_regulator_get_optional(&client->dev, "vref");
 214         if (IS_ERR(st->reg)) {
 215                 if (PTR_ERR(st->reg) == -EPROBE_DEFER)
 216                         return -EPROBE_DEFER;
 217
 218                 st->reg = NULL;
 219         } else {
 220                 ret = regulator_enable(st->reg);
 221                 if (ret)
 222                         return ret;
 223                 ret = devm_add_action_or_reset(&client->dev, adm1177_remove,
 224                                                st);
 225                 if (ret)
 226                         return ret;
 227         }
 228
 229         if (device_property_read_u32(dev, "shunt-resistor-micro-ohms",
 230                                      &st->r_sense_uohm))
 231                 st->r_sense_uohm = 0;
 232         if (device_property_read_u32(dev, "adi,shutdown-threshold-microamp",
 233                                      &alert_threshold_ua)) {
 234                 if (st->r_sense_uohm)
 235                         /*
 236                          * set maximum default value from datasheet based on
 237                          * shunt-resistor
 238                          */
 239                         alert_threshold_ua = div_u64(105840000000,
 240                                                      st->r_sense_uohm);
 241                 else
 242                         alert_threshold_ua = 0;
 243         }
 244         st->vrange_high = device_property_read_bool(dev,
 245                                                     "adi,vrange-high-enable");
 246         if (alert_threshold_ua && st->r_sense_uohm)
 247                 adm1177_write_alert_thr(st, alert_threshold_ua);
 248
 249         ret = adm1177_write_cmd(st, ADM1177_CMD_V_CONT |
 250                                     ADM1177_CMD_I_CONT |
 251                                     (st->vrange_high ? 0 : ADM1177_CMD_VRANGE));
 252         if (ret)
 253                 return ret;
 254
 255         hwmon_dev =
 256                 devm_hwmon_device_register_with_info(dev, client->name, st,
 257                                                      &adm1177_chip_info, NULL);
 258         return PTR_ERR_OR_ZERO(hwmon_dev);
 259 }
 260
 261 static const struct i2c_device_id adm1177_id[] = {
 262         {"adm1177", 0},
 263         {}
 264 };
 265 MODULE_DEVICE_TABLE(i2c, adm1177_id);
 266
 267 static const struct of_device_id adm1177_dt_ids[] = {
 268         { .compatible = "adi,adm1177" },
 269         {},
 270 };
 271 MODULE_DEVICE_TABLE(of, adm1177_dt_ids);
 272
 273 static struct i2c_driver adm1177_driver = {
 274         .class = I2C_CLASS_HWMON,
 275         .driver = {
 276                 .name = "adm1177",
 277                 .of_match_table = adm1177_dt_ids,
 278         },
 279         .probe_new = adm1177_probe,
 280         .id_table = adm1177_id,
 281 };
 282 module_i2c_driver(adm1177_driver);
 283
 284 MODULE_AUTHOR("Beniamin Bia <beniamin.bia@analog.com>");
 285 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
 286 MODULE_DESCRIPTION("Analog Devices ADM1177 ADC driver");
 287 MODULE_LICENSE("GPL v2");