mlxreg-fan.c 14 KB

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