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