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