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 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 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 inline umode_t pvt_limit_is_visible(enum pvt_sensor_type type) 304 { 305 return 0644; 306 } 307 308 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 inline umode_t pvt_limit_is_visible(enum pvt_sensor_type type) 466 { 467 return 0; 468 } 469 470 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"); 1147