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