• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 
3 /*
4  * Copyright 2016-2019 HabanaLabs, Ltd.
5  * All Rights Reserved.
6  */
7 
8 #include "habanalabs.h"
9 
10 #include <linux/pci.h>
11 #include <linux/hwmon.h>
12 
13 #define HWMON_NR_SENSOR_TYPES		(hwmon_pwm + 1)
14 
hl_build_hwmon_channel_info(struct hl_device * hdev,struct cpucp_sensor * sensors_arr)15 int hl_build_hwmon_channel_info(struct hl_device *hdev,
16 				struct cpucp_sensor *sensors_arr)
17 {
18 	u32 counts[HWMON_NR_SENSOR_TYPES] = {0};
19 	u32 *sensors_by_type[HWMON_NR_SENSOR_TYPES] = {NULL};
20 	u32 sensors_by_type_next_index[HWMON_NR_SENSOR_TYPES] = {0};
21 	struct hwmon_channel_info **channels_info;
22 	u32 num_sensors_for_type, num_active_sensor_types = 0,
23 			arr_size = 0, *curr_arr;
24 	enum hwmon_sensor_types type;
25 	int rc, i, j;
26 
27 	for (i = 0 ; i < CPUCP_MAX_SENSORS ; i++) {
28 		type = le32_to_cpu(sensors_arr[i].type);
29 
30 		if ((type == 0) && (sensors_arr[i].flags == 0))
31 			break;
32 
33 		if (type >= HWMON_NR_SENSOR_TYPES) {
34 			dev_err(hdev->dev,
35 				"Got wrong sensor type %d from device\n", type);
36 			return -EINVAL;
37 		}
38 
39 		counts[type]++;
40 		arr_size++;
41 	}
42 
43 	for (i = 0 ; i < HWMON_NR_SENSOR_TYPES ; i++) {
44 		if (counts[i] == 0)
45 			continue;
46 
47 		num_sensors_for_type = counts[i] + 1;
48 		curr_arr = kcalloc(num_sensors_for_type, sizeof(*curr_arr),
49 				GFP_KERNEL);
50 		if (!curr_arr) {
51 			rc = -ENOMEM;
52 			goto sensors_type_err;
53 		}
54 
55 		num_active_sensor_types++;
56 		sensors_by_type[i] = curr_arr;
57 	}
58 
59 	for (i = 0 ; i < arr_size ; i++) {
60 		type = le32_to_cpu(sensors_arr[i].type);
61 		curr_arr = sensors_by_type[type];
62 		curr_arr[sensors_by_type_next_index[type]++] =
63 				le32_to_cpu(sensors_arr[i].flags);
64 	}
65 
66 	channels_info = kcalloc(num_active_sensor_types + 1,
67 			sizeof(*channels_info), GFP_KERNEL);
68 	if (!channels_info) {
69 		rc = -ENOMEM;
70 		goto channels_info_array_err;
71 	}
72 
73 	for (i = 0 ; i < num_active_sensor_types ; i++) {
74 		channels_info[i] = kzalloc(sizeof(*channels_info[i]),
75 				GFP_KERNEL);
76 		if (!channels_info[i]) {
77 			rc = -ENOMEM;
78 			goto channel_info_err;
79 		}
80 	}
81 
82 	for (i = 0, j = 0 ; i < HWMON_NR_SENSOR_TYPES ; i++) {
83 		if (!sensors_by_type[i])
84 			continue;
85 
86 		channels_info[j]->type = i;
87 		channels_info[j]->config = sensors_by_type[i];
88 		j++;
89 	}
90 
91 	hdev->hl_chip_info->info =
92 			(const struct hwmon_channel_info **)channels_info;
93 
94 	return 0;
95 
96 channel_info_err:
97 	for (i = 0 ; i < num_active_sensor_types ; i++)
98 		if (channels_info[i]) {
99 			kfree(channels_info[i]->config);
100 			kfree(channels_info[i]);
101 		}
102 	kfree(channels_info);
103 channels_info_array_err:
104 sensors_type_err:
105 	for (i = 0 ; i < HWMON_NR_SENSOR_TYPES ; i++)
106 		kfree(sensors_by_type[i]);
107 
108 	return rc;
109 }
110 
hl_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)111 static int hl_read(struct device *dev, enum hwmon_sensor_types type,
112 			u32 attr, int channel, long *val)
113 {
114 	struct hl_device *hdev = dev_get_drvdata(dev);
115 	int rc;
116 
117 	if (!hl_device_operational(hdev, NULL))
118 		return -ENODEV;
119 
120 	switch (type) {
121 	case hwmon_temp:
122 		switch (attr) {
123 		case hwmon_temp_input:
124 		case hwmon_temp_max:
125 		case hwmon_temp_crit:
126 		case hwmon_temp_max_hyst:
127 		case hwmon_temp_crit_hyst:
128 		case hwmon_temp_offset:
129 		case hwmon_temp_highest:
130 			break;
131 		default:
132 			return -EINVAL;
133 		}
134 
135 		rc = hl_get_temperature(hdev, channel, attr, val);
136 		break;
137 	case hwmon_in:
138 		switch (attr) {
139 		case hwmon_in_input:
140 		case hwmon_in_min:
141 		case hwmon_in_max:
142 		case hwmon_in_highest:
143 			break;
144 		default:
145 			return -EINVAL;
146 		}
147 
148 		rc = hl_get_voltage(hdev, channel, attr, val);
149 		break;
150 	case hwmon_curr:
151 		switch (attr) {
152 		case hwmon_curr_input:
153 		case hwmon_curr_min:
154 		case hwmon_curr_max:
155 		case hwmon_curr_highest:
156 			break;
157 		default:
158 			return -EINVAL;
159 		}
160 
161 		rc = hl_get_current(hdev, channel, attr, val);
162 		break;
163 	case hwmon_fan:
164 		switch (attr) {
165 		case hwmon_fan_input:
166 		case hwmon_fan_min:
167 		case hwmon_fan_max:
168 			break;
169 		default:
170 			return -EINVAL;
171 		}
172 		rc = hl_get_fan_speed(hdev, channel, attr, val);
173 		break;
174 	case hwmon_pwm:
175 		switch (attr) {
176 		case hwmon_pwm_input:
177 		case hwmon_pwm_enable:
178 			break;
179 		default:
180 			return -EINVAL;
181 		}
182 		rc = hl_get_pwm_info(hdev, channel, attr, val);
183 		break;
184 	default:
185 		return -EINVAL;
186 	}
187 	return rc;
188 }
189 
hl_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)190 static int hl_write(struct device *dev, enum hwmon_sensor_types type,
191 			u32 attr, int channel, long val)
192 {
193 	struct hl_device *hdev = dev_get_drvdata(dev);
194 
195 	if (!hl_device_operational(hdev, NULL))
196 		return -ENODEV;
197 
198 	switch (type) {
199 	case hwmon_temp:
200 		switch (attr) {
201 		case hwmon_temp_offset:
202 		case hwmon_temp_reset_history:
203 			break;
204 		default:
205 			return -EINVAL;
206 		}
207 		hl_set_temperature(hdev, channel, attr, val);
208 		break;
209 	case hwmon_pwm:
210 		switch (attr) {
211 		case hwmon_pwm_input:
212 		case hwmon_pwm_enable:
213 			break;
214 		default:
215 			return -EINVAL;
216 		}
217 		hl_set_pwm_info(hdev, channel, attr, val);
218 		break;
219 	case hwmon_in:
220 		switch (attr) {
221 		case hwmon_in_reset_history:
222 			break;
223 		default:
224 			return -EINVAL;
225 		}
226 		hl_set_voltage(hdev, channel, attr, val);
227 		break;
228 	case hwmon_curr:
229 		switch (attr) {
230 		case hwmon_curr_reset_history:
231 			break;
232 		default:
233 			return -EINVAL;
234 		}
235 		hl_set_current(hdev, channel, attr, val);
236 		break;
237 	default:
238 		return -EINVAL;
239 	}
240 	return 0;
241 }
242 
hl_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)243 static umode_t hl_is_visible(const void *data, enum hwmon_sensor_types type,
244 				u32 attr, int channel)
245 {
246 	switch (type) {
247 	case hwmon_temp:
248 		switch (attr) {
249 		case hwmon_temp_input:
250 		case hwmon_temp_max:
251 		case hwmon_temp_max_hyst:
252 		case hwmon_temp_crit:
253 		case hwmon_temp_crit_hyst:
254 		case hwmon_temp_highest:
255 			return 0444;
256 		case hwmon_temp_offset:
257 			return 0644;
258 		case hwmon_temp_reset_history:
259 			return 0200;
260 		}
261 		break;
262 	case hwmon_in:
263 		switch (attr) {
264 		case hwmon_in_input:
265 		case hwmon_in_min:
266 		case hwmon_in_max:
267 		case hwmon_in_highest:
268 			return 0444;
269 		case hwmon_in_reset_history:
270 			return 0200;
271 		}
272 		break;
273 	case hwmon_curr:
274 		switch (attr) {
275 		case hwmon_curr_input:
276 		case hwmon_curr_min:
277 		case hwmon_curr_max:
278 		case hwmon_curr_highest:
279 			return 0444;
280 		case hwmon_curr_reset_history:
281 			return 0200;
282 		}
283 		break;
284 	case hwmon_fan:
285 		switch (attr) {
286 		case hwmon_fan_input:
287 		case hwmon_fan_min:
288 		case hwmon_fan_max:
289 			return 0444;
290 		}
291 		break;
292 	case hwmon_pwm:
293 		switch (attr) {
294 		case hwmon_pwm_input:
295 		case hwmon_pwm_enable:
296 			return 0644;
297 		}
298 		break;
299 	default:
300 		break;
301 	}
302 	return 0;
303 }
304 
305 static const struct hwmon_ops hl_hwmon_ops = {
306 	.is_visible = hl_is_visible,
307 	.read = hl_read,
308 	.write = hl_write
309 };
310 
hl_get_temperature(struct hl_device * hdev,int sensor_index,u32 attr,long * value)311 int hl_get_temperature(struct hl_device *hdev,
312 			int sensor_index, u32 attr, long *value)
313 {
314 	struct cpucp_packet pkt;
315 	u64 result;
316 	int rc;
317 
318 	memset(&pkt, 0, sizeof(pkt));
319 
320 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_TEMPERATURE_GET <<
321 				CPUCP_PKT_CTL_OPCODE_SHIFT);
322 	pkt.sensor_index = __cpu_to_le16(sensor_index);
323 	pkt.type = __cpu_to_le16(attr);
324 
325 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
326 						0, &result);
327 
328 	*value = (long) result;
329 
330 	if (rc) {
331 		dev_err(hdev->dev,
332 			"Failed to get temperature from sensor %d, error %d\n",
333 			sensor_index, rc);
334 		*value = 0;
335 	}
336 
337 	return rc;
338 }
339 
hl_set_temperature(struct hl_device * hdev,int sensor_index,u32 attr,long value)340 int hl_set_temperature(struct hl_device *hdev,
341 			int sensor_index, u32 attr, long value)
342 {
343 	struct cpucp_packet pkt;
344 	int rc;
345 
346 	memset(&pkt, 0, sizeof(pkt));
347 
348 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_TEMPERATURE_SET <<
349 				CPUCP_PKT_CTL_OPCODE_SHIFT);
350 	pkt.sensor_index = __cpu_to_le16(sensor_index);
351 	pkt.type = __cpu_to_le16(attr);
352 	pkt.value = __cpu_to_le64(value);
353 
354 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
355 						0, NULL);
356 
357 	if (rc)
358 		dev_err(hdev->dev,
359 			"Failed to set temperature of sensor %d, error %d\n",
360 			sensor_index, rc);
361 
362 	return rc;
363 }
364 
hl_get_voltage(struct hl_device * hdev,int sensor_index,u32 attr,long * value)365 int hl_get_voltage(struct hl_device *hdev,
366 			int sensor_index, u32 attr, long *value)
367 {
368 	struct cpucp_packet pkt;
369 	u64 result;
370 	int rc;
371 
372 	memset(&pkt, 0, sizeof(pkt));
373 
374 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_VOLTAGE_GET <<
375 				CPUCP_PKT_CTL_OPCODE_SHIFT);
376 	pkt.sensor_index = __cpu_to_le16(sensor_index);
377 	pkt.type = __cpu_to_le16(attr);
378 
379 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
380 						0, &result);
381 
382 	*value = (long) result;
383 
384 	if (rc) {
385 		dev_err(hdev->dev,
386 			"Failed to get voltage from sensor %d, error %d\n",
387 			sensor_index, rc);
388 		*value = 0;
389 	}
390 
391 	return rc;
392 }
393 
hl_get_current(struct hl_device * hdev,int sensor_index,u32 attr,long * value)394 int hl_get_current(struct hl_device *hdev,
395 			int sensor_index, u32 attr, long *value)
396 {
397 	struct cpucp_packet pkt;
398 	u64 result;
399 	int rc;
400 
401 	memset(&pkt, 0, sizeof(pkt));
402 
403 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_CURRENT_GET <<
404 				CPUCP_PKT_CTL_OPCODE_SHIFT);
405 	pkt.sensor_index = __cpu_to_le16(sensor_index);
406 	pkt.type = __cpu_to_le16(attr);
407 
408 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
409 						0, &result);
410 
411 	*value = (long) result;
412 
413 	if (rc) {
414 		dev_err(hdev->dev,
415 			"Failed to get current from sensor %d, error %d\n",
416 			sensor_index, rc);
417 		*value = 0;
418 	}
419 
420 	return rc;
421 }
422 
hl_get_fan_speed(struct hl_device * hdev,int sensor_index,u32 attr,long * value)423 int hl_get_fan_speed(struct hl_device *hdev,
424 			int sensor_index, u32 attr, long *value)
425 {
426 	struct cpucp_packet pkt;
427 	u64 result;
428 	int rc;
429 
430 	memset(&pkt, 0, sizeof(pkt));
431 
432 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_FAN_SPEED_GET <<
433 				CPUCP_PKT_CTL_OPCODE_SHIFT);
434 	pkt.sensor_index = __cpu_to_le16(sensor_index);
435 	pkt.type = __cpu_to_le16(attr);
436 
437 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
438 						0, &result);
439 
440 	*value = (long) result;
441 
442 	if (rc) {
443 		dev_err(hdev->dev,
444 			"Failed to get fan speed from sensor %d, error %d\n",
445 			sensor_index, rc);
446 		*value = 0;
447 	}
448 
449 	return rc;
450 }
451 
hl_get_pwm_info(struct hl_device * hdev,int sensor_index,u32 attr,long * value)452 int hl_get_pwm_info(struct hl_device *hdev,
453 			int sensor_index, u32 attr, long *value)
454 {
455 	struct cpucp_packet pkt;
456 	u64 result;
457 	int rc;
458 
459 	memset(&pkt, 0, sizeof(pkt));
460 
461 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_PWM_GET <<
462 				CPUCP_PKT_CTL_OPCODE_SHIFT);
463 	pkt.sensor_index = __cpu_to_le16(sensor_index);
464 	pkt.type = __cpu_to_le16(attr);
465 
466 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
467 						0, &result);
468 
469 	*value = (long) result;
470 
471 	if (rc) {
472 		dev_err(hdev->dev,
473 			"Failed to get pwm info from sensor %d, error %d\n",
474 			sensor_index, rc);
475 		*value = 0;
476 	}
477 
478 	return rc;
479 }
480 
hl_set_pwm_info(struct hl_device * hdev,int sensor_index,u32 attr,long value)481 void hl_set_pwm_info(struct hl_device *hdev, int sensor_index, u32 attr,
482 			long value)
483 {
484 	struct cpucp_packet pkt;
485 	int rc;
486 
487 	memset(&pkt, 0, sizeof(pkt));
488 
489 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_PWM_SET <<
490 				CPUCP_PKT_CTL_OPCODE_SHIFT);
491 	pkt.sensor_index = __cpu_to_le16(sensor_index);
492 	pkt.type = __cpu_to_le16(attr);
493 	pkt.value = cpu_to_le64(value);
494 
495 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
496 						0, NULL);
497 
498 	if (rc)
499 		dev_err(hdev->dev,
500 			"Failed to set pwm info to sensor %d, error %d\n",
501 			sensor_index, rc);
502 }
503 
hl_set_voltage(struct hl_device * hdev,int sensor_index,u32 attr,long value)504 int hl_set_voltage(struct hl_device *hdev,
505 			int sensor_index, u32 attr, long value)
506 {
507 	struct cpucp_packet pkt;
508 	int rc;
509 
510 	memset(&pkt, 0, sizeof(pkt));
511 
512 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_VOLTAGE_SET <<
513 				CPUCP_PKT_CTL_OPCODE_SHIFT);
514 	pkt.sensor_index = __cpu_to_le16(sensor_index);
515 	pkt.type = __cpu_to_le16(attr);
516 	pkt.value = __cpu_to_le64(value);
517 
518 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
519 						0, NULL);
520 
521 	if (rc)
522 		dev_err(hdev->dev,
523 			"Failed to set voltage of sensor %d, error %d\n",
524 			sensor_index, rc);
525 
526 	return rc;
527 }
528 
hl_set_current(struct hl_device * hdev,int sensor_index,u32 attr,long value)529 int hl_set_current(struct hl_device *hdev,
530 			int sensor_index, u32 attr, long value)
531 {
532 	struct cpucp_packet pkt;
533 	int rc;
534 
535 	memset(&pkt, 0, sizeof(pkt));
536 
537 	pkt.ctl = cpu_to_le32(CPUCP_PACKET_CURRENT_SET <<
538 				CPUCP_PKT_CTL_OPCODE_SHIFT);
539 	pkt.sensor_index = __cpu_to_le16(sensor_index);
540 	pkt.type = __cpu_to_le16(attr);
541 	pkt.value = __cpu_to_le64(value);
542 
543 	rc = hdev->asic_funcs->send_cpu_message(hdev, (u32 *) &pkt, sizeof(pkt),
544 						0, NULL);
545 
546 	if (rc)
547 		dev_err(hdev->dev,
548 			"Failed to set current of sensor %d, error %d\n",
549 			sensor_index, rc);
550 
551 	return rc;
552 }
553 
hl_hwmon_init(struct hl_device * hdev)554 int hl_hwmon_init(struct hl_device *hdev)
555 {
556 	struct device *dev = hdev->pdev ? &hdev->pdev->dev : hdev->dev;
557 	struct asic_fixed_properties *prop = &hdev->asic_prop;
558 	int rc;
559 
560 	if ((hdev->hwmon_initialized) || !(hdev->cpu_queues_enable))
561 		return 0;
562 
563 	if (hdev->hl_chip_info->info) {
564 		hdev->hl_chip_info->ops = &hl_hwmon_ops;
565 
566 		hdev->hwmon_dev = hwmon_device_register_with_info(dev,
567 					prop->cpucp_info.card_name, hdev,
568 					hdev->hl_chip_info, NULL);
569 		if (IS_ERR(hdev->hwmon_dev)) {
570 			rc = PTR_ERR(hdev->hwmon_dev);
571 			dev_err(hdev->dev,
572 				"Unable to register hwmon device: %d\n", rc);
573 			return rc;
574 		}
575 
576 		dev_info(hdev->dev, "%s: add sensors information\n",
577 			dev_name(hdev->hwmon_dev));
578 
579 		hdev->hwmon_initialized = true;
580 	} else {
581 		dev_info(hdev->dev, "no available sensors\n");
582 	}
583 
584 	return 0;
585 }
586 
hl_hwmon_fini(struct hl_device * hdev)587 void hl_hwmon_fini(struct hl_device *hdev)
588 {
589 	if (!hdev->hwmon_initialized)
590 		return;
591 
592 	hwmon_device_unregister(hdev->hwmon_dev);
593 }
594