drivers/iio/temperature/mcp9600.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * mcp9600.c - Support for Microchip MCP9600 thermocouple EMF converter
   4  *
   5  * Copyright (c) 2022 Andrew Hepp
   6  * Author: <andrew.hepp@ahepp.dev>
   7  */
   8
   9 #include <linux/bitfield.h>
  10 #include <linux/bitops.h>
  11 #include <linux/bits.h>
  12 #include <linux/err.h>
  13 #include <linux/i2c.h>
  14 #include <linux/init.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/irq.h>
  17 #include <linux/math.h>
  18 #include <linux/minmax.h>
  19 #include <linux/mod_devicetable.h>
  20 #include <linux/module.h>
  21
  22 #include <linux/iio/events.h>
  23 #include <linux/iio/iio.h>
  24
  25 /* MCP9600 registers */
  26 #define MCP9600_HOT_JUNCTION 0x0
  27 #define MCP9600_COLD_JUNCTION 0x2
  28 #define MCP9600_STATUS                  0x4
  29 #define MCP9600_STATUS_ALERT(x)         BIT(x)
  30 #define MCP9600_ALERT_CFG1              0x8
  31 #define MCP9600_ALERT_CFG(x)            (MCP9600_ALERT_CFG1 + (x - 1))
  32 #define MCP9600_ALERT_CFG_ENABLE        BIT(0)
  33 #define MCP9600_ALERT_CFG_ACTIVE_HIGH   BIT(2)
  34 #define MCP9600_ALERT_CFG_FALLING       BIT(3)
  35 #define MCP9600_ALERT_CFG_COLD_JUNCTION BIT(4)
  36 #define MCP9600_ALERT_HYSTERESIS1       0xc
  37 #define MCP9600_ALERT_HYSTERESIS(x)     (MCP9600_ALERT_HYSTERESIS1 + (x - 1))
  38 #define MCP9600_ALERT_LIMIT1            0x10
  39 #define MCP9600_ALERT_LIMIT(x)          (MCP9600_ALERT_LIMIT1 + (x - 1))
  40 #define MCP9600_ALERT_LIMIT_MASK        GENMASK(15, 2)
  41 #define MCP9600_DEVICE_ID 0x20
  42
  43 /* MCP9600 device id value */
  44 #define MCP9600_DEVICE_ID_MCP9600 0x40
  45
  46 #define MCP9600_ALERT_COUNT             4
  47
  48 #define MCP9600_MIN_TEMP_HOT_JUNCTION_MICRO     -200000000
  49 #define MCP9600_MAX_TEMP_HOT_JUNCTION_MICRO     1800000000
  50
  51 #define MCP9600_MIN_TEMP_COLD_JUNCTION_MICRO    -40000000
  52 #define MCP9600_MAX_TEMP_COLD_JUNCTION_MICRO    125000000
  53
  54 enum mcp9600_alert {
  55         MCP9600_ALERT1,
  56         MCP9600_ALERT2,
  57         MCP9600_ALERT3,
  58         MCP9600_ALERT4
  59 };
  60
  61 static const char * const mcp9600_alert_name[MCP9600_ALERT_COUNT] = {
  62         [MCP9600_ALERT1] = "alert1",
  63         [MCP9600_ALERT2] = "alert2",
  64         [MCP9600_ALERT3] = "alert3",
  65         [MCP9600_ALERT4] = "alert4",
  66 };
  67
  68 static const struct iio_event_spec mcp9600_events[] = {
  69         {
  70                 .type = IIO_EV_TYPE_THRESH,
  71                 .dir = IIO_EV_DIR_RISING,
  72                 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
  73                                  BIT(IIO_EV_INFO_VALUE) |
  74                                  BIT(IIO_EV_INFO_HYSTERESIS),
  75         },
  76         {
  77                 .type = IIO_EV_TYPE_THRESH,
  78                 .dir = IIO_EV_DIR_FALLING,
  79                 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
  80                                  BIT(IIO_EV_INFO_VALUE) |
  81                                  BIT(IIO_EV_INFO_HYSTERESIS),
  82         },
  83 };
  84
  85 #define MCP9600_CHANNELS(hj_num_ev, hj_ev_spec_off, cj_num_ev, cj_ev_spec_off) \
  86         {                                                                      \
  87                 {                                                              \
  88                         .type = IIO_TEMP,                                      \
  89                         .address = MCP9600_HOT_JUNCTION,                       \
  90                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |         \
  91                                               BIT(IIO_CHAN_INFO_SCALE),        \
  92                         .event_spec = &mcp9600_events[hj_ev_spec_off],         \
  93                         .num_event_specs = hj_num_ev,                          \
  94                 },                                                             \
  95                 {                                                              \
  96                         .type = IIO_TEMP,                                      \
  97                         .address = MCP9600_COLD_JUNCTION,                      \
  98                         .channel2 = IIO_MOD_TEMP_AMBIENT,                      \
  99                         .modified = 1,                                         \
 100                         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |         \
 101                                               BIT(IIO_CHAN_INFO_SCALE),        \
 102                         .event_spec = &mcp9600_events[cj_ev_spec_off],         \
 103                         .num_event_specs = cj_num_ev,                          \
 104                 },                                                             \
 105         }
 106
 107 static const struct iio_chan_spec mcp9600_channels[][2] = {
 108         MCP9600_CHANNELS(0, 0, 0, 0), /* Alerts: - - - - */
 109         MCP9600_CHANNELS(1, 0, 0, 0), /* Alerts: 1 - - - */
 110         MCP9600_CHANNELS(1, 1, 0, 0), /* Alerts: - 2 - - */
 111         MCP9600_CHANNELS(2, 0, 0, 0), /* Alerts: 1 2 - - */
 112         MCP9600_CHANNELS(0, 0, 1, 0), /* Alerts: - - 3 - */
 113         MCP9600_CHANNELS(1, 0, 1, 0), /* Alerts: 1 - 3 - */
 114         MCP9600_CHANNELS(1, 1, 1, 0), /* Alerts: - 2 3 - */
 115         MCP9600_CHANNELS(2, 0, 1, 0), /* Alerts: 1 2 3 - */
 116         MCP9600_CHANNELS(0, 0, 1, 1), /* Alerts: - - - 4 */
 117         MCP9600_CHANNELS(1, 0, 1, 1), /* Alerts: 1 - - 4 */
 118         MCP9600_CHANNELS(1, 1, 1, 1), /* Alerts: - 2 - 4 */
 119         MCP9600_CHANNELS(2, 0, 1, 1), /* Alerts: 1 2 - 4 */
 120         MCP9600_CHANNELS(0, 0, 2, 0), /* Alerts: - - 3 4 */
 121         MCP9600_CHANNELS(1, 0, 2, 0), /* Alerts: 1 - 3 4 */
 122         MCP9600_CHANNELS(1, 1, 2, 0), /* Alerts: - 2 3 4 */
 123         MCP9600_CHANNELS(2, 0, 2, 0), /* Alerts: 1 2 3 4 */
 124 };
 125
 126 struct mcp9600_data {
 127         struct i2c_client *client;
 128 };
 129
 130 static int mcp9600_read(struct mcp9600_data *data,
 131                         struct iio_chan_spec const *chan, int *val)
 132 {
 133         int ret;
 134
 135         ret = i2c_smbus_read_word_swapped(data->client, chan->address);
 136
 137         if (ret < 0)
 138                 return ret;
 139
 140         *val = sign_extend32(ret, 15);
 141
 142         return 0;
 143 }
 144
 145 static int mcp9600_read_raw(struct iio_dev *indio_dev,
 146                             struct iio_chan_spec const *chan, int *val,
 147                             int *val2, long mask)
 148 {
 149         struct mcp9600_data *data = iio_priv(indio_dev);
 150         int ret;
 151
 152         switch (mask) {
 153         case IIO_CHAN_INFO_RAW:
 154                 ret = mcp9600_read(data, chan, val);
 155                 if (ret)
 156                         return ret;
 157                 return IIO_VAL_INT;
 158         case IIO_CHAN_INFO_SCALE:
 159                 *val = 62;
 160                 *val2 = 500000;
 161                 return IIO_VAL_INT_PLUS_MICRO;
 162         default:
 163                 return -EINVAL;
 164         }
 165 }
 166
 167 static int mcp9600_get_alert_index(int channel2, enum iio_event_direction dir)
 168 {
 169         if (channel2 == IIO_MOD_TEMP_AMBIENT) {
 170                 if (dir == IIO_EV_DIR_RISING)
 171                         return MCP9600_ALERT3;
 172                 else
 173                         return MCP9600_ALERT4;
 174         } else {
 175                 if (dir == IIO_EV_DIR_RISING)
 176                         return MCP9600_ALERT1;
 177                 else
 178                         return MCP9600_ALERT2;
 179         }
 180 }
 181
 182 static int mcp9600_read_event_config(struct iio_dev *indio_dev,
 183                                      const struct iio_chan_spec *chan,
 184                                      enum iio_event_type type,
 185                                      enum iio_event_direction dir)
 186 {
 187         struct mcp9600_data *data = iio_priv(indio_dev);
 188         struct i2c_client *client = data->client;
 189         int i, ret;
 190
 191         i = mcp9600_get_alert_index(chan->channel2, dir);
 192         ret = i2c_smbus_read_byte_data(client, MCP9600_ALERT_CFG(i + 1));
 193         if (ret < 0)
 194                 return ret;
 195
 196         return FIELD_GET(MCP9600_ALERT_CFG_ENABLE, ret);
 197 }
 198
 199 static int mcp9600_write_event_config(struct iio_dev *indio_dev,
 200                                       const struct iio_chan_spec *chan,
 201                                       enum iio_event_type type,
 202                                       enum iio_event_direction dir,
 203                                       int state)
 204 {
 205         struct mcp9600_data *data = iio_priv(indio_dev);
 206         struct i2c_client *client = data->client;
 207         int i, ret;
 208
 209         i = mcp9600_get_alert_index(chan->channel2, dir);
 210         ret = i2c_smbus_read_byte_data(client, MCP9600_ALERT_CFG(i + 1));
 211         if (ret < 0)
 212                 return ret;
 213
 214         if (state)
 215                 ret |= MCP9600_ALERT_CFG_ENABLE;
 216         else
 217                 ret &= ~MCP9600_ALERT_CFG_ENABLE;
 218
 219         return i2c_smbus_write_byte_data(client, MCP9600_ALERT_CFG(i + 1), ret);
 220 }
 221
 222 static int mcp9600_read_thresh(struct iio_dev *indio_dev,
 223                                const struct iio_chan_spec *chan,
 224                                enum iio_event_type type,
 225                                enum iio_event_direction dir,
 226                                enum iio_event_info info, int *val, int *val2)
 227 {
 228         struct mcp9600_data *data = iio_priv(indio_dev);
 229         struct i2c_client *client = data->client;
 230         s32 ret;
 231         int i;
 232
 233         i = mcp9600_get_alert_index(chan->channel2, dir);
 234         switch (info) {
 235         case IIO_EV_INFO_VALUE:
 236                 ret = i2c_smbus_read_word_swapped(client, MCP9600_ALERT_LIMIT(i + 1));
 237                 if (ret < 0)
 238                         return ret;
 239                 /*
 240                  * Temperature is stored in two’s complement format in
 241                  * bits(15:2), LSB is 0.25 degree celsius.
 242                  */
 243                 *val = sign_extend32(FIELD_GET(MCP9600_ALERT_LIMIT_MASK, ret), 13);
 244                 *val2 = 4;
 245                 return IIO_VAL_FRACTIONAL;
 246         case IIO_EV_INFO_HYSTERESIS:
 247                 ret = i2c_smbus_read_byte_data(client, MCP9600_ALERT_HYSTERESIS(i + 1));
 248                 if (ret < 0)
 249                         return ret;
 250
 251                 *val = ret;
 252                 return IIO_VAL_INT;
 253         default:
 254                 return -EINVAL;
 255         }
 256 }
 257
 258 static int mcp9600_write_thresh(struct iio_dev *indio_dev,
 259                                 const struct iio_chan_spec *chan,
 260                                 enum iio_event_type type,
 261                                 enum iio_event_direction dir,
 262                                 enum iio_event_info info, int val, int val2)
 263 {
 264         struct mcp9600_data *data = iio_priv(indio_dev);
 265         struct i2c_client *client = data->client;
 266         int s_val, i;
 267         s16 thresh;
 268         u8 hyst;
 269
 270         i = mcp9600_get_alert_index(chan->channel2, dir);
 271         switch (info) {
 272         case IIO_EV_INFO_VALUE:
 273                 /* Scale value to include decimal part into calculations */
 274                 s_val = (val < 0) ? ((val * 1000000) - val2) :
 275                                     ((val * 1000000) + val2);
 276                 if (chan->channel2 == IIO_MOD_TEMP_AMBIENT) {
 277                         s_val = max(s_val, MCP9600_MIN_TEMP_COLD_JUNCTION_MICRO);
 278                         s_val = min(s_val, MCP9600_MAX_TEMP_COLD_JUNCTION_MICRO);
 279                 } else {
 280                         s_val = max(s_val, MCP9600_MIN_TEMP_HOT_JUNCTION_MICRO);
 281                         s_val = min(s_val, MCP9600_MAX_TEMP_HOT_JUNCTION_MICRO);
 282                 }
 283
 284                 /*
 285                  * Shift length 4 bits = 2(15:2) + 2(0.25 LSB), temperature is
 286                  * stored in two’s complement format.
 287                  */
 288                 thresh = (s16)(s_val / (1000000 >> 4));
 289                 return i2c_smbus_write_word_swapped(client,
 290                                                     MCP9600_ALERT_LIMIT(i + 1),
 291                                                     thresh);
 292         case IIO_EV_INFO_HYSTERESIS:
 293                 hyst = min(abs(val), 255);
 294                 return i2c_smbus_write_byte_data(client,
 295                                                  MCP9600_ALERT_HYSTERESIS(i + 1),
 296                                                  hyst);
 297         default:
 298                 return -EINVAL;
 299         }
 300 }
 301
 302 static const struct iio_info mcp9600_info = {
 303         .read_raw = mcp9600_read_raw,
 304         .read_event_config = mcp9600_read_event_config,
 305         .write_event_config = mcp9600_write_event_config,
 306         .read_event_value = mcp9600_read_thresh,
 307         .write_event_value = mcp9600_write_thresh,
 308 };
 309
 310 static irqreturn_t mcp9600_alert_handler(void *private,
 311                                          enum mcp9600_alert alert,
 312                                          enum iio_modifier mod,
 313                                          enum iio_event_direction dir)
 314 {
 315         struct iio_dev *indio_dev = private;
 316         struct mcp9600_data *data = iio_priv(indio_dev);
 317         int ret;
 318
 319         ret = i2c_smbus_read_byte_data(data->client, MCP9600_STATUS);
 320         if (ret < 0)
 321                 return IRQ_HANDLED;
 322
 323         if (!(ret & MCP9600_STATUS_ALERT(alert)))
 324                 return IRQ_NONE;
 325
 326         iio_push_event(indio_dev,
 327                        IIO_MOD_EVENT_CODE(IIO_TEMP, 0, mod, IIO_EV_TYPE_THRESH,
 328                                           dir),
 329                        iio_get_time_ns(indio_dev));
 330
 331         return IRQ_HANDLED;
 332 }
 333
 334 static irqreturn_t mcp9600_alert1_handler(int irq, void *private)
 335 {
 336         return mcp9600_alert_handler(private, MCP9600_ALERT1, IIO_NO_MOD,
 337                                      IIO_EV_DIR_RISING);
 338 }
 339
 340 static irqreturn_t mcp9600_alert2_handler(int irq, void *private)
 341 {
 342         return mcp9600_alert_handler(private, MCP9600_ALERT2, IIO_NO_MOD,
 343                                      IIO_EV_DIR_FALLING);
 344 }
 345
 346 static irqreturn_t mcp9600_alert3_handler(int irq, void *private)
 347 {
 348         return mcp9600_alert_handler(private, MCP9600_ALERT3,
 349                                      IIO_MOD_TEMP_AMBIENT, IIO_EV_DIR_RISING);
 350 }
 351
 352 static irqreturn_t mcp9600_alert4_handler(int irq, void *private)
 353 {
 354         return mcp9600_alert_handler(private, MCP9600_ALERT4,
 355                                      IIO_MOD_TEMP_AMBIENT, IIO_EV_DIR_FALLING);
 356 }
 357
 358 static irqreturn_t (*mcp9600_alert_handler_func[MCP9600_ALERT_COUNT]) (int, void *) = {
 359         mcp9600_alert1_handler,
 360         mcp9600_alert2_handler,
 361         mcp9600_alert3_handler,
 362         mcp9600_alert4_handler,
 363 };
 364
 365 static int mcp9600_probe_alerts(struct iio_dev *indio_dev)
 366 {
 367         struct mcp9600_data *data = iio_priv(indio_dev);
 368         struct i2c_client *client = data->client;
 369         struct device *dev = &client->dev;
 370         struct fwnode_handle *fwnode = dev_fwnode(dev);
 371         unsigned int irq_type;
 372         int ret, irq, i;
 373         u8 val, ch_sel;
 374
 375         /*
 376          * alert1: hot junction, rising temperature
 377          * alert2: hot junction, falling temperature
 378          * alert3: cold junction, rising temperature
 379          * alert4: cold junction, falling temperature
 380          */
 381         ch_sel = 0;
 382         for (i = 0; i < MCP9600_ALERT_COUNT; i++) {
 383                 irq = fwnode_irq_get_byname(fwnode, mcp9600_alert_name[i]);
 384                 if (irq <= 0)
 385                         continue;
 386
 387                 val = 0;
 388                 irq_type = irq_get_trigger_type(irq);
 389                 if (irq_type == IRQ_TYPE_EDGE_RISING)
 390                         val |= MCP9600_ALERT_CFG_ACTIVE_HIGH;
 391
 392                 if (i == MCP9600_ALERT2 || i == MCP9600_ALERT4)
 393                         val |= MCP9600_ALERT_CFG_FALLING;
 394
 395                 if (i == MCP9600_ALERT3 || i == MCP9600_ALERT4)
 396                         val |= MCP9600_ALERT_CFG_COLD_JUNCTION;
 397
 398                 ret = i2c_smbus_write_byte_data(client,
 399                                                 MCP9600_ALERT_CFG(i + 1),
 400                                                 val);
 401                 if (ret < 0)
 402                         return ret;
 403
 404                 ret = devm_request_threaded_irq(dev, irq, NULL,
 405                                                 mcp9600_alert_handler_func[i],
 406                                                 IRQF_ONESHOT, "mcp9600",
 407                                                 indio_dev);
 408                 if (ret)
 409                         return ret;
 410
 411                 ch_sel |= BIT(i);
 412         }
 413
 414         return ch_sel;
 415 }
 416
 417 static int mcp9600_probe(struct i2c_client *client)
 418 {
 419         struct iio_dev *indio_dev;
 420         struct mcp9600_data *data;
 421         int ret, ch_sel;
 422
 423         ret = i2c_smbus_read_byte_data(client, MCP9600_DEVICE_ID);
 424         if (ret < 0)
 425                 return dev_err_probe(&client->dev, ret, "Failed to read device ID\n");
 426         if (ret != MCP9600_DEVICE_ID_MCP9600)
 427                 dev_warn(&client->dev, "Expected ID %x, got %x\n",
 428                                 MCP9600_DEVICE_ID_MCP9600, ret);
 429
 430         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 431         if (!indio_dev)
 432                 return -ENOMEM;
 433
 434         data = iio_priv(indio_dev);
 435         data->client = client;
 436
 437         ch_sel = mcp9600_probe_alerts(indio_dev);
 438         if (ch_sel < 0)
 439                 return ch_sel;
 440
 441         indio_dev->info = &mcp9600_info;
 442         indio_dev->name = "mcp9600";
 443         indio_dev->modes = INDIO_DIRECT_MODE;
 444         indio_dev->channels = mcp9600_channels[ch_sel];
 445         indio_dev->num_channels = ARRAY_SIZE(mcp9600_channels[ch_sel]);
 446
 447         return devm_iio_device_register(&client->dev, indio_dev);
 448 }
 449
 450 static const struct i2c_device_id mcp9600_id[] = {
 451         { "mcp9600" },
 452         {}
 453 };
 454 MODULE_DEVICE_TABLE(i2c, mcp9600_id);
 455
 456 static const struct of_device_id mcp9600_of_match[] = {
 457         { .compatible = "microchip,mcp9600" },
 458         {}
 459 };
 460 MODULE_DEVICE_TABLE(of, mcp9600_of_match);
 461
 462 static struct i2c_driver mcp9600_driver = {
 463         .driver = {
 464                 .name = "mcp9600",
 465                 .of_match_table = mcp9600_of_match,
 466         },
 467         .probe = mcp9600_probe,
 468         .id_table = mcp9600_id
 469 };
 470 module_i2c_driver(mcp9600_driver);
 471
 472 MODULE_AUTHOR("Dimitri Fedrau <dima.fedrau@gmail.com>");
 473 MODULE_AUTHOR("Andrew Hepp <andrew.hepp@ahepp.dev>");
 474 MODULE_DESCRIPTION("Microchip MCP9600 thermocouple EMF converter driver");
 475 MODULE_LICENSE("GPL");