?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / drivers / net / ethernet / mellanox / mlxsw / core_thermal.c
blobce0a6837daa32b3748e79b0880f35c38ad458851
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2016-2018 Mellanox Technologies. All rights reserved
3 * Copyright (c) 2016 Ivan Vecera <cera@cera.cz>
4 */
5
6 #include <linux/kernel.h>
7 #include <linux/types.h>
8 #include <linux/device.h>
9 #include <linux/sysfs.h>
10 #include <linux/thermal.h>
11 #include <linux/err.h>
12 #include <linux/sfp.h>
13
14 #include "core.h"
15 #include "core_env.h"
16
17 #define MLXSW_THERMAL_POLL_INT 1000 /* ms */
18 #define MLXSW_THERMAL_SLOW_POLL_INT 20000 /* ms */
19 #define MLXSW_THERMAL_ASIC_TEMP_NORM 75000 /* 75C */
20 #define MLXSW_THERMAL_ASIC_TEMP_HIGH 85000 /* 85C */
21 #define MLXSW_THERMAL_ASIC_TEMP_HOT 105000 /* 105C */
22 #define MLXSW_THERMAL_ASIC_TEMP_CRIT 110000 /* 110C */
23 #define MLXSW_THERMAL_HYSTERESIS_TEMP 5000 /* 5C */
24 #define MLXSW_THERMAL_MODULE_TEMP_SHIFT (MLXSW_THERMAL_HYSTERESIS_TEMP * 2)
25 #define MLXSW_THERMAL_ZONE_MAX_NAME 16
26 #define MLXSW_THERMAL_TEMP_SCORE_MAX GENMASK(31, 0)
27 #define MLXSW_THERMAL_MAX_STATE 10
28 #define MLXSW_THERMAL_MAX_DUTY 255
29 /* Minimum and maximum fan allowed speed in percent: from 20% to 100%. Values
30 * MLXSW_THERMAL_MAX_STATE + x, where x is between 2 and 10 are used for
31 * setting fan speed dynamic minimum. For example, if value is set to 14 (40%)
32 * cooling levels vector will be set to 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10 to
33 * introduce PWM speed in percent: 40, 40, 40, 40, 40, 50, 60. 70, 80, 90, 100.
34 */
35 #define MLXSW_THERMAL_SPEED_MIN (MLXSW_THERMAL_MAX_STATE + 2)
36 #define MLXSW_THERMAL_SPEED_MAX (MLXSW_THERMAL_MAX_STATE * 2)
37 #define MLXSW_THERMAL_SPEED_MIN_LEVEL 2 /* 20% */
38
39 /* External cooling devices, allowed for binding to mlxsw thermal zones. */
40 static char * const mlxsw_thermal_external_allowed_cdev[] = {
41 "mlxreg_fan",
42 };
43
44 enum mlxsw_thermal_trips {
45 MLXSW_THERMAL_TEMP_TRIP_NORM,
46 MLXSW_THERMAL_TEMP_TRIP_HIGH,
47 MLXSW_THERMAL_TEMP_TRIP_HOT,
48 MLXSW_THERMAL_TEMP_TRIP_CRIT,
49 };
50
51 struct mlxsw_thermal_trip {
52 int type;
53 int temp;
54 int hyst;
55 int min_state;
56 int max_state;
57 };
58
59 static const struct mlxsw_thermal_trip default_thermal_trips[] = {
60 { /* In range - 0-40% PWM */
61 .type = THERMAL_TRIP_ACTIVE,
62 .temp = MLXSW_THERMAL_ASIC_TEMP_NORM,
63 .hyst = MLXSW_THERMAL_HYSTERESIS_TEMP,
64 .min_state = 0,
65 .max_state = (4 * MLXSW_THERMAL_MAX_STATE) / 10,
66 },
67 {
68 /* In range - 40-100% PWM */
69 .type = THERMAL_TRIP_ACTIVE,
70 .temp = MLXSW_THERMAL_ASIC_TEMP_HIGH,
71 .hyst = MLXSW_THERMAL_HYSTERESIS_TEMP,
72 .min_state = (4 * MLXSW_THERMAL_MAX_STATE) / 10,
73 .max_state = MLXSW_THERMAL_MAX_STATE,
74 },
75 { /* Warning */
76 .type = THERMAL_TRIP_HOT,
77 .temp = MLXSW_THERMAL_ASIC_TEMP_HOT,
78 .hyst = MLXSW_THERMAL_HYSTERESIS_TEMP,
79 .min_state = MLXSW_THERMAL_MAX_STATE,
80 .max_state = MLXSW_THERMAL_MAX_STATE,
81 },
82 { /* Critical - soft poweroff */
83 .type = THERMAL_TRIP_CRITICAL,
84 .temp = MLXSW_THERMAL_ASIC_TEMP_CRIT,
85 .min_state = MLXSW_THERMAL_MAX_STATE,
86 .max_state = MLXSW_THERMAL_MAX_STATE,
87 }
88 };
89
90 #define MLXSW_THERMAL_NUM_TRIPS ARRAY_SIZE(default_thermal_trips)
91
92 /* Make sure all trips are writable */
93 #define MLXSW_THERMAL_TRIP_MASK (BIT(MLXSW_THERMAL_NUM_TRIPS) - 1)
94
95 struct mlxsw_thermal;
96
97 struct mlxsw_thermal_module {
98 struct mlxsw_thermal *parent;
99 struct thermal_zone_device *tzdev;
100 struct mlxsw_thermal_trip trips[MLXSW_THERMAL_NUM_TRIPS];
101 enum thermal_device_mode mode;
102 int module; /* Module or gearbox number */
103 };
104
105 struct mlxsw_thermal {
106 struct mlxsw_core *core;
107 const struct mlxsw_bus_info *bus_info;
108 struct thermal_zone_device *tzdev;
109 int polling_delay;
110 struct thermal_cooling_device *cdevs[MLXSW_MFCR_PWMS_MAX];
111 u8 cooling_levels[MLXSW_THERMAL_MAX_STATE + 1];
112 struct mlxsw_thermal_trip trips[MLXSW_THERMAL_NUM_TRIPS];
113 enum thermal_device_mode mode;
114 struct mlxsw_thermal_module *tz_module_arr;
115 u8 tz_module_num;
116 struct mlxsw_thermal_module *tz_gearbox_arr;
117 u8 tz_gearbox_num;
118 unsigned int tz_highest_score;
119 struct thermal_zone_device *tz_highest_dev;
120 };
121
122 static inline u8 mlxsw_state_to_duty(int state)
123 {
124 return DIV_ROUND_CLOSEST(state * MLXSW_THERMAL_MAX_DUTY,
125 MLXSW_THERMAL_MAX_STATE);
126 }
127
128 static inline int mlxsw_duty_to_state(u8 duty)
129 {
130 return DIV_ROUND_CLOSEST(duty * MLXSW_THERMAL_MAX_STATE,
131 MLXSW_THERMAL_MAX_DUTY);
132 }
133
134 static int mlxsw_get_cooling_device_idx(struct mlxsw_thermal *thermal,
135 struct thermal_cooling_device *cdev)
136 {
137 int i;
138
139 for (i = 0; i < MLXSW_MFCR_PWMS_MAX; i++)
140 if (thermal->cdevs[i] == cdev)
141 return i;
142
143 /* Allow mlxsw thermal zone binding to an external cooling device */
144 for (i = 0; i < ARRAY_SIZE(mlxsw_thermal_external_allowed_cdev); i++) {
145 if (strnstr(cdev->type, mlxsw_thermal_external_allowed_cdev[i],
146 sizeof(cdev->type)))
147 return 0;
148 }
149
150 return -ENODEV;
151 }
152
153 static void
154 mlxsw_thermal_module_trips_reset(struct mlxsw_thermal_module *tz)
155 {
156 tz->trips[MLXSW_THERMAL_TEMP_TRIP_NORM].temp = 0;
157 tz->trips[MLXSW_THERMAL_TEMP_TRIP_HIGH].temp = 0;
158 tz->trips[MLXSW_THERMAL_TEMP_TRIP_HOT].temp = 0;
159 tz->trips[MLXSW_THERMAL_TEMP_TRIP_CRIT].temp = 0;
160 }
161
162 static int
163 mlxsw_thermal_module_trips_update(struct device *dev, struct mlxsw_core *core,
164 struct mlxsw_thermal_module *tz)
165 {
166 int crit_temp, emerg_temp;
167 int err;
168
169 err = mlxsw_env_module_temp_thresholds_get(core, tz->module,
170 SFP_TEMP_HIGH_WARN,
171 &crit_temp);
172 if (err)
173 return err;
174
175 err = mlxsw_env_module_temp_thresholds_get(core, tz->module,
176 SFP_TEMP_HIGH_ALARM,
177 &emerg_temp);
178 if (err)
179 return err;
180
181 /* According to the system thermal requirements, the thermal zones are
182 * defined with four trip points. The critical and emergency
183 * temperature thresholds, provided by QSFP module are set as "active"
184 * and "hot" trip points, "normal" and "critical" trip points are
185 * derived from "active" and "hot" by subtracting or adding double
186 * hysteresis value.
187 */
188 if (crit_temp >= MLXSW_THERMAL_MODULE_TEMP_SHIFT)
189 tz->trips[MLXSW_THERMAL_TEMP_TRIP_NORM].temp = crit_temp -
190 MLXSW_THERMAL_MODULE_TEMP_SHIFT;
191 else
192 tz->trips[MLXSW_THERMAL_TEMP_TRIP_NORM].temp = crit_temp;
193 tz->trips[MLXSW_THERMAL_TEMP_TRIP_HIGH].temp = crit_temp;
194 tz->trips[MLXSW_THERMAL_TEMP_TRIP_HOT].temp = emerg_temp;
195 if (emerg_temp > crit_temp)
196 tz->trips[MLXSW_THERMAL_TEMP_TRIP_CRIT].temp = emerg_temp +
197 MLXSW_THERMAL_MODULE_TEMP_SHIFT;
198 else
199 tz->trips[MLXSW_THERMAL_TEMP_TRIP_CRIT].temp = emerg_temp;
200
201 return 0;
202 }
203
204 static void mlxsw_thermal_tz_score_update(struct mlxsw_thermal *thermal,
205 struct thermal_zone_device *tzdev,
206 struct mlxsw_thermal_trip *trips,
207 int temp)
208 {
209 struct mlxsw_thermal_trip *trip = trips;
210 unsigned int score, delta, i, shift = 1;
211
212 /* Calculate thermal zone score, if temperature is above the critical
213 * threshold score is set to MLXSW_THERMAL_TEMP_SCORE_MAX.
214 */
215 score = MLXSW_THERMAL_TEMP_SCORE_MAX;
216 for (i = MLXSW_THERMAL_TEMP_TRIP_NORM; i < MLXSW_THERMAL_NUM_TRIPS;
217 i++, trip++) {
218 if (temp < trip->temp) {
219 delta = DIV_ROUND_CLOSEST(temp, trip->temp - temp);
220 score = delta * shift;
221 break;
222 }
223 shift *= 256;
224 }
225
226 if (score > thermal->tz_highest_score) {
227 thermal->tz_highest_score = score;
228 thermal->tz_highest_dev = tzdev;
229 }
230 }
231
232 static int mlxsw_thermal_bind(struct thermal_zone_device *tzdev,
233 struct thermal_cooling_device *cdev)
234 {
235 struct mlxsw_thermal *thermal = tzdev->devdata;
236 struct device *dev = thermal->bus_info->dev;
237 int i, err;
238
239 /* If the cooling device is one of ours bind it */
240 if (mlxsw_get_cooling_device_idx(thermal, cdev) < 0)
241 return 0;
242
243 for (i = 0; i < MLXSW_THERMAL_NUM_TRIPS; i++) {
244 const struct mlxsw_thermal_trip *trip = &thermal->trips[i];
245
246 err = thermal_zone_bind_cooling_device(tzdev, i, cdev,
247 trip->max_state,
248 trip->min_state,
249 THERMAL_WEIGHT_DEFAULT);
250 if (err < 0) {
251 dev_err(dev, "Failed to bind cooling device to trip %d\n", i);
252 return err;
253 }
254 }
255 return 0;
256 }
257
258 static int mlxsw_thermal_unbind(struct thermal_zone_device *tzdev,
259 struct thermal_cooling_device *cdev)
260 {
261 struct mlxsw_thermal *thermal = tzdev->devdata;
262 struct device *dev = thermal->bus_info->dev;
263 int i;
264 int err;
265
266 /* If the cooling device is our one unbind it */
267 if (mlxsw_get_cooling_device_idx(thermal, cdev) < 0)
268 return 0;
269
270 for (i = 0; i < MLXSW_THERMAL_NUM_TRIPS; i++) {
271 err = thermal_zone_unbind_cooling_device(tzdev, i, cdev);
272 if (err < 0) {
273 dev_err(dev, "Failed to unbind cooling device\n");
274 return err;
275 }
276 }
277 return 0;
278 }
279
280 static int mlxsw_thermal_get_mode(struct thermal_zone_device *tzdev,
281 enum thermal_device_mode *mode)
282 {
283 struct mlxsw_thermal *thermal = tzdev->devdata;
284
285 *mode = thermal->mode;
286
287 return 0;
288 }
289
290 static int mlxsw_thermal_set_mode(struct thermal_zone_device *tzdev,
291 enum thermal_device_mode mode)
292 {
293 struct mlxsw_thermal *thermal = tzdev->devdata;
294
295 mutex_lock(&tzdev->lock);
296
297 if (mode == THERMAL_DEVICE_ENABLED)
298 tzdev->polling_delay = thermal->polling_delay;
299 else
300 tzdev->polling_delay = 0;
301
302 mutex_unlock(&tzdev->lock);
303
304 thermal->mode = mode;
305 thermal_zone_device_update(tzdev, THERMAL_EVENT_UNSPECIFIED);
306
307 return 0;
308 }
309
310 static int mlxsw_thermal_get_temp(struct thermal_zone_device *tzdev,
311 int *p_temp)
312 {
313 struct mlxsw_thermal *thermal = tzdev->devdata;
314 struct device *dev = thermal->bus_info->dev;
315 char mtmp_pl[MLXSW_REG_MTMP_LEN];
316 int temp;
317 int err;
318
319 mlxsw_reg_mtmp_pack(mtmp_pl, 0, false, false);
320
321 err = mlxsw_reg_query(thermal->core, MLXSW_REG(mtmp), mtmp_pl);
322 if (err) {
323 dev_err(dev, "Failed to query temp sensor\n");
324 return err;
325 }
326 mlxsw_reg_mtmp_unpack(mtmp_pl, &temp, NULL, NULL);
327 if (temp > 0)
328 mlxsw_thermal_tz_score_update(thermal, tzdev, thermal->trips,
329 temp);
330
331 *p_temp = temp;
332 return 0;
333 }
334
335 static int mlxsw_thermal_get_trip_type(struct thermal_zone_device *tzdev,
336 int trip,
337 enum thermal_trip_type *p_type)
338 {
339 struct mlxsw_thermal *thermal = tzdev->devdata;
340
341 if (trip < 0 || trip >= MLXSW_THERMAL_NUM_TRIPS)
342 return -EINVAL;
343
344 *p_type = thermal->trips[trip].type;
345 return 0;
346 }
347
348 static int mlxsw_thermal_get_trip_temp(struct thermal_zone_device *tzdev,
349 int trip, int *p_temp)
350 {
351 struct mlxsw_thermal *thermal = tzdev->devdata;
352
353 if (trip < 0 || trip >= MLXSW_THERMAL_NUM_TRIPS)
354 return -EINVAL;
355
356 *p_temp = thermal->trips[trip].temp;
357 return 0;
358 }
359
360 static int mlxsw_thermal_set_trip_temp(struct thermal_zone_device *tzdev,
361 int trip, int temp)
362 {
363 struct mlxsw_thermal *thermal = tzdev->devdata;
364
365 if (trip < 0 || trip >= MLXSW_THERMAL_NUM_TRIPS ||
366 temp > MLXSW_THERMAL_ASIC_TEMP_CRIT)
367 return -EINVAL;
368
369 thermal->trips[trip].temp = temp;
370 return 0;
371 }
372
373 static int mlxsw_thermal_get_trip_hyst(struct thermal_zone_device *tzdev,
374 int trip, int *p_hyst)
375 {
376 struct mlxsw_thermal *thermal = tzdev->devdata;
377
378 *p_hyst = thermal->trips[trip].hyst;
379 return 0;
380 }
381
382 static int mlxsw_thermal_set_trip_hyst(struct thermal_zone_device *tzdev,
383 int trip, int hyst)
384 {
385 struct mlxsw_thermal *thermal = tzdev->devdata;
386
387 thermal->trips[trip].hyst = hyst;
388 return 0;
389 }
390
391 static int mlxsw_thermal_trend_get(struct thermal_zone_device *tzdev,
392 int trip, enum thermal_trend *trend)
393 {
394 struct mlxsw_thermal_module *tz = tzdev->devdata;
395 struct mlxsw_thermal *thermal = tz->parent;
396
397 if (trip < 0 || trip >= MLXSW_THERMAL_NUM_TRIPS)
398 return -EINVAL;
399
400 if (tzdev == thermal->tz_highest_dev)
401 return 1;
402
403 *trend = THERMAL_TREND_STABLE;
404 return 0;
405 }
406
407 static struct thermal_zone_device_ops mlxsw_thermal_ops = {
408 .bind = mlxsw_thermal_bind,
409 .unbind = mlxsw_thermal_unbind,
410 .get_mode = mlxsw_thermal_get_mode,
411 .set_mode = mlxsw_thermal_set_mode,
412 .get_temp = mlxsw_thermal_get_temp,
413 .get_trip_type = mlxsw_thermal_get_trip_type,
414 .get_trip_temp = mlxsw_thermal_get_trip_temp,
415 .set_trip_temp = mlxsw_thermal_set_trip_temp,
416 .get_trip_hyst = mlxsw_thermal_get_trip_hyst,
417 .set_trip_hyst = mlxsw_thermal_set_trip_hyst,
418 .get_trend = mlxsw_thermal_trend_get,
419 };
420
421 static int mlxsw_thermal_module_bind(struct thermal_zone_device *tzdev,
422 struct thermal_cooling_device *cdev)
423 {
424 struct mlxsw_thermal_module *tz = tzdev->devdata;
425 struct mlxsw_thermal *thermal = tz->parent;
426 int i, j, err;
427
428 /* If the cooling device is one of ours bind it */
429 if (mlxsw_get_cooling_device_idx(thermal, cdev) < 0)
430 return 0;
431
432 for (i = 0; i < MLXSW_THERMAL_NUM_TRIPS; i++) {
433 const struct mlxsw_thermal_trip *trip = &tz->trips[i];
434
435 err = thermal_zone_bind_cooling_device(tzdev, i, cdev,
436 trip->max_state,
437 trip->min_state,
438 THERMAL_WEIGHT_DEFAULT);
439 if (err < 0)
440 goto err_bind_cooling_device;
441 }
442 return 0;
443
444 err_bind_cooling_device:
445 for (j = i - 1; j >= 0; j--)
446 thermal_zone_unbind_cooling_device(tzdev, j, cdev);
447 return err;
448 }
449
450 static int mlxsw_thermal_module_unbind(struct thermal_zone_device *tzdev,
451 struct thermal_cooling_device *cdev)
452 {
453 struct mlxsw_thermal_module *tz = tzdev->devdata;
454 struct mlxsw_thermal *thermal = tz->parent;
455 int i;
456 int err;
457
458 /* If the cooling device is one of ours unbind it */
459 if (mlxsw_get_cooling_device_idx(thermal, cdev) < 0)
460 return 0;
461
462 for (i = 0; i < MLXSW_THERMAL_NUM_TRIPS; i++) {
463 err = thermal_zone_unbind_cooling_device(tzdev, i, cdev);
464 WARN_ON(err);
465 }
466 return err;
467 }
468
469 static int mlxsw_thermal_module_mode_get(struct thermal_zone_device *tzdev,
470 enum thermal_device_mode *mode)
471 {
472 struct mlxsw_thermal_module *tz = tzdev->devdata;
473
474 *mode = tz->mode;
475
476 return 0;
477 }
478
479 static int mlxsw_thermal_module_mode_set(struct thermal_zone_device *tzdev,
480 enum thermal_device_mode mode)
481 {
482 struct mlxsw_thermal_module *tz = tzdev->devdata;
483 struct mlxsw_thermal *thermal = tz->parent;
484
485 mutex_lock(&tzdev->lock);
486
487 if (mode == THERMAL_DEVICE_ENABLED)
488 tzdev->polling_delay = thermal->polling_delay;
489 else
490 tzdev->polling_delay = 0;
491
492 mutex_unlock(&tzdev->lock);
493
494 tz->mode = mode;
495 thermal_zone_device_update(tzdev, THERMAL_EVENT_UNSPECIFIED);
496
497 return 0;
498 }
499
500 static int mlxsw_thermal_module_temp_get(struct thermal_zone_device *tzdev,
501 int *p_temp)
502 {
503 struct mlxsw_thermal_module *tz = tzdev->devdata;
504 struct mlxsw_thermal *thermal = tz->parent;
505 struct device *dev = thermal->bus_info->dev;
506 char mtmp_pl[MLXSW_REG_MTMP_LEN];
507 int temp;
508 int err;
509
510 /* Read module temperature. */
511 mlxsw_reg_mtmp_pack(mtmp_pl, MLXSW_REG_MTMP_MODULE_INDEX_MIN +
512 tz->module, false, false);
513 err = mlxsw_reg_query(thermal->core, MLXSW_REG(mtmp), mtmp_pl);
514 if (err) {
515 /* Do not return error - in case of broken module's sensor
516 * it will cause error message flooding.
517 */
518 temp = 0;
519 *p_temp = (int) temp;
520 return 0;
521 }
522 mlxsw_reg_mtmp_unpack(mtmp_pl, &temp, NULL, NULL);
523 *p_temp = temp;
524
525 if (!temp)
526 return 0;
527
528 /* Update trip points. */
529 err = mlxsw_thermal_module_trips_update(dev, thermal->core, tz);
530 if (!err && temp > 0)
531 mlxsw_thermal_tz_score_update(thermal, tzdev, tz->trips, temp);
532
533 return 0;
534 }
535
536 static int
537 mlxsw_thermal_module_trip_type_get(struct thermal_zone_device *tzdev, int trip,
538 enum thermal_trip_type *p_type)
539 {
540 struct mlxsw_thermal_module *tz = tzdev->devdata;
541
542 if (trip < 0 || trip >= MLXSW_THERMAL_NUM_TRIPS)
543 return -EINVAL;
544
545 *p_type = tz->trips[trip].type;
546 return 0;
547 }
548
549 static int
550 mlxsw_thermal_module_trip_temp_get(struct thermal_zone_device *tzdev,
551 int trip, int *p_temp)
552 {
553 struct mlxsw_thermal_module *tz = tzdev->devdata;
554
555 if (trip < 0 || trip >= MLXSW_THERMAL_NUM_TRIPS)
556 return -EINVAL;
557
558 *p_temp = tz->trips[trip].temp;
559 return 0;
560 }
561
562 static int
563 mlxsw_thermal_module_trip_temp_set(struct thermal_zone_device *tzdev,
564 int trip, int temp)
565 {
566 struct mlxsw_thermal_module *tz = tzdev->devdata;
567
568 if (trip < 0 || trip >= MLXSW_THERMAL_NUM_TRIPS ||
569 temp > tz->trips[MLXSW_THERMAL_TEMP_TRIP_CRIT].temp)
570 return -EINVAL;
571
572 tz->trips[trip].temp = temp;
573 return 0;
574 }
575
576 static int
577 mlxsw_thermal_module_trip_hyst_get(struct thermal_zone_device *tzdev, int trip,
578 int *p_hyst)
579 {
580 struct mlxsw_thermal_module *tz = tzdev->devdata;
581
582 *p_hyst = tz->trips[trip].hyst;
583 return 0;
584 }
585
586 static int
587 mlxsw_thermal_module_trip_hyst_set(struct thermal_zone_device *tzdev, int trip,
588 int hyst)
589 {
590 struct mlxsw_thermal_module *tz = tzdev->devdata;
591
592 tz->trips[trip].hyst = hyst;
593 return 0;
594 }
595
596 static struct thermal_zone_device_ops mlxsw_thermal_module_ops = {
597 .bind = mlxsw_thermal_module_bind,
598 .unbind = mlxsw_thermal_module_unbind,
599 .get_mode = mlxsw_thermal_module_mode_get,
600 .set_mode = mlxsw_thermal_module_mode_set,
601 .get_temp = mlxsw_thermal_module_temp_get,
602 .get_trip_type = mlxsw_thermal_module_trip_type_get,
603 .get_trip_temp = mlxsw_thermal_module_trip_temp_get,
604 .set_trip_temp = mlxsw_thermal_module_trip_temp_set,
605 .get_trip_hyst = mlxsw_thermal_module_trip_hyst_get,
606 .set_trip_hyst = mlxsw_thermal_module_trip_hyst_set,
607 .get_trend = mlxsw_thermal_trend_get,
608 };
609
610 static int mlxsw_thermal_gearbox_temp_get(struct thermal_zone_device *tzdev,
611 int *p_temp)
612 {
613 struct mlxsw_thermal_module *tz = tzdev->devdata;
614 struct mlxsw_thermal *thermal = tz->parent;
615 char mtmp_pl[MLXSW_REG_MTMP_LEN];
616 u16 index;
617 int temp;
618 int err;
619
620 index = MLXSW_REG_MTMP_GBOX_INDEX_MIN + tz->module;
621 mlxsw_reg_mtmp_pack(mtmp_pl, index, false, false);
622
623 err = mlxsw_reg_query(thermal->core, MLXSW_REG(mtmp), mtmp_pl);
624 if (err)
625 return err;
626
627 mlxsw_reg_mtmp_unpack(mtmp_pl, &temp, NULL, NULL);
628 if (temp > 0)
629 mlxsw_thermal_tz_score_update(thermal, tzdev, tz->trips, temp);
630
631 *p_temp = temp;
632 return 0;
633 }
634
635 static struct thermal_zone_device_ops mlxsw_thermal_gearbox_ops = {
636 .bind = mlxsw_thermal_module_bind,
637 .unbind = mlxsw_thermal_module_unbind,
638 .get_mode = mlxsw_thermal_module_mode_get,
639 .set_mode = mlxsw_thermal_module_mode_set,
640 .get_temp = mlxsw_thermal_gearbox_temp_get,
641 .get_trip_type = mlxsw_thermal_module_trip_type_get,
642 .get_trip_temp = mlxsw_thermal_module_trip_temp_get,
643 .set_trip_temp = mlxsw_thermal_module_trip_temp_set,
644 .get_trip_hyst = mlxsw_thermal_module_trip_hyst_get,
645 .set_trip_hyst = mlxsw_thermal_module_trip_hyst_set,
646 .get_trend = mlxsw_thermal_trend_get,
647 };
648
649 static int mlxsw_thermal_get_max_state(struct thermal_cooling_device *cdev,
650 unsigned long *p_state)
651 {
652 *p_state = MLXSW_THERMAL_MAX_STATE;
653 return 0;
654 }
655
656 static int mlxsw_thermal_get_cur_state(struct thermal_cooling_device *cdev,
657 unsigned long *p_state)
658
659 {
660 struct mlxsw_thermal *thermal = cdev->devdata;
661 struct device *dev = thermal->bus_info->dev;
662 char mfsc_pl[MLXSW_REG_MFSC_LEN];
663 int err, idx;
664 u8 duty;
665
666 idx = mlxsw_get_cooling_device_idx(thermal, cdev);
667 if (idx < 0)
668 return idx;
669
670 mlxsw_reg_mfsc_pack(mfsc_pl, idx, 0);
671 err = mlxsw_reg_query(thermal->core, MLXSW_REG(mfsc), mfsc_pl);
672 if (err) {
673 dev_err(dev, "Failed to query PWM duty\n");
674 return err;
675 }
676
677 duty = mlxsw_reg_mfsc_pwm_duty_cycle_get(mfsc_pl);
678 *p_state = mlxsw_duty_to_state(duty);
679 return 0;
680 }
681
682 static int mlxsw_thermal_set_cur_state(struct thermal_cooling_device *cdev,
683 unsigned long state)
684
685 {
686 struct mlxsw_thermal *thermal = cdev->devdata;
687 struct device *dev = thermal->bus_info->dev;
688 char mfsc_pl[MLXSW_REG_MFSC_LEN];
689 unsigned long cur_state, i;
690 int idx;
691 u8 duty;
692 int err;
693
694 idx = mlxsw_get_cooling_device_idx(thermal, cdev);
695 if (idx < 0)
696 return idx;
697
698 /* Verify if this request is for changing allowed fan dynamical
699 * minimum. If it is - update cooling levels accordingly and update
700 * state, if current state is below the newly requested minimum state.
701 * For example, if current state is 5, and minimal state is to be
702 * changed from 4 to 6, thermal->cooling_levels[0 to 5] will be changed
703 * all from 4 to 6. And state 5 (thermal->cooling_levels[4]) should be
704 * overwritten.
705 */
706 if (state >= MLXSW_THERMAL_SPEED_MIN &&
707 state <= MLXSW_THERMAL_SPEED_MAX) {
708 state -= MLXSW_THERMAL_MAX_STATE;
709 for (i = 0; i <= MLXSW_THERMAL_MAX_STATE; i++)
710 thermal->cooling_levels[i] = max(state, i);
711
712 mlxsw_reg_mfsc_pack(mfsc_pl, idx, 0);
713 err = mlxsw_reg_query(thermal->core, MLXSW_REG(mfsc), mfsc_pl);
714 if (err)
715 return err;
716
717 duty = mlxsw_reg_mfsc_pwm_duty_cycle_get(mfsc_pl);
718 cur_state = mlxsw_duty_to_state(duty);
719
720 /* If current fan state is lower than requested dynamical
721 * minimum, increase fan speed up to dynamical minimum.
722 */
723 if (state < cur_state)
724 return 0;
725
726 state = cur_state;
727 }
728
729 if (state > MLXSW_THERMAL_MAX_STATE)
730 return -EINVAL;
731
732 /* Normalize the state to the valid speed range. */
733 state = thermal->cooling_levels[state];
734 mlxsw_reg_mfsc_pack(mfsc_pl, idx, mlxsw_state_to_duty(state));
735 err = mlxsw_reg_write(thermal->core, MLXSW_REG(mfsc), mfsc_pl);
736 if (err) {
737 dev_err(dev, "Failed to write PWM duty\n");
738 return err;
739 }
740 return 0;
741 }
742
743 static const struct thermal_cooling_device_ops mlxsw_cooling_ops = {
744 .get_max_state = mlxsw_thermal_get_max_state,
745 .get_cur_state = mlxsw_thermal_get_cur_state,
746 .set_cur_state = mlxsw_thermal_set_cur_state,
747 };
748
749 static int
750 mlxsw_thermal_module_tz_init(struct mlxsw_thermal_module *module_tz)
751 {
752 char tz_name[MLXSW_THERMAL_ZONE_MAX_NAME];
753 int err;
754
755 snprintf(tz_name, sizeof(tz_name), "mlxsw-module%d",
756 module_tz->module + 1);
757 module_tz->tzdev = thermal_zone_device_register(tz_name,
758 MLXSW_THERMAL_NUM_TRIPS,
759 MLXSW_THERMAL_TRIP_MASK,
760 module_tz,
761 &mlxsw_thermal_module_ops,
762 NULL, 0, 0);
763 if (IS_ERR(module_tz->tzdev)) {
764 err = PTR_ERR(module_tz->tzdev);
765 return err;
766 }
767
768 module_tz->mode = THERMAL_DEVICE_ENABLED;
769 return 0;
770 }
771
772 static void mlxsw_thermal_module_tz_fini(struct thermal_zone_device *tzdev)
773 {
774 thermal_zone_device_unregister(tzdev);
775 }
776
777 static int
778 mlxsw_thermal_module_init(struct device *dev, struct mlxsw_core *core,
779 struct mlxsw_thermal *thermal, u8 module)
780 {
781 struct mlxsw_thermal_module *module_tz;
782
783 module_tz = &thermal->tz_module_arr[module];
784 /* Skip if parent is already set (case of port split). */
785 if (module_tz->parent)
786 return 0;
787 module_tz->module = module;
788 module_tz->parent = thermal;
789 memcpy(module_tz->trips, default_thermal_trips,
790 sizeof(thermal->trips));
791 /* Initialize all trip point. */
792 mlxsw_thermal_module_trips_reset(module_tz);
793 /* Update trip point according to the module data. */
794 return mlxsw_thermal_module_trips_update(dev, core, module_tz);
795 }
796
797 static void mlxsw_thermal_module_fini(struct mlxsw_thermal_module *module_tz)
798 {
799 if (module_tz && module_tz->tzdev) {
800 mlxsw_thermal_module_tz_fini(module_tz->tzdev);
801 module_tz->tzdev = NULL;
802 module_tz->parent = NULL;
803 }
804 }
805
806 static int
807 mlxsw_thermal_modules_init(struct device *dev, struct mlxsw_core *core,
808 struct mlxsw_thermal *thermal)
809 {
810 struct mlxsw_thermal_module *module_tz;
811 char mgpir_pl[MLXSW_REG_MGPIR_LEN];
812 int i, err;
813
814 if (!mlxsw_core_res_query_enabled(core))
815 return 0;
816
817 mlxsw_reg_mgpir_pack(mgpir_pl);
818 err = mlxsw_reg_query(core, MLXSW_REG(mgpir), mgpir_pl);
819 if (err)
820 return err;
821
822 mlxsw_reg_mgpir_unpack(mgpir_pl, NULL, NULL, NULL,
823 &thermal->tz_module_num);
824
825 thermal->tz_module_arr = kcalloc(thermal->tz_module_num,
826 sizeof(*thermal->tz_module_arr),
827 GFP_KERNEL);
828 if (!thermal->tz_module_arr)
829 return -ENOMEM;
830
831 for (i = 0; i < thermal->tz_module_num; i++) {
832 err = mlxsw_thermal_module_init(dev, core, thermal, i);
833 if (err)
834 goto err_unreg_tz_module_arr;
835 }
836
837 for (i = 0; i < thermal->tz_module_num; i++) {
838 module_tz = &thermal->tz_module_arr[i];
839 if (!module_tz->parent)
840 continue;
841 err = mlxsw_thermal_module_tz_init(module_tz);
842 if (err)
843 goto err_unreg_tz_module_arr;
844 }
845
846 return 0;
847
848 err_unreg_tz_module_arr:
849 for (i = thermal->tz_module_num - 1; i >= 0; i--)
850 mlxsw_thermal_module_fini(&thermal->tz_module_arr[i]);
851 kfree(thermal->tz_module_arr);
852 return err;
853 }
854
855 static void
856 mlxsw_thermal_modules_fini(struct mlxsw_thermal *thermal)
857 {
858 int i;
859
860 if (!mlxsw_core_res_query_enabled(thermal->core))
861 return;
862
863 for (i = thermal->tz_module_num - 1; i >= 0; i--)
864 mlxsw_thermal_module_fini(&thermal->tz_module_arr[i]);
865 kfree(thermal->tz_module_arr);
866 }
867
868 static int
869 mlxsw_thermal_gearbox_tz_init(struct mlxsw_thermal_module *gearbox_tz)
870 {
871 char tz_name[MLXSW_THERMAL_ZONE_MAX_NAME];
872
873 snprintf(tz_name, sizeof(tz_name), "mlxsw-gearbox%d",
874 gearbox_tz->module + 1);
875 gearbox_tz->tzdev = thermal_zone_device_register(tz_name,
876 MLXSW_THERMAL_NUM_TRIPS,
877 MLXSW_THERMAL_TRIP_MASK,
878 gearbox_tz,
879 &mlxsw_thermal_gearbox_ops,
880 NULL, 0, 0);
881 if (IS_ERR(gearbox_tz->tzdev))
882 return PTR_ERR(gearbox_tz->tzdev);
883
884 gearbox_tz->mode = THERMAL_DEVICE_ENABLED;
885 return 0;
886 }
887
888 static void
889 mlxsw_thermal_gearbox_tz_fini(struct mlxsw_thermal_module *gearbox_tz)
890 {
891 thermal_zone_device_unregister(gearbox_tz->tzdev);
892 }
893
894 static int
895 mlxsw_thermal_gearboxes_init(struct device *dev, struct mlxsw_core *core,
896 struct mlxsw_thermal *thermal)
897 {
898 enum mlxsw_reg_mgpir_device_type device_type;
899 struct mlxsw_thermal_module *gearbox_tz;
900 char mgpir_pl[MLXSW_REG_MGPIR_LEN];
901 u8 gbox_num;
902 int i;
903 int err;
904
905 if (!mlxsw_core_res_query_enabled(core))
906 return 0;
907
908 mlxsw_reg_mgpir_pack(mgpir_pl);
909 err = mlxsw_reg_query(core, MLXSW_REG(mgpir), mgpir_pl);
910 if (err)
911 return err;
912
913 mlxsw_reg_mgpir_unpack(mgpir_pl, &gbox_num, &device_type, NULL,
914 NULL);
915 if (device_type != MLXSW_REG_MGPIR_DEVICE_TYPE_GEARBOX_DIE ||
916 !gbox_num)
917 return 0;
918
919 thermal->tz_gearbox_num = gbox_num;
920 thermal->tz_gearbox_arr = kcalloc(thermal->tz_gearbox_num,
921 sizeof(*thermal->tz_gearbox_arr),
922 GFP_KERNEL);
923 if (!thermal->tz_gearbox_arr)
924 return -ENOMEM;
925
926 for (i = 0; i < thermal->tz_gearbox_num; i++) {
927 gearbox_tz = &thermal->tz_gearbox_arr[i];
928 memcpy(gearbox_tz->trips, default_thermal_trips,
929 sizeof(thermal->trips));
930 gearbox_tz->module = i;
931 gearbox_tz->parent = thermal;
932 err = mlxsw_thermal_gearbox_tz_init(gearbox_tz);
933 if (err)
934 goto err_unreg_tz_gearbox;
935 }
936
937 return 0;
938
939 err_unreg_tz_gearbox:
940 for (i--; i >= 0; i--)
941 mlxsw_thermal_gearbox_tz_fini(&thermal->tz_gearbox_arr[i]);
942 kfree(thermal->tz_gearbox_arr);
943 return err;
944 }
945
946 static void
947 mlxsw_thermal_gearboxes_fini(struct mlxsw_thermal *thermal)
948 {
949 int i;
950
951 if (!mlxsw_core_res_query_enabled(thermal->core))
952 return;
953
954 for (i = thermal->tz_gearbox_num - 1; i >= 0; i--)
955 mlxsw_thermal_gearbox_tz_fini(&thermal->tz_gearbox_arr[i]);
956 kfree(thermal->tz_gearbox_arr);
957 }
958
959 int mlxsw_thermal_init(struct mlxsw_core *core,
960 const struct mlxsw_bus_info *bus_info,
961 struct mlxsw_thermal **p_thermal)
962 {
963 char mfcr_pl[MLXSW_REG_MFCR_LEN] = { 0 };
964 enum mlxsw_reg_mfcr_pwm_frequency freq;
965 struct device *dev = bus_info->dev;
966 struct mlxsw_thermal *thermal;
967 u16 tacho_active;
968 u8 pwm_active;
969 int err, i;
970
971 thermal = devm_kzalloc(dev, sizeof(*thermal),
972 GFP_KERNEL);
973 if (!thermal)
974 return -ENOMEM;
975
976 thermal->core = core;
977 thermal->bus_info = bus_info;
978 memcpy(thermal->trips, default_thermal_trips, sizeof(thermal->trips));
979
980 err = mlxsw_reg_query(thermal->core, MLXSW_REG(mfcr), mfcr_pl);
981 if (err) {
982 dev_err(dev, "Failed to probe PWMs\n");
983 goto err_free_thermal;
984 }
985 mlxsw_reg_mfcr_unpack(mfcr_pl, &freq, &tacho_active, &pwm_active);
986
987 for (i = 0; i < MLXSW_MFCR_TACHOS_MAX; i++) {
988 if (tacho_active & BIT(i)) {
989 char mfsl_pl[MLXSW_REG_MFSL_LEN];
990
991 mlxsw_reg_mfsl_pack(mfsl_pl, i, 0, 0);
992
993 /* We need to query the register to preserve maximum */
994 err = mlxsw_reg_query(thermal->core, MLXSW_REG(mfsl),
995 mfsl_pl);
996 if (err)
997 goto err_free_thermal;
998
999 /* set the minimal RPMs to 0 */
1000 mlxsw_reg_mfsl_tach_min_set(mfsl_pl, 0);
1001 err = mlxsw_reg_write(thermal->core, MLXSW_REG(mfsl),
1002 mfsl_pl);
1003 if (err)
1004 goto err_free_thermal;
1005 }
1006 }
1007 for (i = 0; i < MLXSW_MFCR_PWMS_MAX; i++) {
1008 if (pwm_active & BIT(i)) {
1009 struct thermal_cooling_device *cdev;
1010
1011 cdev = thermal_cooling_device_register("mlxsw_fan",
1012 thermal,
1013 &mlxsw_cooling_ops);
1014 if (IS_ERR(cdev)) {
1015 err = PTR_ERR(cdev);
1016 dev_err(dev, "Failed to register cooling device\n");
1017 goto err_unreg_cdevs;
1018 }
1019 thermal->cdevs[i] = cdev;
1020 }
1021 }
1022
1023 /* Initialize cooling levels per PWM state. */
1024 for (i = 0; i < MLXSW_THERMAL_MAX_STATE; i++)
1025 thermal->cooling_levels[i] = max(MLXSW_THERMAL_SPEED_MIN_LEVEL,
1026 i);
1027
1028 thermal->polling_delay = bus_info->low_frequency ?
1029 MLXSW_THERMAL_SLOW_POLL_INT :
1030 MLXSW_THERMAL_POLL_INT;
1031
1032 thermal->tzdev = thermal_zone_device_register("mlxsw",
1033 MLXSW_THERMAL_NUM_TRIPS,
1034 MLXSW_THERMAL_TRIP_MASK,
1035 thermal,
1036 &mlxsw_thermal_ops,
1037 NULL, 0,
1038 thermal->polling_delay);
1039 if (IS_ERR(thermal->tzdev)) {
1040 err = PTR_ERR(thermal->tzdev);
1041 dev_err(dev, "Failed to register thermal zone\n");
1042 goto err_unreg_cdevs;
1043 }
1044
1045 err = mlxsw_thermal_modules_init(dev, core, thermal);
1046 if (err)
1047 goto err_unreg_tzdev;
1048
1049 err = mlxsw_thermal_gearboxes_init(dev, core, thermal);
1050 if (err)
1051 goto err_unreg_modules_tzdev;
1052
1053 thermal->mode = THERMAL_DEVICE_ENABLED;
1054 *p_thermal = thermal;
1055 return 0;
1056
1057 err_unreg_modules_tzdev:
1058 mlxsw_thermal_modules_fini(thermal);
1059 err_unreg_tzdev:
1060 if (thermal->tzdev) {
1061 thermal_zone_device_unregister(thermal->tzdev);
1062 thermal->tzdev = NULL;
1063 }
1064 err_unreg_cdevs:
1065 for (i = 0; i < MLXSW_MFCR_PWMS_MAX; i++)
1066 if (thermal->cdevs[i])
1067 thermal_cooling_device_unregister(thermal->cdevs[i]);
1068 err_free_thermal:
1069 devm_kfree(dev, thermal);
1070 return err;
1071 }
1072
1073 void mlxsw_thermal_fini(struct mlxsw_thermal *thermal)
1074 {
1075 int i;
1076
1077 mlxsw_thermal_gearboxes_fini(thermal);
1078 mlxsw_thermal_modules_fini(thermal);
1079 if (thermal->tzdev) {
1080 thermal_zone_device_unregister(thermal->tzdev);
1081 thermal->tzdev = NULL;
1082 }
1083
1084 for (i = 0; i < MLXSW_MFCR_PWMS_MAX; i++) {
1085 if (thermal->cdevs[i]) {
1086 thermal_cooling_device_unregister(thermal->cdevs[i]);
1087 thermal->cdevs[i] = NULL;
1088 }
1089 }
1090
1091 devm_kfree(thermal->bus_info->dev, thermal);
1092 }
Linux with added FPC-III support