1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Hardware monitoring driver for EMC2305 fan controller
4 *
5 * Copyright (C) 2022 Nvidia Technologies Ltd.
6 */
7
8 #include <linux/err.h>
9 #include <linux/hwmon.h>
10 #include <linux/i2c.h>
11 #include <linux/module.h>
12 #include <linux/platform_data/emc2305.h>
13 #include <linux/thermal.h>
14
15 static const unsigned short
16 emc2305_normal_i2c[] = { 0x27, 0x2c, 0x2d, 0x2e, 0x2f, 0x4c, 0x4d, I2C_CLIENT_END };
17
18 #define EMC2305_REG_DRIVE_FAIL_STATUS 0x27
19 #define EMC2305_REG_DEVICE 0xfd
20 #define EMC2305_REG_VENDOR 0xfe
21 #define EMC2305_FAN_MAX 0xff
22 #define EMC2305_FAN_MIN 0x00
23 #define EMC2305_FAN_MAX_STATE 10
24 #define EMC2305_DEVICE 0x34
25 #define EMC2305_VENDOR 0x5d
26 #define EMC2305_REG_PRODUCT_ID 0xfd
27 #define EMC2305_TACH_REGS_UNUSE_BITS 3
28 #define EMC2305_TACH_CNT_MULTIPLIER 0x02
29 #define EMC2305_TACH_RANGE_MIN 480
30
31 #define EMC2305_PWM_DUTY2STATE(duty, max_state, pwm_max) \
32 DIV_ROUND_CLOSEST((duty) * (max_state), (pwm_max))
33 #define EMC2305_PWM_STATE2DUTY(state, max_state, pwm_max) \
34 DIV_ROUND_CLOSEST((state) * (pwm_max), (max_state))
35
36 /*
37 * Factor by equations [2] and [3] from data sheet; valid for fans where the number of edges
38 * equal (poles * 2 + 1).
39 */
40 #define EMC2305_RPM_FACTOR 3932160
41
42 #define EMC2305_REG_FAN_DRIVE(n) (0x30 + 0x10 * (n))
43 #define EMC2305_REG_FAN_MIN_DRIVE(n) (0x38 + 0x10 * (n))
44 #define EMC2305_REG_FAN_TACH(n) (0x3e + 0x10 * (n))
45
46 enum emc230x_product_id {
47 EMC2305 = 0x34,
48 EMC2303 = 0x35,
49 EMC2302 = 0x36,
50 EMC2301 = 0x37,
51 };
52
53 static const struct i2c_device_id emc2305_ids[] = {
54 { "emc2305", 0 },
55 { "emc2303", 0 },
56 { "emc2302", 0 },
57 { "emc2301", 0 },
58 { }
59 };
60 MODULE_DEVICE_TABLE(i2c, emc2305_ids);
61
62 /**
63 * @cdev: cooling device;
64 * @curr_state: cooling current state;
65 * @last_hwmon_state: last cooling state updated by hwmon subsystem;
66 * @last_thermal_state: last cooling state updated by thermal subsystem;
67 *
68 * The 'last_hwmon_state' and 'last_thermal_state' fields are provided to support fan low limit
69 * speed feature. The purpose of this feature is to provides ability to limit fan speed
70 * according to some system wise considerations, like absence of some replaceable units (PSU or
71 * line cards), high system ambient temperature, unreliable transceivers temperature sensing or
72 * some other factors which indirectly impacts system's airflow
73 * Fan low limit feature is supported through 'hwmon' interface: 'hwmon' 'pwm' attribute is
74 * used for setting low limit for fan speed in case 'thermal' subsystem is configured in
75 * kernel. In this case setting fan speed through 'hwmon' will never let the 'thermal'
76 * subsystem to select a lower duty cycle than the duty cycle selected with the 'pwm'
77 * attribute.
78 * From other side, fan speed is to be updated in hardware through 'pwm' only in case the
79 * requested fan speed is above last speed set by 'thermal' subsystem, otherwise requested fan
80 * speed will be just stored with no PWM update.
81 */
82 struct emc2305_cdev_data {
83 struct thermal_cooling_device *cdev;
84 unsigned int cur_state;
85 unsigned long last_hwmon_state;
86 unsigned long last_thermal_state;
87 };
88
89 /**
90 * @client: i2c client;
91 * @hwmon_dev: hwmon device;
92 * @max_state: maximum cooling state of the cooling device;
93 * @pwm_num: number of PWM channels;
94 * @pwm_separate: separate PWM settings for every channel;
95 * @pwm_min: array of minimum PWM per channel;
96 * @cdev_data: array of cooling devices data;
97 */
98 struct emc2305_data {
99 struct i2c_client *client;
100 struct device *hwmon_dev;
101 u8 max_state;
102 u8 pwm_num;
103 bool pwm_separate;
104 u8 pwm_min[EMC2305_PWM_MAX];
105 struct emc2305_cdev_data cdev_data[EMC2305_PWM_MAX];
106 };
107
108 static char *emc2305_fan_name[] = {
109 "emc2305_fan",
110 "emc2305_fan1",
111 "emc2305_fan2",
112 "emc2305_fan3",
113 "emc2305_fan4",
114 "emc2305_fan5",
115 };
116
117 static void emc2305_unset_tz(struct device *dev);
118
emc2305_get_max_channel(const struct emc2305_data * data)119 static int emc2305_get_max_channel(const struct emc2305_data *data)
120 {
121 return data->pwm_num;
122 }
123
emc2305_get_cdev_idx(struct thermal_cooling_device * cdev)124 static int emc2305_get_cdev_idx(struct thermal_cooling_device *cdev)
125 {
126 struct emc2305_data *data = cdev->devdata;
127 size_t len = strlen(cdev->type);
128 int ret;
129
130 if (len <= 0)
131 return -EINVAL;
132
133 /*
134 * Returns index of cooling device 0..4 in case of separate PWM setting.
135 * Zero index is used in case of one common PWM setting.
136 * If the mode is not set as pwm_separate, all PWMs are to be bound
137 * to the common thermal zone and should work at the same speed
138 * to perform cooling for the same thermal junction.
139 * Otherwise, return specific channel that will be used in bound
140 * related PWM to the thermal zone.
141 */
142 if (!data->pwm_separate)
143 return 0;
144
145 ret = cdev->type[len - 1];
146 switch (ret) {
147 case '1' ... '5':
148 return ret - '1';
149 default:
150 break;
151 }
152 return -EINVAL;
153 }
154
emc2305_get_cur_state(struct thermal_cooling_device * cdev,unsigned long * state)155 static int emc2305_get_cur_state(struct thermal_cooling_device *cdev, unsigned long *state)
156 {
157 int cdev_idx;
158 struct emc2305_data *data = cdev->devdata;
159
160 cdev_idx = emc2305_get_cdev_idx(cdev);
161 if (cdev_idx < 0)
162 return cdev_idx;
163
164 *state = data->cdev_data[cdev_idx].cur_state;
165 return 0;
166 }
167
emc2305_get_max_state(struct thermal_cooling_device * cdev,unsigned long * state)168 static int emc2305_get_max_state(struct thermal_cooling_device *cdev, unsigned long *state)
169 {
170 struct emc2305_data *data = cdev->devdata;
171 *state = data->max_state;
172 return 0;
173 }
174
emc2305_set_cur_state(struct thermal_cooling_device * cdev,unsigned long state)175 static int emc2305_set_cur_state(struct thermal_cooling_device *cdev, unsigned long state)
176 {
177 int cdev_idx, ret;
178 struct emc2305_data *data = cdev->devdata;
179 struct i2c_client *client = data->client;
180 u8 val, i;
181
182 if (state > data->max_state)
183 return -EINVAL;
184
185 cdev_idx = emc2305_get_cdev_idx(cdev);
186 if (cdev_idx < 0)
187 return cdev_idx;
188
189 /* Save thermal state. */
190 data->cdev_data[cdev_idx].last_thermal_state = state;
191 state = max_t(unsigned long, state, data->cdev_data[cdev_idx].last_hwmon_state);
192
193 val = EMC2305_PWM_STATE2DUTY(state, data->max_state, EMC2305_FAN_MAX);
194
195 data->cdev_data[cdev_idx].cur_state = state;
196 if (data->pwm_separate) {
197 ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_DRIVE(cdev_idx), val);
198 if (ret < 0)
199 return ret;
200 } else {
201 /*
202 * Set the same PWM value in all channels
203 * if common PWM channel is used.
204 */
205 for (i = 0; i < data->pwm_num; i++) {
206 ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_DRIVE(i), val);
207 if (ret < 0)
208 return ret;
209 }
210 }
211
212 return 0;
213 }
214
215 static const struct thermal_cooling_device_ops emc2305_cooling_ops = {
216 .get_max_state = emc2305_get_max_state,
217 .get_cur_state = emc2305_get_cur_state,
218 .set_cur_state = emc2305_set_cur_state,
219 };
220
emc2305_show_fault(struct device * dev,int channel)221 static int emc2305_show_fault(struct device *dev, int channel)
222 {
223 struct emc2305_data *data = dev_get_drvdata(dev);
224 struct i2c_client *client = data->client;
225 int status_reg;
226
227 status_reg = i2c_smbus_read_byte_data(client, EMC2305_REG_DRIVE_FAIL_STATUS);
228 if (status_reg < 0)
229 return status_reg;
230
231 return status_reg & (1 << channel) ? 1 : 0;
232 }
233
emc2305_show_fan(struct device * dev,int channel)234 static int emc2305_show_fan(struct device *dev, int channel)
235 {
236 struct emc2305_data *data = dev_get_drvdata(dev);
237 struct i2c_client *client = data->client;
238 int ret;
239
240 ret = i2c_smbus_read_word_swapped(client, EMC2305_REG_FAN_TACH(channel));
241 if (ret <= 0)
242 return ret;
243
244 ret = ret >> EMC2305_TACH_REGS_UNUSE_BITS;
245 ret = EMC2305_RPM_FACTOR / ret;
246 if (ret <= EMC2305_TACH_RANGE_MIN)
247 return 0;
248
249 return ret * EMC2305_TACH_CNT_MULTIPLIER;
250 }
251
emc2305_show_pwm(struct device * dev,int channel)252 static int emc2305_show_pwm(struct device *dev, int channel)
253 {
254 struct emc2305_data *data = dev_get_drvdata(dev);
255 struct i2c_client *client = data->client;
256
257 return i2c_smbus_read_byte_data(client, EMC2305_REG_FAN_DRIVE(channel));
258 }
259
emc2305_set_pwm(struct device * dev,long val,int channel)260 static int emc2305_set_pwm(struct device *dev, long val, int channel)
261 {
262 struct emc2305_data *data = dev_get_drvdata(dev);
263 struct i2c_client *client = data->client;
264 int ret;
265
266 if (val < data->pwm_min[channel] || val > EMC2305_FAN_MAX)
267 return -EINVAL;
268
269 ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_DRIVE(channel), val);
270 if (ret < 0)
271 return ret;
272 data->cdev_data[channel].cur_state = EMC2305_PWM_DUTY2STATE(val, data->max_state,
273 EMC2305_FAN_MAX);
274 return 0;
275 }
276
emc2305_set_single_tz(struct device * dev,int idx)277 static int emc2305_set_single_tz(struct device *dev, int idx)
278 {
279 struct emc2305_data *data = dev_get_drvdata(dev);
280 long pwm;
281 int i, cdev_idx, ret;
282
283 cdev_idx = (idx) ? idx - 1 : 0;
284 pwm = data->pwm_min[cdev_idx];
285
286 data->cdev_data[cdev_idx].cdev =
287 thermal_cooling_device_register(emc2305_fan_name[idx], data,
288 &emc2305_cooling_ops);
289
290 if (IS_ERR(data->cdev_data[cdev_idx].cdev)) {
291 dev_err(dev, "Failed to register cooling device %s\n", emc2305_fan_name[idx]);
292 return PTR_ERR(data->cdev_data[cdev_idx].cdev);
293 }
294 /* Set minimal PWM speed. */
295 if (data->pwm_separate) {
296 ret = emc2305_set_pwm(dev, pwm, cdev_idx);
297 if (ret < 0)
298 return ret;
299 } else {
300 for (i = 0; i < data->pwm_num; i++) {
301 ret = emc2305_set_pwm(dev, pwm, i);
302 if (ret < 0)
303 return ret;
304 }
305 }
306 data->cdev_data[cdev_idx].cur_state =
307 EMC2305_PWM_DUTY2STATE(data->pwm_min[cdev_idx], data->max_state,
308 EMC2305_FAN_MAX);
309 data->cdev_data[cdev_idx].last_hwmon_state =
310 EMC2305_PWM_DUTY2STATE(data->pwm_min[cdev_idx], data->max_state,
311 EMC2305_FAN_MAX);
312 return 0;
313 }
314
emc2305_set_tz(struct device * dev)315 static int emc2305_set_tz(struct device *dev)
316 {
317 struct emc2305_data *data = dev_get_drvdata(dev);
318 int i, ret;
319
320 if (!data->pwm_separate)
321 return emc2305_set_single_tz(dev, 0);
322
323 for (i = 0; i < data->pwm_num; i++) {
324 ret = emc2305_set_single_tz(dev, i + 1);
325 if (ret)
326 goto thermal_cooling_device_register_fail;
327 }
328 return 0;
329
330 thermal_cooling_device_register_fail:
331 emc2305_unset_tz(dev);
332 return ret;
333 }
334
emc2305_unset_tz(struct device * dev)335 static void emc2305_unset_tz(struct device *dev)
336 {
337 struct emc2305_data *data = dev_get_drvdata(dev);
338 int i;
339
340 /* Unregister cooling device. */
341 for (i = 0; i < EMC2305_PWM_MAX; i++)
342 if (data->cdev_data[i].cdev)
343 thermal_cooling_device_unregister(data->cdev_data[i].cdev);
344 }
345
346 static umode_t
emc2305_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)347 emc2305_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel)
348 {
349 int max_channel = emc2305_get_max_channel(data);
350
351 /* Don't show channels which are not physically connected. */
352 if (channel >= max_channel)
353 return 0;
354 switch (type) {
355 case hwmon_fan:
356 switch (attr) {
357 case hwmon_fan_input:
358 return 0444;
359 case hwmon_fan_fault:
360 return 0444;
361 default:
362 break;
363 }
364 break;
365 case hwmon_pwm:
366 switch (attr) {
367 case hwmon_pwm_input:
368 return 0644;
369 default:
370 break;
371 }
372 break;
373 default:
374 break;
375 }
376
377 return 0;
378 };
379
380 static int
emc2305_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)381 emc2305_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, long val)
382 {
383 struct emc2305_data *data = dev_get_drvdata(dev);
384 int cdev_idx;
385
386 switch (type) {
387 case hwmon_pwm:
388 switch (attr) {
389 case hwmon_pwm_input:
390 /* If thermal is configured - handle PWM limit setting. */
391 if (IS_REACHABLE(CONFIG_THERMAL)) {
392 if (data->pwm_separate)
393 cdev_idx = channel;
394 else
395 cdev_idx = 0;
396 data->cdev_data[cdev_idx].last_hwmon_state =
397 EMC2305_PWM_DUTY2STATE(val, data->max_state,
398 EMC2305_FAN_MAX);
399 /*
400 * Update PWM only in case requested state is not less than the
401 * last thermal state.
402 */
403 if (data->cdev_data[cdev_idx].last_hwmon_state >=
404 data->cdev_data[cdev_idx].last_thermal_state)
405 return emc2305_set_cur_state(data->cdev_data[cdev_idx].cdev,
406 data->cdev_data[cdev_idx].last_hwmon_state);
407 return 0;
408 }
409 return emc2305_set_pwm(dev, val, channel);
410 default:
411 break;
412 }
413 break;
414 default:
415 break;
416 }
417
418 return -EOPNOTSUPP;
419 };
420
421 static int
emc2305_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)422 emc2305_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, long *val)
423 {
424 int ret;
425
426 switch (type) {
427 case hwmon_fan:
428 switch (attr) {
429 case hwmon_fan_input:
430 ret = emc2305_show_fan(dev, channel);
431 if (ret < 0)
432 return ret;
433 *val = ret;
434 return 0;
435 case hwmon_fan_fault:
436 ret = emc2305_show_fault(dev, channel);
437 if (ret < 0)
438 return ret;
439 *val = ret;
440 return 0;
441 default:
442 break;
443 }
444 break;
445 case hwmon_pwm:
446 switch (attr) {
447 case hwmon_pwm_input:
448 ret = emc2305_show_pwm(dev, channel);
449 if (ret < 0)
450 return ret;
451 *val = ret;
452 return 0;
453 default:
454 break;
455 }
456 break;
457 default:
458 break;
459 }
460
461 return -EOPNOTSUPP;
462 };
463
464 static const struct hwmon_ops emc2305_ops = {
465 .is_visible = emc2305_is_visible,
466 .read = emc2305_read,
467 .write = emc2305_write,
468 };
469
470 static const struct hwmon_channel_info *emc2305_info[] = {
471 HWMON_CHANNEL_INFO(fan,
472 HWMON_F_INPUT | HWMON_F_FAULT,
473 HWMON_F_INPUT | HWMON_F_FAULT,
474 HWMON_F_INPUT | HWMON_F_FAULT,
475 HWMON_F_INPUT | HWMON_F_FAULT,
476 HWMON_F_INPUT | HWMON_F_FAULT),
477 HWMON_CHANNEL_INFO(pwm,
478 HWMON_PWM_INPUT,
479 HWMON_PWM_INPUT,
480 HWMON_PWM_INPUT,
481 HWMON_PWM_INPUT,
482 HWMON_PWM_INPUT),
483 NULL
484 };
485
486 static const struct hwmon_chip_info emc2305_chip_info = {
487 .ops = &emc2305_ops,
488 .info = emc2305_info,
489 };
490
emc2305_identify(struct device * dev)491 static int emc2305_identify(struct device *dev)
492 {
493 struct i2c_client *client = to_i2c_client(dev);
494 struct emc2305_data *data = i2c_get_clientdata(client);
495 int ret;
496
497 ret = i2c_smbus_read_byte_data(client, EMC2305_REG_PRODUCT_ID);
498 if (ret < 0)
499 return ret;
500
501 switch (ret) {
502 case EMC2305:
503 data->pwm_num = 5;
504 break;
505 case EMC2303:
506 data->pwm_num = 3;
507 break;
508 case EMC2302:
509 data->pwm_num = 2;
510 break;
511 case EMC2301:
512 data->pwm_num = 1;
513 break;
514 default:
515 return -ENODEV;
516 }
517
518 return 0;
519 }
520
emc2305_probe(struct i2c_client * client,const struct i2c_device_id * id)521 static int emc2305_probe(struct i2c_client *client, const struct i2c_device_id *id)
522 {
523 struct i2c_adapter *adapter = client->adapter;
524 struct device *dev = &client->dev;
525 struct emc2305_data *data;
526 struct emc2305_platform_data *pdata;
527 int vendor, device;
528 int ret;
529 int i;
530
531 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
532 return -ENODEV;
533
534 vendor = i2c_smbus_read_byte_data(client, EMC2305_REG_VENDOR);
535 if (vendor != EMC2305_VENDOR)
536 return -ENODEV;
537
538 device = i2c_smbus_read_byte_data(client, EMC2305_REG_DEVICE);
539 if (device != EMC2305_DEVICE)
540 return -ENODEV;
541
542 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
543 if (!data)
544 return -ENOMEM;
545
546 i2c_set_clientdata(client, data);
547 data->client = client;
548
549 ret = emc2305_identify(dev);
550 if (ret)
551 return ret;
552
553 pdata = dev_get_platdata(&client->dev);
554 if (pdata) {
555 if (!pdata->max_state || pdata->max_state > EMC2305_FAN_MAX_STATE)
556 return -EINVAL;
557 data->max_state = pdata->max_state;
558 /*
559 * Validate a number of active PWM channels. Note that
560 * configured number can be less than the actual maximum
561 * supported by the device.
562 */
563 if (!pdata->pwm_num || pdata->pwm_num > EMC2305_PWM_MAX)
564 return -EINVAL;
565 data->pwm_num = pdata->pwm_num;
566 data->pwm_separate = pdata->pwm_separate;
567 for (i = 0; i < EMC2305_PWM_MAX; i++)
568 data->pwm_min[i] = pdata->pwm_min[i];
569 } else {
570 data->max_state = EMC2305_FAN_MAX_STATE;
571 data->pwm_separate = false;
572 for (i = 0; i < EMC2305_PWM_MAX; i++)
573 data->pwm_min[i] = EMC2305_FAN_MIN;
574 }
575
576 data->hwmon_dev = devm_hwmon_device_register_with_info(dev, "emc2305", data,
577 &emc2305_chip_info, NULL);
578 if (IS_ERR(data->hwmon_dev))
579 return PTR_ERR(data->hwmon_dev);
580
581 if (IS_REACHABLE(CONFIG_THERMAL)) {
582 ret = emc2305_set_tz(dev);
583 if (ret != 0)
584 return ret;
585 }
586
587 for (i = 0; i < data->pwm_num; i++) {
588 ret = i2c_smbus_write_byte_data(client, EMC2305_REG_FAN_MIN_DRIVE(i),
589 data->pwm_min[i]);
590 if (ret < 0)
591 return ret;
592 }
593
594 return 0;
595 }
596
emc2305_remove(struct i2c_client * client)597 static void emc2305_remove(struct i2c_client *client)
598 {
599 struct device *dev = &client->dev;
600
601 if (IS_REACHABLE(CONFIG_THERMAL))
602 emc2305_unset_tz(dev);
603 }
604
605 static struct i2c_driver emc2305_driver = {
606 .class = I2C_CLASS_HWMON,
607 .driver = {
608 .name = "emc2305",
609 },
610 .probe = emc2305_probe,
611 .remove = emc2305_remove,
612 .id_table = emc2305_ids,
613 .address_list = emc2305_normal_i2c,
614 };
615
616 module_i2c_driver(emc2305_driver);
617
618 MODULE_AUTHOR("Nvidia");
619 MODULE_DESCRIPTION("Microchip EMC2305 fan controller driver");
620 MODULE_LICENSE("GPL");
621
