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