1 // SPDX-License-Identifier: GPL-2.0
2 /* Huawei HiNIC PCI Express Linux driver
3  * Copyright(c) 2017 Huawei Technologies Co., Ltd
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms and conditions of the GNU General Public License,
7  * version 2, as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * for more details.
13  *
14  */
15 #include <linux/netlink.h>
16 #include <net/devlink.h>
17 #include <linux/firmware.h>
18 
19 #include "hinic_port.h"
20 #include "hinic_devlink.h"
21 #include "hinic_hw_dev.h"
22 
23 static bool check_image_valid(struct hinic_devlink_priv *priv, const u8 *buf,
24 			      u32 image_size, struct host_image_st *host_image)
25 {
26 	struct fw_image_st *fw_image = NULL;
27 	u32 len = 0;
28 	u32 i;
29 
30 	fw_image = (struct fw_image_st *)buf;
31 
32 	if (fw_image->fw_magic != HINIC_MAGIC_NUM) {
33 		dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong fw_magic read from file, fw_magic: 0x%x\n",
34 			fw_image->fw_magic);
35 		return false;
36 	}
37 
38 	if (fw_image->fw_info.fw_section_cnt > MAX_FW_TYPE_NUM) {
39 		dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong fw_type_num read from file, fw_type_num: 0x%x\n",
40 			fw_image->fw_info.fw_section_cnt);
41 		return false;
42 	}
43 
44 	for (i = 0; i < fw_image->fw_info.fw_section_cnt; i++) {
45 		len += fw_image->fw_section_info[i].fw_section_len;
46 		host_image->image_section_info[i] = fw_image->fw_section_info[i];
47 	}
48 
49 	if (len != fw_image->fw_len ||
50 	    (fw_image->fw_len + UPDATEFW_IMAGE_HEAD_SIZE) != image_size) {
51 		dev_err(&priv->hwdev->hwif->pdev->dev, "Wrong data size read from file\n");
52 		return false;
53 	}
54 
55 	host_image->image_info.up_total_len = fw_image->fw_len;
56 	host_image->image_info.fw_version = fw_image->fw_version;
57 	host_image->section_type_num = fw_image->fw_info.fw_section_cnt;
58 	host_image->device_id = fw_image->device_id;
59 
60 	return true;
61 }
62 
63 static bool check_image_integrity(struct hinic_devlink_priv *priv,
64 				  struct host_image_st *host_image,
65 				  u32 update_type)
66 {
67 	u32 collect_section_type = 0;
68 	u32 i, type;
69 
70 	for (i = 0; i < host_image->section_type_num; i++) {
71 		type = host_image->image_section_info[i].fw_section_type;
72 		if (collect_section_type & (1U << type)) {
73 			dev_err(&priv->hwdev->hwif->pdev->dev, "Duplicate section type: %u\n",
74 				type);
75 			return false;
76 		}
77 		collect_section_type |= (1U << type);
78 	}
79 
80 	if (update_type == FW_UPDATE_COLD &&
81 	    (((collect_section_type & _IMAGE_COLD_SUB_MODULES_MUST_IN) ==
82 	       _IMAGE_COLD_SUB_MODULES_MUST_IN) ||
83 	      collect_section_type == _IMAGE_CFG_SUB_MODULES_MUST_IN))
84 		return true;
85 
86 	if (update_type == FW_UPDATE_HOT &&
87 	    (collect_section_type & _IMAGE_HOT_SUB_MODULES_MUST_IN) ==
88 	    _IMAGE_HOT_SUB_MODULES_MUST_IN)
89 		return true;
90 
91 	if (update_type == FW_UPDATE_COLD)
92 		dev_err(&priv->hwdev->hwif->pdev->dev, "Check file integrity failed, valid: 0x%x or 0x%lx, current: 0x%x\n",
93 			_IMAGE_COLD_SUB_MODULES_MUST_IN,
94 			_IMAGE_CFG_SUB_MODULES_MUST_IN, collect_section_type);
95 	else
96 		dev_err(&priv->hwdev->hwif->pdev->dev, "Check file integrity failed, valid:0x%x, current: 0x%x\n",
97 			_IMAGE_HOT_SUB_MODULES_MUST_IN, collect_section_type);
98 
99 	return false;
100 }
101 
102 static int check_image_device_type(struct hinic_devlink_priv *priv,
103 				   u32 image_device_type)
104 {
105 	struct hinic_comm_board_info board_info = {0};
106 
107 	if (hinic_get_board_info(priv->hwdev, &board_info)) {
108 		dev_err(&priv->hwdev->hwif->pdev->dev, "Get board info failed\n");
109 		return false;
110 	}
111 
112 	if (image_device_type == board_info.info.board_type)
113 		return true;
114 
115 	dev_err(&priv->hwdev->hwif->pdev->dev, "The device type of upgrade file doesn't match the device type of current firmware, please check the upgrade file\n");
116 	dev_err(&priv->hwdev->hwif->pdev->dev, "The image device type: 0x%x, firmware device type: 0x%x\n",
117 		image_device_type, board_info.info.board_type);
118 
119 	return false;
120 }
121 
122 static int hinic_flash_fw(struct hinic_devlink_priv *priv, const u8 *data,
123 			  struct host_image_st *host_image)
124 {
125 	u32 section_remain_send_len, send_fragment_len, send_pos, up_total_len;
126 	struct hinic_cmd_update_fw *fw_update_msg = NULL;
127 	u32 section_type, section_crc, section_version;
128 	u32 i, len, section_len, section_offset;
129 	u16 out_size = sizeof(*fw_update_msg);
130 	int total_len_flag = 0;
131 	int err;
132 
133 	fw_update_msg = kzalloc(sizeof(*fw_update_msg), GFP_KERNEL);
134 	if (!fw_update_msg)
135 		return -ENOMEM;
136 
137 	up_total_len = host_image->image_info.up_total_len;
138 
139 	for (i = 0; i < host_image->section_type_num; i++) {
140 		len = host_image->image_section_info[i].fw_section_len;
141 		if (host_image->image_section_info[i].fw_section_type ==
142 		    UP_FW_UPDATE_BOOT) {
143 			up_total_len = up_total_len - len;
144 			break;
145 		}
146 	}
147 
148 	for (i = 0; i < host_image->section_type_num; i++) {
149 		section_len =
150 			host_image->image_section_info[i].fw_section_len;
151 		section_offset =
152 			host_image->image_section_info[i].fw_section_offset;
153 		section_remain_send_len = section_len;
154 		section_type =
155 			host_image->image_section_info[i].fw_section_type;
156 		section_crc = host_image->image_section_info[i].fw_section_crc;
157 		section_version =
158 			host_image->image_section_info[i].fw_section_version;
159 
160 		if (section_type == UP_FW_UPDATE_BOOT)
161 			continue;
162 
163 		send_fragment_len = 0;
164 		send_pos = 0;
165 
166 		while (section_remain_send_len > 0) {
167 			if (!total_len_flag) {
168 				fw_update_msg->total_len = up_total_len;
169 				total_len_flag = 1;
170 			} else {
171 				fw_update_msg->total_len = 0;
172 			}
173 
174 			memset(fw_update_msg->data, 0, MAX_FW_FRAGMENT_LEN);
175 
176 			fw_update_msg->ctl_info.SF =
177 				(section_remain_send_len == section_len) ?
178 				true : false;
179 			fw_update_msg->section_info.FW_section_CRC = section_crc;
180 			fw_update_msg->fw_section_version = section_version;
181 			fw_update_msg->ctl_info.flag = UP_TYPE_A;
182 
183 			if (section_type <= UP_FW_UPDATE_UP_DATA_B) {
184 				fw_update_msg->section_info.FW_section_type =
185 					(section_type % 2) ?
186 					UP_FW_UPDATE_UP_DATA :
187 					UP_FW_UPDATE_UP_TEXT;
188 
189 				fw_update_msg->ctl_info.flag = UP_TYPE_B;
190 				if (section_type <= UP_FW_UPDATE_UP_DATA_A)
191 					fw_update_msg->ctl_info.flag = UP_TYPE_A;
192 			} else {
193 				fw_update_msg->section_info.FW_section_type =
194 					section_type - 0x2;
195 			}
196 
197 			fw_update_msg->setion_total_len = section_len;
198 			fw_update_msg->section_offset = send_pos;
199 
200 			if (section_remain_send_len <= MAX_FW_FRAGMENT_LEN) {
201 				fw_update_msg->ctl_info.SL = true;
202 				fw_update_msg->ctl_info.fragment_len =
203 					section_remain_send_len;
204 				send_fragment_len += section_remain_send_len;
205 			} else {
206 				fw_update_msg->ctl_info.SL = false;
207 				fw_update_msg->ctl_info.fragment_len =
208 					MAX_FW_FRAGMENT_LEN;
209 				send_fragment_len += MAX_FW_FRAGMENT_LEN;
210 			}
211 
212 			memcpy(fw_update_msg->data,
213 			       data + UPDATEFW_IMAGE_HEAD_SIZE +
214 			       section_offset + send_pos,
215 			       fw_update_msg->ctl_info.fragment_len);
216 
217 			err = hinic_port_msg_cmd(priv->hwdev,
218 						 HINIC_PORT_CMD_UPDATE_FW,
219 						 fw_update_msg,
220 						 sizeof(*fw_update_msg),
221 						 fw_update_msg, &out_size);
222 			if (err || !out_size || fw_update_msg->status) {
223 				dev_err(&priv->hwdev->hwif->pdev->dev, "Failed to update firmware, err: %d, status: 0x%x, out size: 0x%x\n",
224 					err, fw_update_msg->status, out_size);
225 				err = fw_update_msg->status ?
226 					fw_update_msg->status : -EIO;
227 				kfree(fw_update_msg);
228 				return err;
229 			}
230 
231 			send_pos = send_fragment_len;
232 			section_remain_send_len = section_len -
233 						  send_fragment_len;
234 		}
235 	}
236 
237 	kfree(fw_update_msg);
238 
239 	return 0;
240 }
241 
242 static int hinic_firmware_update(struct hinic_devlink_priv *priv,
243 				 const struct firmware *fw,
244 				 struct netlink_ext_ack *extack)
245 {
246 	struct host_image_st host_image;
247 	int err;
248 
249 	memset(&host_image, 0, sizeof(struct host_image_st));
250 
251 	if (!check_image_valid(priv, fw->data, fw->size, &host_image) ||
252 	    !check_image_integrity(priv, &host_image, FW_UPDATE_COLD) ||
253 	    !check_image_device_type(priv, host_image.device_id)) {
254 		NL_SET_ERR_MSG_MOD(extack, "Check image failed");
255 		return -EINVAL;
256 	}
257 
258 	dev_info(&priv->hwdev->hwif->pdev->dev, "Flash firmware begin\n");
259 
260 	err = hinic_flash_fw(priv, fw->data, &host_image);
261 	if (err) {
262 		if (err == HINIC_FW_DISMATCH_ERROR) {
263 			dev_err(&priv->hwdev->hwif->pdev->dev, "Firmware image doesn't match this card, please use newer image, err: %d\n",
264 				err);
265 			NL_SET_ERR_MSG_MOD(extack,
266 					   "Firmware image doesn't match this card, please use newer image");
267 		} else {
268 			dev_err(&priv->hwdev->hwif->pdev->dev, "Send firmware image data failed, err: %d\n",
269 				err);
270 			NL_SET_ERR_MSG_MOD(extack, "Send firmware image data failed");
271 		}
272 
273 		return err;
274 	}
275 
276 	dev_info(&priv->hwdev->hwif->pdev->dev, "Flash firmware end\n");
277 
278 	return 0;
279 }
280 
281 static int hinic_devlink_flash_update(struct devlink *devlink,
282 				      struct devlink_flash_update_params *params,
283 				      struct netlink_ext_ack *extack)
284 {
285 	struct hinic_devlink_priv *priv = devlink_priv(devlink);
286 
287 	return hinic_firmware_update(priv, params->fw, extack);
288 }
289 
290 static const struct devlink_ops hinic_devlink_ops = {
291 	.flash_update = hinic_devlink_flash_update,
292 };
293 
294 struct devlink *hinic_devlink_alloc(struct device *dev)
295 {
296 	return devlink_alloc(&hinic_devlink_ops, sizeof(struct hinic_dev), dev);
297 }
298 
299 void hinic_devlink_free(struct devlink *devlink)
300 {
301 	devlink_free(devlink);
302 }
303 
304 void hinic_devlink_register(struct hinic_devlink_priv *priv)
305 {
306 	struct devlink *devlink = priv_to_devlink(priv);
307 
308 	devlink_register(devlink);
309 }
310 
311 void hinic_devlink_unregister(struct hinic_devlink_priv *priv)
312 {
313 	struct devlink *devlink = priv_to_devlink(priv);
314 
315 	devlink_unregister(devlink);
316 }
317 
318 static int chip_fault_show(struct devlink_fmsg *fmsg,
319 			   struct hinic_fault_event *event)
320 {
321 	const char * const level_str[FAULT_LEVEL_MAX + 1] = {
322 		"fatal", "reset", "flr", "general", "suggestion", "Unknown"};
323 	u8 fault_level;
324 	int err;
325 
326 	fault_level = (event->event.chip.err_level < FAULT_LEVEL_MAX) ?
327 		event->event.chip.err_level : FAULT_LEVEL_MAX;
328 	if (fault_level == FAULT_LEVEL_SERIOUS_FLR) {
329 		err = devlink_fmsg_u32_pair_put(fmsg, "Function level err func_id",
330 						(u32)event->event.chip.func_id);
331 		if (err)
332 			return err;
333 	}
334 
335 	err = devlink_fmsg_u8_pair_put(fmsg, "module_id", event->event.chip.node_id);
336 	if (err)
337 		return err;
338 
339 	err = devlink_fmsg_u32_pair_put(fmsg, "err_type", (u32)event->event.chip.err_type);
340 	if (err)
341 		return err;
342 
343 	err = devlink_fmsg_string_pair_put(fmsg, "err_level", level_str[fault_level]);
344 	if (err)
345 		return err;
346 
347 	err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_addr",
348 					event->event.chip.err_csr_addr);
349 	if (err)
350 		return err;
351 
352 	err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_value",
353 					event->event.chip.err_csr_value);
354 	if (err)
355 		return err;
356 
357 	return 0;
358 }
359 
360 static int fault_report_show(struct devlink_fmsg *fmsg,
361 			     struct hinic_fault_event *event)
362 {
363 	const char * const type_str[FAULT_TYPE_MAX + 1] = {
364 		"chip", "ucode", "mem rd timeout", "mem wr timeout",
365 		"reg rd timeout", "reg wr timeout", "phy fault", "Unknown"};
366 	u8 fault_type;
367 	int err;
368 
369 	fault_type = (event->type < FAULT_TYPE_MAX) ? event->type : FAULT_TYPE_MAX;
370 
371 	err = devlink_fmsg_string_pair_put(fmsg, "Fault type", type_str[fault_type]);
372 	if (err)
373 		return err;
374 
375 	err = devlink_fmsg_binary_pair_put(fmsg, "Fault raw data",
376 					   event->event.val, sizeof(event->event.val));
377 	if (err)
378 		return err;
379 
380 	switch (event->type) {
381 	case FAULT_TYPE_CHIP:
382 		err = chip_fault_show(fmsg, event);
383 		if (err)
384 			return err;
385 		break;
386 	case FAULT_TYPE_UCODE:
387 		err = devlink_fmsg_u8_pair_put(fmsg, "Cause_id", event->event.ucode.cause_id);
388 		if (err)
389 			return err;
390 		err = devlink_fmsg_u8_pair_put(fmsg, "core_id", event->event.ucode.core_id);
391 		if (err)
392 			return err;
393 		err = devlink_fmsg_u8_pair_put(fmsg, "c_id", event->event.ucode.c_id);
394 		if (err)
395 			return err;
396 		err = devlink_fmsg_u8_pair_put(fmsg, "epc", event->event.ucode.epc);
397 		if (err)
398 			return err;
399 		break;
400 	case FAULT_TYPE_MEM_RD_TIMEOUT:
401 	case FAULT_TYPE_MEM_WR_TIMEOUT:
402 		err = devlink_fmsg_u32_pair_put(fmsg, "Err_csr_ctrl",
403 						event->event.mem_timeout.err_csr_ctrl);
404 		if (err)
405 			return err;
406 		err = devlink_fmsg_u32_pair_put(fmsg, "err_csr_data",
407 						event->event.mem_timeout.err_csr_data);
408 		if (err)
409 			return err;
410 		err = devlink_fmsg_u32_pair_put(fmsg, "ctrl_tab",
411 						event->event.mem_timeout.ctrl_tab);
412 		if (err)
413 			return err;
414 		err = devlink_fmsg_u32_pair_put(fmsg, "mem_index",
415 						event->event.mem_timeout.mem_index);
416 		if (err)
417 			return err;
418 		break;
419 	case FAULT_TYPE_REG_RD_TIMEOUT:
420 	case FAULT_TYPE_REG_WR_TIMEOUT:
421 		err = devlink_fmsg_u32_pair_put(fmsg, "Err_csr", event->event.reg_timeout.err_csr);
422 		if (err)
423 			return err;
424 		break;
425 	case FAULT_TYPE_PHY_FAULT:
426 		err = devlink_fmsg_u8_pair_put(fmsg, "Op_type", event->event.phy_fault.op_type);
427 		if (err)
428 			return err;
429 		err = devlink_fmsg_u8_pair_put(fmsg, "port_id", event->event.phy_fault.port_id);
430 		if (err)
431 			return err;
432 		err = devlink_fmsg_u8_pair_put(fmsg, "dev_ad", event->event.phy_fault.dev_ad);
433 		if (err)
434 			return err;
435 
436 		err = devlink_fmsg_u32_pair_put(fmsg, "csr_addr", event->event.phy_fault.csr_addr);
437 		if (err)
438 			return err;
439 		err = devlink_fmsg_u32_pair_put(fmsg, "op_data", event->event.phy_fault.op_data);
440 		if (err)
441 			return err;
442 		break;
443 	default:
444 		break;
445 	}
446 
447 	return 0;
448 }
449 
450 static int hinic_hw_reporter_dump(struct devlink_health_reporter *reporter,
451 				  struct devlink_fmsg *fmsg, void *priv_ctx,
452 				  struct netlink_ext_ack *extack)
453 {
454 	if (priv_ctx)
455 		return fault_report_show(fmsg, priv_ctx);
456 
457 	return 0;
458 }
459 
460 static int mgmt_watchdog_report_show(struct devlink_fmsg *fmsg,
461 				     struct hinic_mgmt_watchdog_info *watchdog_info)
462 {
463 	int err;
464 
465 	err = devlink_fmsg_u32_pair_put(fmsg, "Mgmt deadloop time_h", watchdog_info->curr_time_h);
466 	if (err)
467 		return err;
468 
469 	err = devlink_fmsg_u32_pair_put(fmsg, "time_l", watchdog_info->curr_time_l);
470 	if (err)
471 		return err;
472 
473 	err = devlink_fmsg_u32_pair_put(fmsg, "task_id", watchdog_info->task_id);
474 	if (err)
475 		return err;
476 
477 	err = devlink_fmsg_u32_pair_put(fmsg, "sp", watchdog_info->sp);
478 	if (err)
479 		return err;
480 
481 	err = devlink_fmsg_u32_pair_put(fmsg, "stack_current_used", watchdog_info->curr_used);
482 	if (err)
483 		return err;
484 
485 	err = devlink_fmsg_u32_pair_put(fmsg, "peak_used", watchdog_info->peak_used);
486 	if (err)
487 		return err;
488 
489 	err = devlink_fmsg_u32_pair_put(fmsg, "\n Overflow_flag", watchdog_info->is_overflow);
490 	if (err)
491 		return err;
492 
493 	err = devlink_fmsg_u32_pair_put(fmsg, "stack_top", watchdog_info->stack_top);
494 	if (err)
495 		return err;
496 
497 	err = devlink_fmsg_u32_pair_put(fmsg, "stack_bottom", watchdog_info->stack_bottom);
498 	if (err)
499 		return err;
500 
501 	err = devlink_fmsg_u32_pair_put(fmsg, "mgmt_pc", watchdog_info->pc);
502 	if (err)
503 		return err;
504 
505 	err = devlink_fmsg_u32_pair_put(fmsg, "lr", watchdog_info->lr);
506 	if (err)
507 		return err;
508 
509 	err = devlink_fmsg_u32_pair_put(fmsg, "cpsr", watchdog_info->cpsr);
510 	if (err)
511 		return err;
512 
513 	err = devlink_fmsg_binary_pair_put(fmsg, "Mgmt register info",
514 					   watchdog_info->reg, sizeof(watchdog_info->reg));
515 	if (err)
516 		return err;
517 
518 	err = devlink_fmsg_binary_pair_put(fmsg, "Mgmt dump stack(start from sp)",
519 					   watchdog_info->data, sizeof(watchdog_info->data));
520 	if (err)
521 		return err;
522 
523 	return 0;
524 }
525 
526 static int hinic_fw_reporter_dump(struct devlink_health_reporter *reporter,
527 				  struct devlink_fmsg *fmsg, void *priv_ctx,
528 				  struct netlink_ext_ack *extack)
529 {
530 	if (priv_ctx)
531 		return mgmt_watchdog_report_show(fmsg, priv_ctx);
532 
533 	return 0;
534 }
535 
536 static const struct devlink_health_reporter_ops hinic_hw_fault_reporter_ops = {
537 	.name = "hw",
538 	.dump = hinic_hw_reporter_dump,
539 };
540 
541 static const struct devlink_health_reporter_ops hinic_fw_fault_reporter_ops = {
542 	.name = "fw",
543 	.dump = hinic_fw_reporter_dump,
544 };
545 
546 int hinic_health_reporters_create(struct hinic_devlink_priv *priv)
547 {
548 	struct devlink *devlink = priv_to_devlink(priv);
549 
550 	priv->hw_fault_reporter =
551 		devlink_health_reporter_create(devlink, &hinic_hw_fault_reporter_ops,
552 					       0, priv);
553 	if (IS_ERR(priv->hw_fault_reporter)) {
554 		dev_warn(&priv->hwdev->hwif->pdev->dev, "Failed to create hw fault reporter, err: %ld\n",
555 			 PTR_ERR(priv->hw_fault_reporter));
556 		return PTR_ERR(priv->hw_fault_reporter);
557 	}
558 
559 	priv->fw_fault_reporter =
560 		devlink_health_reporter_create(devlink, &hinic_fw_fault_reporter_ops,
561 					       0, priv);
562 	if (IS_ERR(priv->fw_fault_reporter)) {
563 		dev_warn(&priv->hwdev->hwif->pdev->dev, "Failed to create fw fault reporter, err: %ld\n",
564 			 PTR_ERR(priv->fw_fault_reporter));
565 		devlink_health_reporter_destroy(priv->hw_fault_reporter);
566 		priv->hw_fault_reporter = NULL;
567 		return PTR_ERR(priv->fw_fault_reporter);
568 	}
569 
570 	return 0;
571 }
572 
573 void hinic_health_reporters_destroy(struct hinic_devlink_priv *priv)
574 {
575 	if (!IS_ERR_OR_NULL(priv->fw_fault_reporter)) {
576 		devlink_health_reporter_destroy(priv->fw_fault_reporter);
577 		priv->fw_fault_reporter = NULL;
578 	}
579 
580 	if (!IS_ERR_OR_NULL(priv->hw_fault_reporter)) {
581 		devlink_health_reporter_destroy(priv->hw_fault_reporter);
582 		priv->hw_fault_reporter = NULL;
583 	}
584 }
585