drivers/hwmon/bt1-pvt.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2020 BAIKAL ELECTRONICS, JSC
   4  *
   5  * Authors:
   6  *   Maxim Kaurkin <maxim.kaurkin@baikalelectronics.ru>
   7  *   Serge Semin <Sergey.Semin@baikalelectronics.ru>
   8  *
   9  * Baikal-T1 Process, Voltage, Temperature sensor driver
  10  */
  11
  12 #include <linux/bitfield.h>
  13 #include <linux/bitops.h>
  14 #include <linux/clk.h>
  15 #include <linux/completion.h>
  16 #include <linux/delay.h>
  17 #include <linux/device.h>
  18 #include <linux/hwmon-sysfs.h>
  19 #include <linux/hwmon.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/io.h>
  22 #include <linux/kernel.h>
  23 #include <linux/ktime.h>
  24 #include <linux/limits.h>
  25 #include <linux/module.h>
  26 #include <linux/mutex.h>
  27 #include <linux/of.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/polynomial.h>
  30 #include <linux/seqlock.h>
  31 #include <linux/sysfs.h>
  32 #include <linux/types.h>
  33
  34 #include "bt1-pvt.h"
  35
  36 /*
  37  * For the sake of the code simplification we created the sensors info table
  38  * with the sensor names, activation modes, threshold registers base address
  39  * and the thresholds bit fields.
  40  */
  41 static const struct pvt_sensor_info pvt_info[] = {
  42         PVT_SENSOR_INFO(0, "CPU Core Temperature", hwmon_temp, TEMP, TTHRES),
  43         PVT_SENSOR_INFO(0, "CPU Core Voltage", hwmon_in, VOLT, VTHRES),
  44         PVT_SENSOR_INFO(1, "CPU Core Low-Vt", hwmon_in, LVT, LTHRES),
  45         PVT_SENSOR_INFO(2, "CPU Core High-Vt", hwmon_in, HVT, HTHRES),
  46         PVT_SENSOR_INFO(3, "CPU Core Standard-Vt", hwmon_in, SVT, STHRES),
  47 };
  48
  49 /*
  50  * The original translation formulae of the temperature (in degrees of Celsius)
  51  * to PVT data and vice-versa are following:
  52  * N = 1.8322e-8*(T^4) + 2.343e-5*(T^3) + 8.7018e-3*(T^2) + 3.9269*(T^1) +
  53  *     1.7204e2,
  54  * T = -1.6743e-11*(N^4) + 8.1542e-8*(N^3) + -1.8201e-4*(N^2) +
  55  *     3.1020e-1*(N^1) - 4.838e1,
  56  * where T = [-48.380, 147.438]C and N = [0, 1023].
  57  * They must be accordingly altered to be suitable for the integer arithmetics.
  58  * The technique is called 'factor redistribution', which just makes sure the
  59  * multiplications and divisions are made so to have a result of the operations
  60  * within the integer numbers limit. In addition we need to translate the
  61  * formulae to accept millidegrees of Celsius. Here what they look like after
  62  * the alterations:
  63  * N = (18322e-20*(T^4) + 2343e-13*(T^3) + 87018e-9*(T^2) + 39269e-3*T +
  64  *     17204e2) / 1e4,
  65  * T = -16743e-12*(D^4) + 81542e-9*(D^3) - 182010e-6*(D^2) + 310200e-3*D -
  66  *     48380,
  67  * where T = [-48380, 147438] mC and N = [0, 1023].
  68  */
  69 static const struct polynomial __maybe_unused poly_temp_to_N = {
  70         .total_divider = 10000,
  71         .terms = {
  72                 {4, 18322, 10000, 10000},
  73                 {3, 2343, 10000, 10},
  74                 {2, 87018, 10000, 10},
  75                 {1, 39269, 1000, 1},
  76                 {0, 1720400, 1, 1}
  77         }
  78 };
  79
  80 static const struct polynomial poly_N_to_temp = {
  81         .total_divider = 1,
  82         .terms = {
  83                 {4, -16743, 1000, 1},
  84                 {3, 81542, 1000, 1},
  85                 {2, -182010, 1000, 1},
  86                 {1, 310200, 1000, 1},
  87                 {0, -48380, 1, 1}
  88         }
  89 };
  90
  91 /*
  92  * Similar alterations are performed for the voltage conversion equations.
  93  * The original formulae are:
  94  * N = 1.8658e3*V - 1.1572e3,
  95  * V = (N + 1.1572e3) / 1.8658e3,
  96  * where V = [0.620, 1.168] V and N = [0, 1023].
  97  * After the optimization they looks as follows:
  98  * N = (18658e-3*V - 11572) / 10,
  99  * V = N * 10^5 / 18658 + 11572 * 10^4 / 18658.
 100  */
 101 static const struct polynomial __maybe_unused poly_volt_to_N = {
 102         .total_divider = 10,
 103         .terms = {
 104                 {1, 18658, 1000, 1},
 105                 {0, -11572, 1, 1}
 106         }
 107 };
 108
 109 static const struct polynomial poly_N_to_volt = {
 110         .total_divider = 10,
 111         .terms = {
 112                 {1, 100000, 18658, 1},
 113                 {0, 115720000, 1, 18658}
 114         }
 115 };
 116
 117 static inline u32 pvt_update(void __iomem *reg, u32 mask, u32 data)
 118 {
 119         u32 old;
 120
 121         old = readl_relaxed(reg);
 122         writel((old & ~mask) | (data & mask), reg);
 123
 124         return old & mask;
 125 }
 126
 127 /*
 128  * Baikal-T1 PVT mode can be updated only when the controller is disabled.
 129  * So first we disable it, then set the new mode together with the controller
 130  * getting back enabled. The same concerns the temperature trim and
 131  * measurements timeout. If it is necessary the interface mutex is supposed
 132  * to be locked at the time the operations are performed.
 133  */
 134 static inline void pvt_set_mode(struct pvt_hwmon *pvt, u32 mode)
 135 {
 136         u32 old;
 137
 138         mode = FIELD_PREP(PVT_CTRL_MODE_MASK, mode);
 139
 140         old = pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
 141         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_MODE_MASK | PVT_CTRL_EN,
 142                    mode | old);
 143 }
 144
 145 static inline u32 pvt_calc_trim(long temp)
 146 {
 147         temp = clamp_val(temp, 0, PVT_TRIM_TEMP);
 148
 149         return DIV_ROUND_UP(temp, PVT_TRIM_STEP);
 150 }
 151
 152 static inline void pvt_set_trim(struct pvt_hwmon *pvt, u32 trim)
 153 {
 154         u32 old;
 155
 156         trim = FIELD_PREP(PVT_CTRL_TRIM_MASK, trim);
 157
 158         old = pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
 159         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_TRIM_MASK | PVT_CTRL_EN,
 160                    trim | old);
 161 }
 162
 163 static inline void pvt_set_tout(struct pvt_hwmon *pvt, u32 tout)
 164 {
 165         u32 old;
 166
 167         old = pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
 168         writel(tout, pvt->regs + PVT_TTIMEOUT);
 169         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, old);
 170 }
 171
 172 /*
 173  * This driver can optionally provide the hwmon alarms for each sensor the PVT
 174  * controller supports. The alarms functionality is made compile-time
 175  * configurable due to the hardware interface implementation peculiarity
 176  * described further in this comment. So in case if alarms are unnecessary in
 177  * your system design it's recommended to have them disabled to prevent the PVT
 178  * IRQs being periodically raised to get the data cache/alarms status up to
 179  * date.
 180  *
 181  * Baikal-T1 PVT embedded controller is based on the Analog Bits PVT sensor,
 182  * but is equipped with a dedicated control wrapper. It exposes the PVT
 183  * sub-block registers space via the APB3 bus. In addition the wrapper provides
 184  * a common interrupt vector of the sensors conversion completion events and
 185  * threshold value alarms. Alas the wrapper interface hasn't been fully thought
 186  * through. There is only one sensor can be activated at a time, for which the
 187  * thresholds comparator is enabled right after the data conversion is
 188  * completed. Due to this if alarms need to be implemented for all available
 189  * sensors we can't just set the thresholds and enable the interrupts. We need
 190  * to enable the sensors one after another and let the controller to detect
 191  * the alarms by itself at each conversion. This also makes pointless to handle
 192  * the alarms interrupts, since in occasion they happen synchronously with
 193  * data conversion completion. The best driver design would be to have the
 194  * completion interrupts enabled only and keep the converted value in the
 195  * driver data cache. This solution is implemented if hwmon alarms are enabled
 196  * in this driver. In case if the alarms are disabled, the conversion is
 197  * performed on demand at the time a sensors input file is read.
 198  */
 199
 200 #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
 201
 202 #define pvt_hard_isr NULL
 203
 204 static irqreturn_t pvt_soft_isr(int irq, void *data)
 205 {
 206         const struct pvt_sensor_info *info;
 207         struct pvt_hwmon *pvt = data;
 208         struct pvt_cache *cache;
 209         u32 val, thres_sts, old;
 210
 211         /*
 212          * DVALID bit will be cleared by reading the data. We need to save the
 213          * status before the next conversion happens. Threshold events will be
 214          * handled a bit later.
 215          */
 216         thres_sts = readl(pvt->regs + PVT_RAW_INTR_STAT);
 217
 218         /*
 219          * Then lets recharge the PVT interface with the next sampling mode.
 220          * Lock the interface mutex to serialize trim, timeouts and alarm
 221          * thresholds settings.
 222          */
 223         cache = &pvt->cache[pvt->sensor];
 224         info = &pvt_info[pvt->sensor];
 225         pvt->sensor = (pvt->sensor == PVT_SENSOR_LAST) ?
 226                       PVT_SENSOR_FIRST : (pvt->sensor + 1);
 227
 228         /*
 229          * For some reason we have to mask the interrupt before changing the
 230          * mode, otherwise sometimes the temperature mode doesn't get
 231          * activated even though the actual mode in the ctrl register
 232          * corresponds to one. Then we read the data. By doing so we also
 233          * recharge the data conversion. After this the mode corresponding
 234          * to the next sensor in the row is set. Finally we enable the
 235          * interrupts back.
 236          */
 237         mutex_lock(&pvt->iface_mtx);
 238
 239         old = pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID,
 240                          PVT_INTR_DVALID);
 241
 242         val = readl(pvt->regs + PVT_DATA);
 243
 244         pvt_set_mode(pvt, pvt_info[pvt->sensor].mode);
 245
 246         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, old);
 247
 248         mutex_unlock(&pvt->iface_mtx);
 249
 250         /*
 251          * We can now update the data cache with data just retrieved from the
 252          * sensor. Lock write-seqlock to make sure the reader has a coherent
 253          * data.
 254          */
 255         write_seqlock(&cache->data_seqlock);
 256
 257         cache->data = FIELD_GET(PVT_DATA_DATA_MASK, val);
 258
 259         write_sequnlock(&cache->data_seqlock);
 260
 261         /*
 262          * While PVT core is doing the next mode data conversion, we'll check
 263          * whether the alarms were triggered for the current sensor. Note that
 264          * according to the documentation only one threshold IRQ status can be
 265          * set at a time, that's why if-else statement is utilized.
 266          */
 267         if ((thres_sts & info->thres_sts_lo) ^ cache->thres_sts_lo) {
 268                 WRITE_ONCE(cache->thres_sts_lo, thres_sts & info->thres_sts_lo);
 269                 hwmon_notify_event(pvt->hwmon, info->type, info->attr_min_alarm,
 270                                    info->channel);
 271         } else if ((thres_sts & info->thres_sts_hi) ^ cache->thres_sts_hi) {
 272                 WRITE_ONCE(cache->thres_sts_hi, thres_sts & info->thres_sts_hi);
 273                 hwmon_notify_event(pvt->hwmon, info->type, info->attr_max_alarm,
 274                                    info->channel);
 275         }
 276
 277         return IRQ_HANDLED;
 278 }
 279
 280 static inline umode_t pvt_limit_is_visible(enum pvt_sensor_type type)
 281 {
 282         return 0644;
 283 }
 284
 285 static inline umode_t pvt_alarm_is_visible(enum pvt_sensor_type type)
 286 {
 287         return 0444;
 288 }
 289
 290 static int pvt_read_data(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 291                          long *val)
 292 {
 293         struct pvt_cache *cache = &pvt->cache[type];
 294         unsigned int seq;
 295         u32 data;
 296
 297         do {
 298                 seq = read_seqbegin(&cache->data_seqlock);
 299                 data = cache->data;
 300         } while (read_seqretry(&cache->data_seqlock, seq));
 301
 302         if (type == PVT_TEMP)
 303                 *val = polynomial_calc(&poly_N_to_temp, data);
 304         else
 305                 *val = polynomial_calc(&poly_N_to_volt, data);
 306
 307         return 0;
 308 }
 309
 310 static int pvt_read_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 311                           bool is_low, long *val)
 312 {
 313         u32 data;
 314
 315         /* No need in serialization, since it is just read from MMIO. */
 316         data = readl(pvt->regs + pvt_info[type].thres_base);
 317
 318         if (is_low)
 319                 data = FIELD_GET(PVT_THRES_LO_MASK, data);
 320         else
 321                 data = FIELD_GET(PVT_THRES_HI_MASK, data);
 322
 323         if (type == PVT_TEMP)
 324                 *val = polynomial_calc(&poly_N_to_temp, data);
 325         else
 326                 *val = polynomial_calc(&poly_N_to_volt, data);
 327
 328         return 0;
 329 }
 330
 331 static int pvt_write_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 332                            bool is_low, long val)
 333 {
 334         u32 data, limit, mask;
 335         int ret;
 336
 337         if (type == PVT_TEMP) {
 338                 val = clamp(val, PVT_TEMP_MIN, PVT_TEMP_MAX);
 339                 data = polynomial_calc(&poly_temp_to_N, val);
 340         } else {
 341                 val = clamp(val, PVT_VOLT_MIN, PVT_VOLT_MAX);
 342                 data = polynomial_calc(&poly_volt_to_N, val);
 343         }
 344
 345         /* Serialize limit update, since a part of the register is changed. */
 346         ret = mutex_lock_interruptible(&pvt->iface_mtx);
 347         if (ret)
 348                 return ret;
 349
 350         /* Make sure the upper and lower ranges don't intersect. */
 351         limit = readl(pvt->regs + pvt_info[type].thres_base);
 352         if (is_low) {
 353                 limit = FIELD_GET(PVT_THRES_HI_MASK, limit);
 354                 data = clamp_val(data, PVT_DATA_MIN, limit);
 355                 data = FIELD_PREP(PVT_THRES_LO_MASK, data);
 356                 mask = PVT_THRES_LO_MASK;
 357         } else {
 358                 limit = FIELD_GET(PVT_THRES_LO_MASK, limit);
 359                 data = clamp_val(data, limit, PVT_DATA_MAX);
 360                 data = FIELD_PREP(PVT_THRES_HI_MASK, data);
 361                 mask = PVT_THRES_HI_MASK;
 362         }
 363
 364         pvt_update(pvt->regs + pvt_info[type].thres_base, mask, data);
 365
 366         mutex_unlock(&pvt->iface_mtx);
 367
 368         return 0;
 369 }
 370
 371 static int pvt_read_alarm(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 372                           bool is_low, long *val)
 373 {
 374         if (is_low)
 375                 *val = !!READ_ONCE(pvt->cache[type].thres_sts_lo);
 376         else
 377                 *val = !!READ_ONCE(pvt->cache[type].thres_sts_hi);
 378
 379         return 0;
 380 }
 381
 382 static const struct hwmon_channel_info *pvt_channel_info[] = {
 383         HWMON_CHANNEL_INFO(chip,
 384                            HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
 385         HWMON_CHANNEL_INFO(temp,
 386                            HWMON_T_INPUT | HWMON_T_TYPE | HWMON_T_LABEL |
 387                            HWMON_T_MIN | HWMON_T_MIN_ALARM |
 388                            HWMON_T_MAX | HWMON_T_MAX_ALARM |
 389                            HWMON_T_OFFSET),
 390         HWMON_CHANNEL_INFO(in,
 391                            HWMON_I_INPUT | HWMON_I_LABEL |
 392                            HWMON_I_MIN | HWMON_I_MIN_ALARM |
 393                            HWMON_I_MAX | HWMON_I_MAX_ALARM,
 394                            HWMON_I_INPUT | HWMON_I_LABEL |
 395                            HWMON_I_MIN | HWMON_I_MIN_ALARM |
 396                            HWMON_I_MAX | HWMON_I_MAX_ALARM,
 397                            HWMON_I_INPUT | HWMON_I_LABEL |
 398                            HWMON_I_MIN | HWMON_I_MIN_ALARM |
 399                            HWMON_I_MAX | HWMON_I_MAX_ALARM,
 400                            HWMON_I_INPUT | HWMON_I_LABEL |
 401                            HWMON_I_MIN | HWMON_I_MIN_ALARM |
 402                            HWMON_I_MAX | HWMON_I_MAX_ALARM),
 403         NULL
 404 };
 405
 406 #else /* !CONFIG_SENSORS_BT1_PVT_ALARMS */
 407
 408 static irqreturn_t pvt_hard_isr(int irq, void *data)
 409 {
 410         struct pvt_hwmon *pvt = data;
 411         struct pvt_cache *cache;
 412         u32 val;
 413
 414         /*
 415          * Mask the DVALID interrupt so after exiting from the handler a
 416          * repeated conversion wouldn't happen.
 417          */
 418         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID,
 419                    PVT_INTR_DVALID);
 420
 421         /*
 422          * Nothing special for alarm-less driver. Just read the data, update
 423          * the cache and notify a waiter of this event.
 424          */
 425         val = readl(pvt->regs + PVT_DATA);
 426         if (!(val & PVT_DATA_VALID)) {
 427                 dev_err(pvt->dev, "Got IRQ when data isn't valid\n");
 428                 return IRQ_HANDLED;
 429         }
 430
 431         cache = &pvt->cache[pvt->sensor];
 432
 433         WRITE_ONCE(cache->data, FIELD_GET(PVT_DATA_DATA_MASK, val));
 434
 435         complete(&cache->conversion);
 436
 437         return IRQ_HANDLED;
 438 }
 439
 440 #define pvt_soft_isr NULL
 441
 442 static inline umode_t pvt_limit_is_visible(enum pvt_sensor_type type)
 443 {
 444         return 0;
 445 }
 446
 447 static inline umode_t pvt_alarm_is_visible(enum pvt_sensor_type type)
 448 {
 449         return 0;
 450 }
 451
 452 static int pvt_read_data(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 453                          long *val)
 454 {
 455         struct pvt_cache *cache = &pvt->cache[type];
 456         unsigned long timeout;
 457         u32 data;
 458         int ret;
 459
 460         /*
 461          * Lock PVT conversion interface until data cache is updated. The
 462          * data read procedure is following: set the requested PVT sensor
 463          * mode, enable IRQ and conversion, wait until conversion is finished,
 464          * then disable conversion and IRQ, and read the cached data.
 465          */
 466         ret = mutex_lock_interruptible(&pvt->iface_mtx);
 467         if (ret)
 468                 return ret;
 469
 470         pvt->sensor = type;
 471         pvt_set_mode(pvt, pvt_info[type].mode);
 472
 473         /*
 474          * Unmask the DVALID interrupt and enable the sensors conversions.
 475          * Do the reverse procedure when conversion is done.
 476          */
 477         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, 0);
 478         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, PVT_CTRL_EN);
 479
 480         /*
 481          * Wait with timeout since in case if the sensor is suddenly powered
 482          * down the request won't be completed and the caller will hang up on
 483          * this procedure until the power is back up again. Multiply the
 484          * timeout by the factor of two to prevent a false timeout.
 485          */
 486         timeout = 2 * usecs_to_jiffies(ktime_to_us(pvt->timeout));
 487         ret = wait_for_completion_timeout(&cache->conversion, timeout);
 488
 489         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
 490         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID,
 491                    PVT_INTR_DVALID);
 492
 493         data = READ_ONCE(cache->data);
 494
 495         mutex_unlock(&pvt->iface_mtx);
 496
 497         if (!ret)
 498                 return -ETIMEDOUT;
 499
 500         if (type == PVT_TEMP)
 501                 *val = polynomial_calc(&poly_N_to_temp, data);
 502         else
 503                 *val = polynomial_calc(&poly_N_to_volt, data);
 504
 505         return 0;
 506 }
 507
 508 static int pvt_read_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 509                           bool is_low, long *val)
 510 {
 511         return -EOPNOTSUPP;
 512 }
 513
 514 static int pvt_write_limit(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 515                            bool is_low, long val)
 516 {
 517         return -EOPNOTSUPP;
 518 }
 519
 520 static int pvt_read_alarm(struct pvt_hwmon *pvt, enum pvt_sensor_type type,
 521                           bool is_low, long *val)
 522 {
 523         return -EOPNOTSUPP;
 524 }
 525
 526 static const struct hwmon_channel_info *pvt_channel_info[] = {
 527         HWMON_CHANNEL_INFO(chip,
 528                            HWMON_C_REGISTER_TZ | HWMON_C_UPDATE_INTERVAL),
 529         HWMON_CHANNEL_INFO(temp,
 530                            HWMON_T_INPUT | HWMON_T_TYPE | HWMON_T_LABEL |
 531                            HWMON_T_OFFSET),
 532         HWMON_CHANNEL_INFO(in,
 533                            HWMON_I_INPUT | HWMON_I_LABEL,
 534                            HWMON_I_INPUT | HWMON_I_LABEL,
 535                            HWMON_I_INPUT | HWMON_I_LABEL,
 536                            HWMON_I_INPUT | HWMON_I_LABEL),
 537         NULL
 538 };
 539
 540 #endif /* !CONFIG_SENSORS_BT1_PVT_ALARMS */
 541
 542 static inline bool pvt_hwmon_channel_is_valid(enum hwmon_sensor_types type,
 543                                               int ch)
 544 {
 545         switch (type) {
 546         case hwmon_temp:
 547                 if (ch < 0 || ch >= PVT_TEMP_CHS)
 548                         return false;
 549                 break;
 550         case hwmon_in:
 551                 if (ch < 0 || ch >= PVT_VOLT_CHS)
 552                         return false;
 553                 break;
 554         default:
 555                 break;
 556         }
 557
 558         /* The rest of the types are independent from the channel number. */
 559         return true;
 560 }
 561
 562 static umode_t pvt_hwmon_is_visible(const void *data,
 563                                     enum hwmon_sensor_types type,
 564                                     u32 attr, int ch)
 565 {
 566         if (!pvt_hwmon_channel_is_valid(type, ch))
 567                 return 0;
 568
 569         switch (type) {
 570         case hwmon_chip:
 571                 switch (attr) {
 572                 case hwmon_chip_update_interval:
 573                         return 0644;
 574                 }
 575                 break;
 576         case hwmon_temp:
 577                 switch (attr) {
 578                 case hwmon_temp_input:
 579                 case hwmon_temp_type:
 580                 case hwmon_temp_label:
 581                         return 0444;
 582                 case hwmon_temp_min:
 583                 case hwmon_temp_max:
 584                         return pvt_limit_is_visible(ch);
 585                 case hwmon_temp_min_alarm:
 586                 case hwmon_temp_max_alarm:
 587                         return pvt_alarm_is_visible(ch);
 588                 case hwmon_temp_offset:
 589                         return 0644;
 590                 }
 591                 break;
 592         case hwmon_in:
 593                 switch (attr) {
 594                 case hwmon_in_input:
 595                 case hwmon_in_label:
 596                         return 0444;
 597                 case hwmon_in_min:
 598                 case hwmon_in_max:
 599                         return pvt_limit_is_visible(PVT_VOLT + ch);
 600                 case hwmon_in_min_alarm:
 601                 case hwmon_in_max_alarm:
 602                         return pvt_alarm_is_visible(PVT_VOLT + ch);
 603                 }
 604                 break;
 605         default:
 606                 break;
 607         }
 608
 609         return 0;
 610 }
 611
 612 static int pvt_read_trim(struct pvt_hwmon *pvt, long *val)
 613 {
 614         u32 data;
 615
 616         data = readl(pvt->regs + PVT_CTRL);
 617         *val = FIELD_GET(PVT_CTRL_TRIM_MASK, data) * PVT_TRIM_STEP;
 618
 619         return 0;
 620 }
 621
 622 static int pvt_write_trim(struct pvt_hwmon *pvt, long val)
 623 {
 624         u32 trim;
 625         int ret;
 626
 627         /*
 628          * Serialize trim update, since a part of the register is changed and
 629          * the controller is supposed to be disabled during this operation.
 630          */
 631         ret = mutex_lock_interruptible(&pvt->iface_mtx);
 632         if (ret)
 633                 return ret;
 634
 635         trim = pvt_calc_trim(val);
 636         pvt_set_trim(pvt, trim);
 637
 638         mutex_unlock(&pvt->iface_mtx);
 639
 640         return 0;
 641 }
 642
 643 static int pvt_read_timeout(struct pvt_hwmon *pvt, long *val)
 644 {
 645         int ret;
 646
 647         ret = mutex_lock_interruptible(&pvt->iface_mtx);
 648         if (ret)
 649                 return ret;
 650
 651         /* Return the result in msec as hwmon sysfs interface requires. */
 652         *val = ktime_to_ms(pvt->timeout);
 653
 654         mutex_unlock(&pvt->iface_mtx);
 655
 656         return 0;
 657 }
 658
 659 static int pvt_write_timeout(struct pvt_hwmon *pvt, long val)
 660 {
 661         unsigned long rate;
 662         ktime_t kt, cache;
 663         u32 data;
 664         int ret;
 665
 666         rate = clk_get_rate(pvt->clks[PVT_CLOCK_REF].clk);
 667         if (!rate)
 668                 return -ENODEV;
 669
 670         /*
 671          * If alarms are enabled, the requested timeout must be divided
 672          * between all available sensors to have the requested delay
 673          * applicable to each individual sensor.
 674          */
 675         cache = kt = ms_to_ktime(val);
 676 #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
 677         kt = ktime_divns(kt, PVT_SENSORS_NUM);
 678 #endif
 679
 680         /*
 681          * Subtract a constant lag, which always persists due to the limited
 682          * PVT sampling rate. Make sure the timeout is not negative.
 683          */
 684         kt = ktime_sub_ns(kt, PVT_TOUT_MIN);
 685         if (ktime_to_ns(kt) < 0)
 686                 kt = ktime_set(0, 0);
 687
 688         /*
 689          * Finally recalculate the timeout in terms of the reference clock
 690          * period.
 691          */
 692         data = ktime_divns(kt * rate, NSEC_PER_SEC);
 693
 694         /*
 695          * Update the measurements delay, but lock the interface first, since
 696          * we have to disable PVT in order to have the new delay actually
 697          * updated.
 698          */
 699         ret = mutex_lock_interruptible(&pvt->iface_mtx);
 700         if (ret)
 701                 return ret;
 702
 703         pvt_set_tout(pvt, data);
 704         pvt->timeout = cache;
 705
 706         mutex_unlock(&pvt->iface_mtx);
 707
 708         return 0;
 709 }
 710
 711 static int pvt_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
 712                           u32 attr, int ch, long *val)
 713 {
 714         struct pvt_hwmon *pvt = dev_get_drvdata(dev);
 715
 716         if (!pvt_hwmon_channel_is_valid(type, ch))
 717                 return -EINVAL;
 718
 719         switch (type) {
 720         case hwmon_chip:
 721                 switch (attr) {
 722                 case hwmon_chip_update_interval:
 723                         return pvt_read_timeout(pvt, val);
 724                 }
 725                 break;
 726         case hwmon_temp:
 727                 switch (attr) {
 728                 case hwmon_temp_input:
 729                         return pvt_read_data(pvt, ch, val);
 730                 case hwmon_temp_type:
 731                         *val = 1;
 732                         return 0;
 733                 case hwmon_temp_min:
 734                         return pvt_read_limit(pvt, ch, true, val);
 735                 case hwmon_temp_max:
 736                         return pvt_read_limit(pvt, ch, false, val);
 737                 case hwmon_temp_min_alarm:
 738                         return pvt_read_alarm(pvt, ch, true, val);
 739                 case hwmon_temp_max_alarm:
 740                         return pvt_read_alarm(pvt, ch, false, val);
 741                 case hwmon_temp_offset:
 742                         return pvt_read_trim(pvt, val);
 743                 }
 744                 break;
 745         case hwmon_in:
 746                 switch (attr) {
 747                 case hwmon_in_input:
 748                         return pvt_read_data(pvt, PVT_VOLT + ch, val);
 749                 case hwmon_in_min:
 750                         return pvt_read_limit(pvt, PVT_VOLT + ch, true, val);
 751                 case hwmon_in_max:
 752                         return pvt_read_limit(pvt, PVT_VOLT + ch, false, val);
 753                 case hwmon_in_min_alarm:
 754                         return pvt_read_alarm(pvt, PVT_VOLT + ch, true, val);
 755                 case hwmon_in_max_alarm:
 756                         return pvt_read_alarm(pvt, PVT_VOLT + ch, false, val);
 757                 }
 758                 break;
 759         default:
 760                 break;
 761         }
 762
 763         return -EOPNOTSUPP;
 764 }
 765
 766 static int pvt_hwmon_read_string(struct device *dev,
 767                                  enum hwmon_sensor_types type,
 768                                  u32 attr, int ch, const char **str)
 769 {
 770         if (!pvt_hwmon_channel_is_valid(type, ch))
 771                 return -EINVAL;
 772
 773         switch (type) {
 774         case hwmon_temp:
 775                 switch (attr) {
 776                 case hwmon_temp_label:
 777                         *str = pvt_info[ch].label;
 778                         return 0;
 779                 }
 780                 break;
 781         case hwmon_in:
 782                 switch (attr) {
 783                 case hwmon_in_label:
 784                         *str = pvt_info[PVT_VOLT + ch].label;
 785                         return 0;
 786                 }
 787                 break;
 788         default:
 789                 break;
 790         }
 791
 792         return -EOPNOTSUPP;
 793 }
 794
 795 static int pvt_hwmon_write(struct device *dev, enum hwmon_sensor_types type,
 796                            u32 attr, int ch, long val)
 797 {
 798         struct pvt_hwmon *pvt = dev_get_drvdata(dev);
 799
 800         if (!pvt_hwmon_channel_is_valid(type, ch))
 801                 return -EINVAL;
 802
 803         switch (type) {
 804         case hwmon_chip:
 805                 switch (attr) {
 806                 case hwmon_chip_update_interval:
 807                         return pvt_write_timeout(pvt, val);
 808                 }
 809                 break;
 810         case hwmon_temp:
 811                 switch (attr) {
 812                 case hwmon_temp_min:
 813                         return pvt_write_limit(pvt, ch, true, val);
 814                 case hwmon_temp_max:
 815                         return pvt_write_limit(pvt, ch, false, val);
 816                 case hwmon_temp_offset:
 817                         return pvt_write_trim(pvt, val);
 818                 }
 819                 break;
 820         case hwmon_in:
 821                 switch (attr) {
 822                 case hwmon_in_min:
 823                         return pvt_write_limit(pvt, PVT_VOLT + ch, true, val);
 824                 case hwmon_in_max:
 825                         return pvt_write_limit(pvt, PVT_VOLT + ch, false, val);
 826                 }
 827                 break;
 828         default:
 829                 break;
 830         }
 831
 832         return -EOPNOTSUPP;
 833 }
 834
 835 static const struct hwmon_ops pvt_hwmon_ops = {
 836         .is_visible = pvt_hwmon_is_visible,
 837         .read = pvt_hwmon_read,
 838         .read_string = pvt_hwmon_read_string,
 839         .write = pvt_hwmon_write
 840 };
 841
 842 static const struct hwmon_chip_info pvt_hwmon_info = {
 843         .ops = &pvt_hwmon_ops,
 844         .info = pvt_channel_info
 845 };
 846
 847 static void pvt_clear_data(void *data)
 848 {
 849         struct pvt_hwmon *pvt = data;
 850 #if !defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
 851         int idx;
 852
 853         for (idx = 0; idx < PVT_SENSORS_NUM; ++idx)
 854                 complete_all(&pvt->cache[idx].conversion);
 855 #endif
 856
 857         mutex_destroy(&pvt->iface_mtx);
 858 }
 859
 860 static struct pvt_hwmon *pvt_create_data(struct platform_device *pdev)
 861 {
 862         struct device *dev = &pdev->dev;
 863         struct pvt_hwmon *pvt;
 864         int ret, idx;
 865
 866         pvt = devm_kzalloc(dev, sizeof(*pvt), GFP_KERNEL);
 867         if (!pvt)
 868                 return ERR_PTR(-ENOMEM);
 869
 870         ret = devm_add_action(dev, pvt_clear_data, pvt);
 871         if (ret) {
 872                 dev_err(dev, "Can't add PVT data clear action\n");
 873                 return ERR_PTR(ret);
 874         }
 875
 876         pvt->dev = dev;
 877         pvt->sensor = PVT_SENSOR_FIRST;
 878         mutex_init(&pvt->iface_mtx);
 879
 880 #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
 881         for (idx = 0; idx < PVT_SENSORS_NUM; ++idx)
 882                 seqlock_init(&pvt->cache[idx].data_seqlock);
 883 #else
 884         for (idx = 0; idx < PVT_SENSORS_NUM; ++idx)
 885                 init_completion(&pvt->cache[idx].conversion);
 886 #endif
 887
 888         return pvt;
 889 }
 890
 891 static int pvt_request_regs(struct pvt_hwmon *pvt)
 892 {
 893         struct platform_device *pdev = to_platform_device(pvt->dev);
 894         struct resource *res;
 895
 896         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 897         if (!res) {
 898                 dev_err(pvt->dev, "Couldn't find PVT memresource\n");
 899                 return -EINVAL;
 900         }
 901
 902         pvt->regs = devm_ioremap_resource(pvt->dev, res);
 903         if (IS_ERR(pvt->regs))
 904                 return PTR_ERR(pvt->regs);
 905
 906         return 0;
 907 }
 908
 909 static void pvt_disable_clks(void *data)
 910 {
 911         struct pvt_hwmon *pvt = data;
 912
 913         clk_bulk_disable_unprepare(PVT_CLOCK_NUM, pvt->clks);
 914 }
 915
 916 static int pvt_request_clks(struct pvt_hwmon *pvt)
 917 {
 918         int ret;
 919
 920         pvt->clks[PVT_CLOCK_APB].id = "pclk";
 921         pvt->clks[PVT_CLOCK_REF].id = "ref";
 922
 923         ret = devm_clk_bulk_get(pvt->dev, PVT_CLOCK_NUM, pvt->clks);
 924         if (ret) {
 925                 dev_err(pvt->dev, "Couldn't get PVT clocks descriptors\n");
 926                 return ret;
 927         }
 928
 929         ret = clk_bulk_prepare_enable(PVT_CLOCK_NUM, pvt->clks);
 930         if (ret) {
 931                 dev_err(pvt->dev, "Couldn't enable the PVT clocks\n");
 932                 return ret;
 933         }
 934
 935         ret = devm_add_action_or_reset(pvt->dev, pvt_disable_clks, pvt);
 936         if (ret) {
 937                 dev_err(pvt->dev, "Can't add PVT clocks disable action\n");
 938                 return ret;
 939         }
 940
 941         return 0;
 942 }
 943
 944 static int pvt_check_pwr(struct pvt_hwmon *pvt)
 945 {
 946         unsigned long tout;
 947         int ret = 0;
 948         u32 data;
 949
 950         /*
 951          * Test out the sensor conversion functionality. If it is not done on
 952          * time then the domain must have been unpowered and we won't be able
 953          * to use the device later in this driver.
 954          * Note If the power source is lost during the normal driver work the
 955          * data read procedure will either return -ETIMEDOUT (for the
 956          * alarm-less driver configuration) or just stop the repeated
 957          * conversion. In the later case alas we won't be able to detect the
 958          * problem.
 959          */
 960         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_ALL, PVT_INTR_ALL);
 961         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, PVT_CTRL_EN);
 962         pvt_set_tout(pvt, 0);
 963         readl(pvt->regs + PVT_DATA);
 964
 965         tout = PVT_TOUT_MIN / NSEC_PER_USEC;
 966         usleep_range(tout, 2 * tout);
 967
 968         data = readl(pvt->regs + PVT_DATA);
 969         if (!(data & PVT_DATA_VALID)) {
 970                 ret = -ENODEV;
 971                 dev_err(pvt->dev, "Sensor is powered down\n");
 972         }
 973
 974         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
 975
 976         return ret;
 977 }
 978
 979 static int pvt_init_iface(struct pvt_hwmon *pvt)
 980 {
 981         unsigned long rate;
 982         u32 trim, temp;
 983
 984         rate = clk_get_rate(pvt->clks[PVT_CLOCK_REF].clk);
 985         if (!rate) {
 986                 dev_err(pvt->dev, "Invalid reference clock rate\n");
 987                 return -ENODEV;
 988         }
 989
 990         /*
 991          * Make sure all interrupts and controller are disabled so not to
 992          * accidentally have ISR executed before the driver data is fully
 993          * initialized. Clear the IRQ status as well.
 994          */
 995         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_ALL, PVT_INTR_ALL);
 996         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
 997         readl(pvt->regs + PVT_CLR_INTR);
 998         readl(pvt->regs + PVT_DATA);
 999
1000         /* Setup default sensor mode, timeout and temperature trim. */
1001         pvt_set_mode(pvt, pvt_info[pvt->sensor].mode);
1002         pvt_set_tout(pvt, PVT_TOUT_DEF);
1003
1004         /*
1005          * Preserve the current ref-clock based delay (Ttotal) between the
1006          * sensors data samples in the driver data so not to recalculate it
1007          * each time on the data requests and timeout reads. It consists of the
1008          * delay introduced by the internal ref-clock timer (N / Fclk) and the
1009          * constant timeout caused by each conversion latency (Tmin):
1010          *   Ttotal = N / Fclk + Tmin
1011          * If alarms are enabled the sensors are polled one after another and
1012          * in order to get the next measurement of a particular sensor the
1013          * caller will have to wait for at most until all the others are
1014          * polled. In that case the formulae will look a bit different:
1015          *   Ttotal = 5 * (N / Fclk + Tmin)
1016          */
1017 #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
1018         pvt->timeout = ktime_set(PVT_SENSORS_NUM * PVT_TOUT_DEF, 0);
1019         pvt->timeout = ktime_divns(pvt->timeout, rate);
1020         pvt->timeout = ktime_add_ns(pvt->timeout, PVT_SENSORS_NUM * PVT_TOUT_MIN);
1021 #else
1022         pvt->timeout = ktime_set(PVT_TOUT_DEF, 0);
1023         pvt->timeout = ktime_divns(pvt->timeout, rate);
1024         pvt->timeout = ktime_add_ns(pvt->timeout, PVT_TOUT_MIN);
1025 #endif
1026
1027         trim = PVT_TRIM_DEF;
1028         if (!of_property_read_u32(pvt->dev->of_node,
1029              "baikal,pvt-temp-offset-millicelsius", &temp))
1030                 trim = pvt_calc_trim(temp);
1031
1032         pvt_set_trim(pvt, trim);
1033
1034         return 0;
1035 }
1036
1037 static int pvt_request_irq(struct pvt_hwmon *pvt)
1038 {
1039         struct platform_device *pdev = to_platform_device(pvt->dev);
1040         int ret;
1041
1042         pvt->irq = platform_get_irq(pdev, 0);
1043         if (pvt->irq < 0)
1044                 return pvt->irq;
1045
1046         ret = devm_request_threaded_irq(pvt->dev, pvt->irq,
1047                                         pvt_hard_isr, pvt_soft_isr,
1048 #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
1049                                         IRQF_SHARED | IRQF_TRIGGER_HIGH |
1050                                         IRQF_ONESHOT,
1051 #else
1052                                         IRQF_SHARED | IRQF_TRIGGER_HIGH,
1053 #endif
1054                                         "pvt", pvt);
1055         if (ret) {
1056                 dev_err(pvt->dev, "Couldn't request PVT IRQ\n");
1057                 return ret;
1058         }
1059
1060         return 0;
1061 }
1062
1063 static int pvt_create_hwmon(struct pvt_hwmon *pvt)
1064 {
1065         pvt->hwmon = devm_hwmon_device_register_with_info(pvt->dev, "pvt", pvt,
1066                 &pvt_hwmon_info, NULL);
1067         if (IS_ERR(pvt->hwmon)) {
1068                 dev_err(pvt->dev, "Couldn't create hwmon device\n");
1069                 return PTR_ERR(pvt->hwmon);
1070         }
1071
1072         return 0;
1073 }
1074
1075 #if defined(CONFIG_SENSORS_BT1_PVT_ALARMS)
1076
1077 static void pvt_disable_iface(void *data)
1078 {
1079         struct pvt_hwmon *pvt = data;
1080
1081         mutex_lock(&pvt->iface_mtx);
1082         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, 0);
1083         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID,
1084                    PVT_INTR_DVALID);
1085         mutex_unlock(&pvt->iface_mtx);
1086 }
1087
1088 static int pvt_enable_iface(struct pvt_hwmon *pvt)
1089 {
1090         int ret;
1091
1092         ret = devm_add_action(pvt->dev, pvt_disable_iface, pvt);
1093         if (ret) {
1094                 dev_err(pvt->dev, "Can't add PVT disable interface action\n");
1095                 return ret;
1096         }
1097
1098         /*
1099          * Enable sensors data conversion and IRQ. We need to lock the
1100          * interface mutex since hwmon has just been created and the
1101          * corresponding sysfs files are accessible from user-space,
1102          * which theoretically may cause races.
1103          */
1104         mutex_lock(&pvt->iface_mtx);
1105         pvt_update(pvt->regs + PVT_INTR_MASK, PVT_INTR_DVALID, 0);
1106         pvt_update(pvt->regs + PVT_CTRL, PVT_CTRL_EN, PVT_CTRL_EN);
1107         mutex_unlock(&pvt->iface_mtx);
1108
1109         return 0;
1110 }
1111
1112 #else /* !CONFIG_SENSORS_BT1_PVT_ALARMS */
1113
1114 static int pvt_enable_iface(struct pvt_hwmon *pvt)
1115 {
1116         return 0;
1117 }
1118
1119 #endif /* !CONFIG_SENSORS_BT1_PVT_ALARMS */
1120
1121 static int pvt_probe(struct platform_device *pdev)
1122 {
1123         struct pvt_hwmon *pvt;
1124         int ret;
1125
1126         pvt = pvt_create_data(pdev);
1127         if (IS_ERR(pvt))
1128                 return PTR_ERR(pvt);
1129
1130         ret = pvt_request_regs(pvt);
1131         if (ret)
1132                 return ret;
1133
1134         ret = pvt_request_clks(pvt);
1135         if (ret)
1136                 return ret;
1137
1138         ret = pvt_check_pwr(pvt);
1139         if (ret)
1140                 return ret;
1141
1142         ret = pvt_init_iface(pvt);
1143         if (ret)
1144                 return ret;
1145
1146         ret = pvt_request_irq(pvt);
1147         if (ret)
1148                 return ret;
1149
1150         ret = pvt_create_hwmon(pvt);
1151         if (ret)
1152                 return ret;
1153
1154         ret = pvt_enable_iface(pvt);
1155         if (ret)
1156                 return ret;
1157
1158         return 0;
1159 }
1160
1161 static const struct of_device_id pvt_of_match[] = {
1162         { .compatible = "baikal,bt1-pvt" },
1163         { }
1164 };
1165 MODULE_DEVICE_TABLE(of, pvt_of_match);
1166
1167 static struct platform_driver pvt_driver = {
1168         .probe = pvt_probe,
1169         .driver = {
1170                 .name = "bt1-pvt",
1171                 .of_match_table = pvt_of_match
1172         }
1173 };
1174 module_platform_driver(pvt_driver);
1175
1176 MODULE_AUTHOR("Maxim Kaurkin <maxim.kaurkin@baikalelectronics.ru>");
1177 MODULE_DESCRIPTION("Baikal-T1 PVT driver");
1178 MODULE_LICENSE("GPL v2");