1// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) 2// 3// Copyright (c) 2018 Mellanox Technologies. All rights reserved. 4// Copyright (c) 2018 Vadim Pasternak <vadimp@mellanox.com> 5 6#include <linux/bitops.h> 7#include <linux/device.h> 8#include <linux/hwmon.h> 9#include <linux/module.h> 10#include <linux/platform_data/mlxreg.h> 11#include <linux/platform_device.h> 12#include <linux/regmap.h> 13#include <linux/thermal.h> 14 15#define MLXREG_FAN_MAX_TACHO 12 16#define MLXREG_FAN_MAX_STATE 10 17#define MLXREG_FAN_MIN_DUTY 51 /* 20% */ 18#define MLXREG_FAN_MAX_DUTY 255 /* 100% */ 19/* 20 * Minimum and maximum FAN allowed speed in percent: from 20% to 100%. Values 21 * MLXREG_FAN_MAX_STATE + x, where x is between 2 and 10 are used for 22 * setting FAN speed dynamic minimum. For example, if value is set to 14 (40%) 23 * cooling levels vector will be set to 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10 to 24 * introduce PWM speed in percent: 40, 40, 40, 40, 40, 50, 60. 70, 80, 90, 100. 25 */ 26#define MLXREG_FAN_SPEED_MIN (MLXREG_FAN_MAX_STATE + 2) 27#define MLXREG_FAN_SPEED_MAX (MLXREG_FAN_MAX_STATE * 2) 28#define MLXREG_FAN_SPEED_MIN_LEVEL 2 /* 20 percent */ 29#define MLXREG_FAN_TACHO_SAMPLES_PER_PULSE_DEF 44 30#define MLXREG_FAN_TACHO_DIV_MIN 283 31#define MLXREG_FAN_TACHO_DIV_DEF (MLXREG_FAN_TACHO_DIV_MIN * 4) 32#define MLXREG_FAN_TACHO_DIV_SCALE_MAX 64 33/* 34 * FAN datasheet defines the formula for RPM calculations as RPM = 15/t-high. 35 * The logic in a programmable device measures the time t-high by sampling the 36 * tachometer every t-sample (with the default value 11.32 uS) and increment 37 * a counter (N) as long as the pulse has not change: 38 * RPM = 15 / (t-sample * (K + Regval)), where: 39 * Regval: is the value read from the programmable device register; 40 * - 0xff - represents tachometer fault; 41 * - 0xfe - represents tachometer minimum value , which is 4444 RPM; 42 * - 0x00 - represents tachometer maximum value , which is 300000 RPM; 43 * K: is 44 and it represents the minimum allowed samples per pulse; 44 * N: is equal K + Regval; 45 * In order to calculate RPM from the register value the following formula is 46 * used: RPM = 15 / ((Regval + K) * 11.32) * 10^(-6)), which in the 47 * default case is modified to: 48 * RPM = 15000000 * 100 / ((Regval + 44) * 1132); 49 * - for Regval 0x00, RPM will be 15000000 * 100 / (44 * 1132) = 30115; 50 * - for Regval 0xfe, RPM will be 15000000 * 100 / ((254 + 44) * 1132) = 4446; 51 * In common case the formula is modified to: 52 * RPM = 15000000 * 100 / ((Regval + samples) * divider). 53 */ 54#define MLXREG_FAN_GET_RPM(rval, d, s) (DIV_ROUND_CLOSEST(15000000 * 100, \ 55 ((rval) + (s)) * (d))) 56#define MLXREG_FAN_GET_FAULT(val, mask) ((val) == (mask)) 57#define MLXREG_FAN_PWM_DUTY2STATE(duty) (DIV_ROUND_CLOSEST((duty) * \ 58 MLXREG_FAN_MAX_STATE, \ 59 MLXREG_FAN_MAX_DUTY)) 60#define MLXREG_FAN_PWM_STATE2DUTY(stat) (DIV_ROUND_CLOSEST((stat) * \ 61 MLXREG_FAN_MAX_DUTY, \ 62 MLXREG_FAN_MAX_STATE)) 63 64/* 65 * struct mlxreg_fan_tacho - tachometer data (internal use): 66 * 67 * @connected: indicates if tachometer is connected; 68 * @reg: register offset; 69 * @mask: fault mask; 70 */ 71struct mlxreg_fan_tacho { 72 bool connected; 73 u32 reg; 74 u32 mask; 75}; 76 77/* 78 * struct mlxreg_fan_pwm - PWM data (internal use): 79 * 80 * @connected: indicates if PWM is connected; 81 * @reg: register offset; 82 */ 83struct mlxreg_fan_pwm { 84 bool connected; 85 u32 reg; 86}; 87 88/* 89 * struct mlxreg_fan - private data (internal use): 90 * 91 * @dev: basic device; 92 * @regmap: register map of parent device; 93 * @tacho: tachometer data; 94 * @pwm: PWM data; 95 * @samples: minimum allowed samples per pulse; 96 * @divider: divider value for tachometer RPM calculation; 97 * @cooling: cooling device levels; 98 * @cdev: cooling device; 99 */ 100struct mlxreg_fan { 101 struct device *dev; 102 void *regmap; 103 struct mlxreg_core_platform_data *pdata; 104 struct mlxreg_fan_tacho tacho[MLXREG_FAN_MAX_TACHO]; 105 struct mlxreg_fan_pwm pwm; 106 int samples; 107 int divider; 108 u8 cooling_levels[MLXREG_FAN_MAX_STATE + 1]; 109 struct thermal_cooling_device *cdev; 110}; 111 112static int 113mlxreg_fan_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 114 int channel, long *val) 115{ 116 struct mlxreg_fan *fan = dev_get_drvdata(dev); 117 struct mlxreg_fan_tacho *tacho; 118 u32 regval; 119 int err; 120 121 switch (type) { 122 case hwmon_fan: 123 tacho = &fan->tacho[channel]; 124 switch (attr) { 125 case hwmon_fan_input: 126 err = regmap_read(fan->regmap, tacho->reg, ®val); 127 if (err) 128 return err; 129 130 if (MLXREG_FAN_GET_FAULT(regval, tacho->mask)) { 131 /* FAN is broken - return zero for FAN speed. */ 132 *val = 0; 133 return 0; 134 } 135 136 *val = MLXREG_FAN_GET_RPM(regval, fan->divider, 137 fan->samples); 138 break; 139 140 case hwmon_fan_fault: 141 err = regmap_read(fan->regmap, tacho->reg, ®val); 142 if (err) 143 return err; 144 145 *val = MLXREG_FAN_GET_FAULT(regval, tacho->mask); 146 break; 147 148 default: 149 return -EOPNOTSUPP; 150 } 151 break; 152 153 case hwmon_pwm: 154 switch (attr) { 155 case hwmon_pwm_input: 156 err = regmap_read(fan->regmap, fan->pwm.reg, ®val); 157 if (err) 158 return err; 159 160 *val = regval; 161 break; 162 163 default: 164 return -EOPNOTSUPP; 165 } 166 break; 167 168 default: 169 return -EOPNOTSUPP; 170 } 171 172 return 0; 173} 174 175static int 176mlxreg_fan_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, 177 int channel, long val) 178{ 179 struct mlxreg_fan *fan = dev_get_drvdata(dev); 180 181 switch (type) { 182 case hwmon_pwm: 183 switch (attr) { 184 case hwmon_pwm_input: 185 if (val < MLXREG_FAN_MIN_DUTY || 186 val > MLXREG_FAN_MAX_DUTY) 187 return -EINVAL; 188 return regmap_write(fan->regmap, fan->pwm.reg, val); 189 default: 190 return -EOPNOTSUPP; 191 } 192 break; 193 194 default: 195 return -EOPNOTSUPP; 196 } 197 198 return -EOPNOTSUPP; 199} 200 201static umode_t 202mlxreg_fan_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, 203 int channel) 204{ 205 switch (type) { 206 case hwmon_fan: 207 if (!(((struct mlxreg_fan *)data)->tacho[channel].connected)) 208 return 0; 209 210 switch (attr) { 211 case hwmon_fan_input: 212 case hwmon_fan_fault: 213 return 0444; 214 default: 215 break; 216 } 217 break; 218 219 case hwmon_pwm: 220 if (!(((struct mlxreg_fan *)data)->pwm.connected)) 221 return 0; 222 223 switch (attr) { 224 case hwmon_pwm_input: 225 return 0644; 226 default: 227 break; 228 } 229 break; 230 231 default: 232 break; 233 } 234 235 return 0; 236} 237 238static const struct hwmon_channel_info *mlxreg_fan_hwmon_info[] = { 239 HWMON_CHANNEL_INFO(fan, 240 HWMON_F_INPUT | HWMON_F_FAULT, 241 HWMON_F_INPUT | HWMON_F_FAULT, 242 HWMON_F_INPUT | HWMON_F_FAULT, 243 HWMON_F_INPUT | HWMON_F_FAULT, 244 HWMON_F_INPUT | HWMON_F_FAULT, 245 HWMON_F_INPUT | HWMON_F_FAULT, 246 HWMON_F_INPUT | HWMON_F_FAULT, 247 HWMON_F_INPUT | HWMON_F_FAULT, 248 HWMON_F_INPUT | HWMON_F_FAULT, 249 HWMON_F_INPUT | HWMON_F_FAULT, 250 HWMON_F_INPUT | HWMON_F_FAULT, 251 HWMON_F_INPUT | HWMON_F_FAULT), 252 HWMON_CHANNEL_INFO(pwm, 253 HWMON_PWM_INPUT), 254 NULL 255}; 256 257static const struct hwmon_ops mlxreg_fan_hwmon_hwmon_ops = { 258 .is_visible = mlxreg_fan_is_visible, 259 .read = mlxreg_fan_read, 260 .write = mlxreg_fan_write, 261}; 262 263static const struct hwmon_chip_info mlxreg_fan_hwmon_chip_info = { 264 .ops = &mlxreg_fan_hwmon_hwmon_ops, 265 .info = mlxreg_fan_hwmon_info, 266}; 267 268static int mlxreg_fan_get_max_state(struct thermal_cooling_device *cdev, 269 unsigned long *state) 270{ 271 *state = MLXREG_FAN_MAX_STATE; 272 return 0; 273} 274 275static int mlxreg_fan_get_cur_state(struct thermal_cooling_device *cdev, 276 unsigned long *state) 277 278{ 279 struct mlxreg_fan *fan = cdev->devdata; 280 u32 regval; 281 int err; 282 283 err = regmap_read(fan->regmap, fan->pwm.reg, ®val); 284 if (err) { 285 dev_err(fan->dev, "Failed to query PWM duty\n"); 286 return err; 287 } 288 289 *state = MLXREG_FAN_PWM_DUTY2STATE(regval); 290 291 return 0; 292} 293 294static int mlxreg_fan_set_cur_state(struct thermal_cooling_device *cdev, 295 unsigned long state) 296 297{ 298 struct mlxreg_fan *fan = cdev->devdata; 299 unsigned long cur_state; 300 int i, config = 0; 301 u32 regval; 302 int err; 303 304 /* 305 * Verify if this request is for changing allowed FAN dynamical 306 * minimum. If it is - update cooling levels accordingly and update 307 * state, if current state is below the newly requested minimum state. 308 * For example, if current state is 5, and minimal state is to be 309 * changed from 4 to 6, fan->cooling_levels[0 to 5] will be changed all 310 * from 4 to 6. And state 5 (fan->cooling_levels[4]) should be 311 * overwritten. 312 */ 313 if (state >= MLXREG_FAN_SPEED_MIN && state <= MLXREG_FAN_SPEED_MAX) { 314 /* 315 * This is configuration change, which is only supported through sysfs. 316 * For configuration non-zero value is to be returned to avoid thermal 317 * statistics update. 318 */ 319 config = 1; 320 state -= MLXREG_FAN_MAX_STATE; 321 for (i = 0; i < state; i++) 322 fan->cooling_levels[i] = state; 323 for (i = state; i <= MLXREG_FAN_MAX_STATE; i++) 324 fan->cooling_levels[i] = i; 325 326 err = regmap_read(fan->regmap, fan->pwm.reg, ®val); 327 if (err) { 328 dev_err(fan->dev, "Failed to query PWM duty\n"); 329 return err; 330 } 331 332 cur_state = MLXREG_FAN_PWM_DUTY2STATE(regval); 333 if (state < cur_state) 334 return config; 335 336 state = cur_state; 337 } 338 339 if (state > MLXREG_FAN_MAX_STATE) 340 return -EINVAL; 341 342 /* Normalize the state to the valid speed range. */ 343 state = fan->cooling_levels[state]; 344 err = regmap_write(fan->regmap, fan->pwm.reg, 345 MLXREG_FAN_PWM_STATE2DUTY(state)); 346 if (err) { 347 dev_err(fan->dev, "Failed to write PWM duty\n"); 348 return err; 349 } 350 return config; 351} 352 353static const struct thermal_cooling_device_ops mlxreg_fan_cooling_ops = { 354 .get_max_state = mlxreg_fan_get_max_state, 355 .get_cur_state = mlxreg_fan_get_cur_state, 356 .set_cur_state = mlxreg_fan_set_cur_state, 357}; 358 359static int mlxreg_fan_connect_verify(struct mlxreg_fan *fan, 360 struct mlxreg_core_data *data) 361{ 362 u32 regval; 363 int err; 364 365 err = regmap_read(fan->regmap, data->capability, ®val); 366 if (err) { 367 dev_err(fan->dev, "Failed to query capability register 0x%08x\n", 368 data->capability); 369 return err; 370 } 371 372 return !!(regval & data->bit); 373} 374 375static int mlxreg_fan_speed_divider_get(struct mlxreg_fan *fan, 376 struct mlxreg_core_data *data) 377{ 378 u32 regval; 379 int err; 380 381 err = regmap_read(fan->regmap, data->capability, ®val); 382 if (err) { 383 dev_err(fan->dev, "Failed to query capability register 0x%08x\n", 384 data->capability); 385 return err; 386 } 387 388 /* 389 * Set divider value according to the capability register, in case it 390 * contains valid value. Otherwise use default value. The purpose of 391 * this validation is to protect against the old hardware, in which 392 * this register can return zero. 393 */ 394 if (regval > 0 && regval <= MLXREG_FAN_TACHO_DIV_SCALE_MAX) 395 fan->divider = regval * MLXREG_FAN_TACHO_DIV_MIN; 396 397 return 0; 398} 399 400static int mlxreg_fan_config(struct mlxreg_fan *fan, 401 struct mlxreg_core_platform_data *pdata) 402{ 403 struct mlxreg_core_data *data = pdata->data; 404 bool configured = false; 405 int tacho_num = 0, i; 406 int err; 407 408 fan->samples = MLXREG_FAN_TACHO_SAMPLES_PER_PULSE_DEF; 409 fan->divider = MLXREG_FAN_TACHO_DIV_DEF; 410 for (i = 0; i < pdata->counter; i++, data++) { 411 if (strnstr(data->label, "tacho", sizeof(data->label))) { 412 if (tacho_num == MLXREG_FAN_MAX_TACHO) { 413 dev_err(fan->dev, "too many tacho entries: %s\n", 414 data->label); 415 return -EINVAL; 416 } 417 418 if (data->capability) { 419 err = mlxreg_fan_connect_verify(fan, data); 420 if (err < 0) 421 return err; 422 else if (!err) { 423 tacho_num++; 424 continue; 425 } 426 } 427 428 fan->tacho[tacho_num].reg = data->reg; 429 fan->tacho[tacho_num].mask = data->mask; 430 fan->tacho[tacho_num++].connected = true; 431 } else if (strnstr(data->label, "pwm", sizeof(data->label))) { 432 if (fan->pwm.connected) { 433 dev_err(fan->dev, "duplicate pwm entry: %s\n", 434 data->label); 435 return -EINVAL; 436 } 437 fan->pwm.reg = data->reg; 438 fan->pwm.connected = true; 439 } else if (strnstr(data->label, "conf", sizeof(data->label))) { 440 if (configured) { 441 dev_err(fan->dev, "duplicate conf entry: %s\n", 442 data->label); 443 return -EINVAL; 444 } 445 /* Validate that conf parameters are not zeros. */ 446 if (!data->mask && !data->bit && !data->capability) { 447 dev_err(fan->dev, "invalid conf entry params: %s\n", 448 data->label); 449 return -EINVAL; 450 } 451 if (data->capability) { 452 err = mlxreg_fan_speed_divider_get(fan, data); 453 if (err) 454 return err; 455 } else { 456 if (data->mask) 457 fan->samples = data->mask; 458 if (data->bit) 459 fan->divider = data->bit; 460 } 461 configured = true; 462 } else { 463 dev_err(fan->dev, "invalid label: %s\n", data->label); 464 return -EINVAL; 465 } 466 } 467 468 /* Init cooling levels per PWM state. */ 469 for (i = 0; i < MLXREG_FAN_SPEED_MIN_LEVEL; i++) 470 fan->cooling_levels[i] = MLXREG_FAN_SPEED_MIN_LEVEL; 471 for (i = MLXREG_FAN_SPEED_MIN_LEVEL; i <= MLXREG_FAN_MAX_STATE; i++) 472 fan->cooling_levels[i] = i; 473 474 return 0; 475} 476 477static int mlxreg_fan_probe(struct platform_device *pdev) 478{ 479 struct mlxreg_core_platform_data *pdata; 480 struct device *dev = &pdev->dev; 481 struct mlxreg_fan *fan; 482 struct device *hwm; 483 int err; 484 485 pdata = dev_get_platdata(dev); 486 if (!pdata) { 487 dev_err(dev, "Failed to get platform data.\n"); 488 return -EINVAL; 489 } 490 491 fan = devm_kzalloc(dev, sizeof(*fan), GFP_KERNEL); 492 if (!fan) 493 return -ENOMEM; 494 495 fan->dev = dev; 496 fan->regmap = pdata->regmap; 497 498 err = mlxreg_fan_config(fan, pdata); 499 if (err) 500 return err; 501 502 hwm = devm_hwmon_device_register_with_info(dev, "mlxreg_fan", 503 fan, 504 &mlxreg_fan_hwmon_chip_info, 505 NULL); 506 if (IS_ERR(hwm)) { 507 dev_err(dev, "Failed to register hwmon device\n"); 508 return PTR_ERR(hwm); 509 } 510 511 if (IS_REACHABLE(CONFIG_THERMAL)) { 512 fan->cdev = devm_thermal_of_cooling_device_register(dev, 513 NULL, "mlxreg_fan", fan, &mlxreg_fan_cooling_ops); 514 if (IS_ERR(fan->cdev)) { 515 dev_err(dev, "Failed to register cooling device\n"); 516 return PTR_ERR(fan->cdev); 517 } 518 } 519 520 return 0; 521} 522 523static struct platform_driver mlxreg_fan_driver = { 524 .driver = { 525 .name = "mlxreg-fan", 526 }, 527 .probe = mlxreg_fan_probe, 528}; 529 530module_platform_driver(mlxreg_fan_driver); 531 532MODULE_AUTHOR("Vadim Pasternak <vadimp@mellanox.com>"); 533MODULE_DESCRIPTION("Mellanox FAN driver"); 534MODULE_LICENSE("GPL"); 535MODULE_ALIAS("platform:mlxreg-fan"); 536