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 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                          const struct i2c_device_id *id)
 201 {
 202         struct device *dev = &client->dev;
 203         struct device *hwmon_dev;
 204         struct adm1177_state *st;
 205         u32 alert_threshold_ua;
 206         int ret;
 207
 208         st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL);
 209         if (!st)
 210                 return -ENOMEM;
 211
 212         st->client = client;
 213
 214         st->reg = devm_regulator_get_optional(&client->dev, "vref");
 215         if (IS_ERR(st->reg)) {
 216                 if (PTR_ERR(st->reg) == -EPROBE_DEFER)
 217                         return -EPROBE_DEFER;
 218
 219                 st->reg = NULL;
 220         } else {
 221                 ret = regulator_enable(st->reg);
 222                 if (ret)
 223                         return ret;
 224                 ret = devm_add_action_or_reset(&client->dev, adm1177_remove,
 225                                                st);
 226                 if (ret)
 227                         return ret;
 228         }
 229
 230         if (device_property_read_u32(dev, "shunt-resistor-micro-ohms",
 231                                      &st->r_sense_uohm))
 232                 st->r_sense_uohm = 0;
 233         if (device_property_read_u32(dev, "adi,shutdown-threshold-microamp",
 234                                      &alert_threshold_ua)) {
 235                 if (st->r_sense_uohm)
 236                         /*
 237                          * set maximum default value from datasheet based on
 238                          * shunt-resistor
 239                          */
 240                         alert_threshold_ua = div_u64(105840000000,
 241                                                      st->r_sense_uohm);
 242                 else
 243                         alert_threshold_ua = 0;
 244         }
 245         st->vrange_high = device_property_read_bool(dev,
 246                                                     "adi,vrange-high-enable");
 247         if (alert_threshold_ua && st->r_sense_uohm)
 248                 adm1177_write_alert_thr(st, alert_threshold_ua);
 249
 250         ret = adm1177_write_cmd(st, ADM1177_CMD_V_CONT |
 251                                     ADM1177_CMD_I_CONT |
 252                                     (st->vrange_high ? 0 : ADM1177_CMD_VRANGE));
 253         if (ret)
 254                 return ret;
 255
 256         hwmon_dev =
 257                 devm_hwmon_device_register_with_info(dev, client->name, st,
 258                                                      &adm1177_chip_info, NULL);
 259         return PTR_ERR_OR_ZERO(hwmon_dev);
 260 }
 261
 262 static const struct i2c_device_id adm1177_id[] = {
 263         {"adm1177", 0},
 264         {}
 265 };
 266 MODULE_DEVICE_TABLE(i2c, adm1177_id);
 267
 268 static const struct of_device_id adm1177_dt_ids[] = {
 269         { .compatible = "adi,adm1177" },
 270         {},
 271 };
 272 MODULE_DEVICE_TABLE(of, adm1177_dt_ids);
 273
 274 static struct i2c_driver adm1177_driver = {
 275         .class = I2C_CLASS_HWMON,
 276         .driver = {
 277                 .name = "adm1177",
 278                 .of_match_table = adm1177_dt_ids,
 279         },
 280         .probe = adm1177_probe,
 281         .id_table = adm1177_id,
 282 };
 283 module_i2c_driver(adm1177_driver);
 284
 285 MODULE_AUTHOR("Beniamin Bia <beniamin.bia@analog.com>");
 286 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
 287 MODULE_DESCRIPTION("Analog Devices ADM1177 ADC driver");
 288 MODULE_LICENSE("GPL v2");