1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Huawei HiNIC PCI Express Linux driver 4 * Copyright(c) 2017 Huawei Technologies Co., Ltd 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/types.h> 9 #include <linux/errno.h> 10 #include <linux/pci.h> 11 #include <linux/device.h> 12 #include <linux/semaphore.h> 13 #include <linux/completion.h> 14 #include <linux/slab.h> 15 #include <net/devlink.h> 16 #include <asm/barrier.h> 17 18 #include "hinic_devlink.h" 19 #include "hinic_hw_if.h" 20 #include "hinic_hw_eqs.h" 21 #include "hinic_hw_api_cmd.h" 22 #include "hinic_hw_mgmt.h" 23 #include "hinic_hw_dev.h" 24 25 #define SYNC_MSG_ID_MASK 0x1FF 26 27 #define SYNC_MSG_ID(pf_to_mgmt) ((pf_to_mgmt)->sync_msg_id) 28 29 #define SYNC_MSG_ID_INC(pf_to_mgmt) (SYNC_MSG_ID(pf_to_mgmt) = \ 30 ((SYNC_MSG_ID(pf_to_mgmt) + 1) & \ 31 SYNC_MSG_ID_MASK)) 32 33 #define MSG_SZ_IS_VALID(in_size) ((in_size) <= MAX_MSG_LEN) 34 35 #define MGMT_MSG_LEN_MIN 20 36 #define MGMT_MSG_LEN_STEP 16 37 #define MGMT_MSG_RSVD_FOR_DEV 8 38 39 #define SEGMENT_LEN 48 40 41 #define MAX_PF_MGMT_BUF_SIZE 2048 42 43 /* Data should be SEG LEN size aligned */ 44 #define MAX_MSG_LEN 2016 45 46 #define MSG_NOT_RESP 0xFFFF 47 48 #define MGMT_MSG_TIMEOUT 5000 49 50 #define SET_FUNC_PORT_MBOX_TIMEOUT 30000 51 52 #define SET_FUNC_PORT_MGMT_TIMEOUT 25000 53 54 #define UPDATE_FW_MGMT_TIMEOUT 20000 55 56 #define mgmt_to_pfhwdev(pf_mgmt) \ 57 container_of(pf_mgmt, struct hinic_pfhwdev, pf_to_mgmt) 58 59 enum msg_segment_type { 60 NOT_LAST_SEGMENT = 0, 61 LAST_SEGMENT = 1, 62 }; 63 64 enum mgmt_direction_type { 65 MGMT_DIRECT_SEND = 0, 66 MGMT_RESP = 1, 67 }; 68 69 enum msg_ack_type { 70 MSG_ACK = 0, 71 MSG_NO_ACK = 1, 72 }; 73 74 /** 75 * hinic_register_mgmt_msg_cb - register msg handler for a msg from a module 76 * @pf_to_mgmt: PF to MGMT channel 77 * @mod: module in the chip that this handler will handle its messages 78 * @handle: private data for the callback 79 * @callback: the handler that will handle messages 80 **/ 81 void hinic_register_mgmt_msg_cb(struct hinic_pf_to_mgmt *pf_to_mgmt, 82 enum hinic_mod_type mod, 83 void *handle, 84 void (*callback)(void *handle, 85 u8 cmd, void *buf_in, 86 u16 in_size, void *buf_out, 87 u16 *out_size)) 88 { 89 struct hinic_mgmt_cb *mgmt_cb = &pf_to_mgmt->mgmt_cb[mod]; 90 91 mgmt_cb->cb = callback; 92 mgmt_cb->handle = handle; 93 mgmt_cb->state = HINIC_MGMT_CB_ENABLED; 94 } 95 96 /** 97 * hinic_unregister_mgmt_msg_cb - unregister msg handler for a msg from a module 98 * @pf_to_mgmt: PF to MGMT channel 99 * @mod: module in the chip that this handler handles its messages 100 **/ 101 void hinic_unregister_mgmt_msg_cb(struct hinic_pf_to_mgmt *pf_to_mgmt, 102 enum hinic_mod_type mod) 103 { 104 struct hinic_mgmt_cb *mgmt_cb = &pf_to_mgmt->mgmt_cb[mod]; 105 106 mgmt_cb->state &= ~HINIC_MGMT_CB_ENABLED; 107 108 while (mgmt_cb->state & HINIC_MGMT_CB_RUNNING) 109 schedule(); 110 111 mgmt_cb->cb = NULL; 112 } 113 114 /** 115 * prepare_header - prepare the header of the message 116 * @pf_to_mgmt: PF to MGMT channel 117 * @msg_len: the length of the message 118 * @mod: module in the chip that will get the message 119 * @ack_type: ask for response 120 * @direction: the direction of the message 121 * @cmd: command of the message 122 * @msg_id: message id 123 * 124 * Return the prepared header value 125 **/ 126 static u64 prepare_header(struct hinic_pf_to_mgmt *pf_to_mgmt, 127 u16 msg_len, enum hinic_mod_type mod, 128 enum msg_ack_type ack_type, 129 enum mgmt_direction_type direction, 130 u16 cmd, u16 msg_id) 131 { 132 struct hinic_hwif *hwif = pf_to_mgmt->hwif; 133 134 return HINIC_MSG_HEADER_SET(msg_len, MSG_LEN) | 135 HINIC_MSG_HEADER_SET(mod, MODULE) | 136 HINIC_MSG_HEADER_SET(SEGMENT_LEN, SEG_LEN) | 137 HINIC_MSG_HEADER_SET(ack_type, NO_ACK) | 138 HINIC_MSG_HEADER_SET(0, ASYNC_MGMT_TO_PF) | 139 HINIC_MSG_HEADER_SET(0, SEQID) | 140 HINIC_MSG_HEADER_SET(LAST_SEGMENT, LAST) | 141 HINIC_MSG_HEADER_SET(direction, DIRECTION) | 142 HINIC_MSG_HEADER_SET(cmd, CMD) | 143 HINIC_MSG_HEADER_SET(HINIC_HWIF_PCI_INTF(hwif), PCI_INTF) | 144 HINIC_MSG_HEADER_SET(HINIC_HWIF_PF_IDX(hwif), PF_IDX) | 145 HINIC_MSG_HEADER_SET(msg_id, MSG_ID); 146 } 147 148 /** 149 * prepare_mgmt_cmd - prepare the mgmt command 150 * @mgmt_cmd: pointer to the command to prepare 151 * @header: pointer of the header for the message 152 * @msg: the data of the message 153 * @msg_len: the length of the message 154 **/ 155 static void prepare_mgmt_cmd(u8 *mgmt_cmd, u64 *header, u8 *msg, u16 msg_len) 156 { 157 memset(mgmt_cmd, 0, MGMT_MSG_RSVD_FOR_DEV); 158 159 mgmt_cmd += MGMT_MSG_RSVD_FOR_DEV; 160 memcpy(mgmt_cmd, header, sizeof(*header)); 161 162 mgmt_cmd += sizeof(*header); 163 memcpy(mgmt_cmd, msg, msg_len); 164 } 165 166 /** 167 * mgmt_msg_len - calculate the total message length 168 * @msg_data_len: the length of the message data 169 * 170 * Return the total message length 171 **/ 172 static u16 mgmt_msg_len(u16 msg_data_len) 173 { 174 /* RSVD + HEADER_SIZE + DATA_LEN */ 175 u16 msg_len = MGMT_MSG_RSVD_FOR_DEV + sizeof(u64) + msg_data_len; 176 177 if (msg_len > MGMT_MSG_LEN_MIN) 178 msg_len = MGMT_MSG_LEN_MIN + 179 ALIGN((msg_len - MGMT_MSG_LEN_MIN), 180 MGMT_MSG_LEN_STEP); 181 else 182 msg_len = MGMT_MSG_LEN_MIN; 183 184 return msg_len; 185 } 186 187 /** 188 * send_msg_to_mgmt - send message to mgmt by API CMD 189 * @pf_to_mgmt: PF to MGMT channel 190 * @mod: module in the chip that will get the message 191 * @cmd: command of the message 192 * @data: the msg data 193 * @data_len: the msg data length 194 * @ack_type: ask for response 195 * @direction: the direction of the original message 196 * @resp_msg_id: msg id to response for 197 * 198 * Return 0 - Success, negative - Failure 199 **/ 200 static int send_msg_to_mgmt(struct hinic_pf_to_mgmt *pf_to_mgmt, 201 enum hinic_mod_type mod, u8 cmd, 202 u8 *data, u16 data_len, 203 enum msg_ack_type ack_type, 204 enum mgmt_direction_type direction, 205 u16 resp_msg_id) 206 { 207 struct hinic_api_cmd_chain *chain; 208 u64 header; 209 u16 msg_id; 210 211 msg_id = SYNC_MSG_ID(pf_to_mgmt); 212 213 if (direction == MGMT_RESP) { 214 header = prepare_header(pf_to_mgmt, data_len, mod, ack_type, 215 direction, cmd, resp_msg_id); 216 } else { 217 SYNC_MSG_ID_INC(pf_to_mgmt); 218 header = prepare_header(pf_to_mgmt, data_len, mod, ack_type, 219 direction, cmd, msg_id); 220 } 221 222 prepare_mgmt_cmd(pf_to_mgmt->sync_msg_buf, &header, data, data_len); 223 224 chain = pf_to_mgmt->cmd_chain[HINIC_API_CMD_WRITE_TO_MGMT_CPU]; 225 return hinic_api_cmd_write(chain, HINIC_NODE_ID_MGMT, 226 pf_to_mgmt->sync_msg_buf, 227 mgmt_msg_len(data_len)); 228 } 229 230 /** 231 * msg_to_mgmt_sync - send sync message to mgmt 232 * @pf_to_mgmt: PF to MGMT channel 233 * @mod: module in the chip that will get the message 234 * @cmd: command of the message 235 * @buf_in: the msg data 236 * @in_size: the msg data length 237 * @buf_out: response 238 * @out_size: response length 239 * @direction: the direction of the original message 240 * @resp_msg_id: msg id to response for 241 * @timeout: time-out period of waiting for response 242 * 243 * Return 0 - Success, negative - Failure 244 **/ 245 static int msg_to_mgmt_sync(struct hinic_pf_to_mgmt *pf_to_mgmt, 246 enum hinic_mod_type mod, u8 cmd, 247 u8 *buf_in, u16 in_size, 248 u8 *buf_out, u16 *out_size, 249 enum mgmt_direction_type direction, 250 u16 resp_msg_id, u32 timeout) 251 { 252 struct hinic_hwif *hwif = pf_to_mgmt->hwif; 253 struct pci_dev *pdev = hwif->pdev; 254 struct hinic_recv_msg *recv_msg; 255 struct completion *recv_done; 256 unsigned long timeo; 257 u16 msg_id; 258 int err; 259 260 /* Lock the sync_msg_buf */ 261 down(&pf_to_mgmt->sync_msg_lock); 262 263 recv_msg = &pf_to_mgmt->recv_resp_msg_from_mgmt; 264 recv_done = &recv_msg->recv_done; 265 266 if (resp_msg_id == MSG_NOT_RESP) 267 msg_id = SYNC_MSG_ID(pf_to_mgmt); 268 else 269 msg_id = resp_msg_id; 270 271 init_completion(recv_done); 272 273 err = send_msg_to_mgmt(pf_to_mgmt, mod, cmd, buf_in, in_size, 274 MSG_ACK, direction, resp_msg_id); 275 if (err) { 276 dev_err(&pdev->dev, "Failed to send sync msg to mgmt\n"); 277 goto unlock_sync_msg; 278 } 279 280 timeo = msecs_to_jiffies(timeout ? timeout : MGMT_MSG_TIMEOUT); 281 282 if (!wait_for_completion_timeout(recv_done, timeo)) { 283 dev_err(&pdev->dev, "MGMT timeout, MSG id = %d\n", msg_id); 284 hinic_dump_aeq_info(pf_to_mgmt->hwdev); 285 err = -ETIMEDOUT; 286 goto unlock_sync_msg; 287 } 288 289 smp_rmb(); /* verify reading after completion */ 290 291 if (recv_msg->msg_id != msg_id) { 292 dev_err(&pdev->dev, "incorrect MSG for id = %d\n", msg_id); 293 err = -EFAULT; 294 goto unlock_sync_msg; 295 } 296 297 if (buf_out && recv_msg->msg_len <= MAX_PF_MGMT_BUF_SIZE) { 298 memcpy(buf_out, recv_msg->msg, recv_msg->msg_len); 299 *out_size = recv_msg->msg_len; 300 } 301 302 unlock_sync_msg: 303 up(&pf_to_mgmt->sync_msg_lock); 304 return err; 305 } 306 307 /** 308 * msg_to_mgmt_async - send message to mgmt without response 309 * @pf_to_mgmt: PF to MGMT channel 310 * @mod: module in the chip that will get the message 311 * @cmd: command of the message 312 * @buf_in: the msg data 313 * @in_size: the msg data length 314 * @direction: the direction of the original message 315 * @resp_msg_id: msg id to response for 316 * 317 * Return 0 - Success, negative - Failure 318 **/ 319 static int msg_to_mgmt_async(struct hinic_pf_to_mgmt *pf_to_mgmt, 320 enum hinic_mod_type mod, u8 cmd, 321 u8 *buf_in, u16 in_size, 322 enum mgmt_direction_type direction, 323 u16 resp_msg_id) 324 { 325 int err; 326 327 /* Lock the sync_msg_buf */ 328 down(&pf_to_mgmt->sync_msg_lock); 329 330 err = send_msg_to_mgmt(pf_to_mgmt, mod, cmd, buf_in, in_size, 331 MSG_NO_ACK, direction, resp_msg_id); 332 333 up(&pf_to_mgmt->sync_msg_lock); 334 return err; 335 } 336 337 /** 338 * hinic_msg_to_mgmt - send message to mgmt 339 * @pf_to_mgmt: PF to MGMT channel 340 * @mod: module in the chip that will get the message 341 * @cmd: command of the message 342 * @buf_in: the msg data 343 * @in_size: the msg data length 344 * @buf_out: response 345 * @out_size: returned response length 346 * @sync: sync msg or async msg 347 * 348 * Return 0 - Success, negative - Failure 349 **/ 350 int hinic_msg_to_mgmt(struct hinic_pf_to_mgmt *pf_to_mgmt, 351 enum hinic_mod_type mod, u8 cmd, 352 void *buf_in, u16 in_size, void *buf_out, u16 *out_size, 353 enum hinic_mgmt_msg_type sync) 354 { 355 struct hinic_hwif *hwif = pf_to_mgmt->hwif; 356 struct pci_dev *pdev = hwif->pdev; 357 u32 timeout = 0; 358 359 if (sync != HINIC_MGMT_MSG_SYNC) { 360 dev_err(&pdev->dev, "Invalid MGMT msg type\n"); 361 return -EINVAL; 362 } 363 364 if (!MSG_SZ_IS_VALID(in_size)) { 365 dev_err(&pdev->dev, "Invalid MGMT msg buffer size\n"); 366 return -EINVAL; 367 } 368 369 if (HINIC_IS_VF(hwif)) { 370 if (cmd == HINIC_PORT_CMD_SET_FUNC_STATE) 371 timeout = SET_FUNC_PORT_MBOX_TIMEOUT; 372 373 return hinic_mbox_to_pf(pf_to_mgmt->hwdev, mod, cmd, buf_in, 374 in_size, buf_out, out_size, timeout); 375 } else { 376 if (cmd == HINIC_PORT_CMD_SET_FUNC_STATE) 377 timeout = SET_FUNC_PORT_MGMT_TIMEOUT; 378 else if (cmd == HINIC_PORT_CMD_UPDATE_FW) 379 timeout = UPDATE_FW_MGMT_TIMEOUT; 380 381 return msg_to_mgmt_sync(pf_to_mgmt, mod, cmd, buf_in, in_size, 382 buf_out, out_size, MGMT_DIRECT_SEND, 383 MSG_NOT_RESP, timeout); 384 } 385 } 386 387 static void recv_mgmt_msg_work_handler(struct work_struct *work) 388 { 389 struct hinic_mgmt_msg_handle_work *mgmt_work = 390 container_of(work, struct hinic_mgmt_msg_handle_work, work); 391 struct hinic_pf_to_mgmt *pf_to_mgmt = mgmt_work->pf_to_mgmt; 392 struct pci_dev *pdev = pf_to_mgmt->hwif->pdev; 393 u8 *buf_out = pf_to_mgmt->mgmt_ack_buf; 394 struct hinic_mgmt_cb *mgmt_cb; 395 unsigned long cb_state; 396 u16 out_size = 0; 397 398 memset(buf_out, 0, MAX_PF_MGMT_BUF_SIZE); 399 400 if (mgmt_work->mod >= HINIC_MOD_MAX) { 401 dev_err(&pdev->dev, "Unknown MGMT MSG module = %d\n", 402 mgmt_work->mod); 403 kfree(mgmt_work->msg); 404 kfree(mgmt_work); 405 return; 406 } 407 408 mgmt_cb = &pf_to_mgmt->mgmt_cb[mgmt_work->mod]; 409 410 cb_state = cmpxchg(&mgmt_cb->state, 411 HINIC_MGMT_CB_ENABLED, 412 HINIC_MGMT_CB_ENABLED | HINIC_MGMT_CB_RUNNING); 413 414 if (cb_state == HINIC_MGMT_CB_ENABLED && mgmt_cb->cb) 415 mgmt_cb->cb(mgmt_cb->handle, mgmt_work->cmd, 416 mgmt_work->msg, mgmt_work->msg_len, 417 buf_out, &out_size); 418 else 419 dev_err(&pdev->dev, "No MGMT msg handler, mod: %d, cmd: %d\n", 420 mgmt_work->mod, mgmt_work->cmd); 421 422 mgmt_cb->state &= ~HINIC_MGMT_CB_RUNNING; 423 424 if (!mgmt_work->async_mgmt_to_pf) 425 /* MGMT sent sync msg, send the response */ 426 msg_to_mgmt_async(pf_to_mgmt, mgmt_work->mod, mgmt_work->cmd, 427 buf_out, out_size, MGMT_RESP, 428 mgmt_work->msg_id); 429 430 kfree(mgmt_work->msg); 431 kfree(mgmt_work); 432 } 433 434 /** 435 * mgmt_recv_msg_handler - handler for message from mgmt cpu 436 * @pf_to_mgmt: PF to MGMT channel 437 * @recv_msg: received message details 438 **/ 439 static void mgmt_recv_msg_handler(struct hinic_pf_to_mgmt *pf_to_mgmt, 440 struct hinic_recv_msg *recv_msg) 441 { 442 struct hinic_mgmt_msg_handle_work *mgmt_work = NULL; 443 444 mgmt_work = kzalloc(sizeof(*mgmt_work), GFP_KERNEL); 445 if (!mgmt_work) 446 return; 447 448 if (recv_msg->msg_len) { 449 mgmt_work->msg = kzalloc(recv_msg->msg_len, GFP_KERNEL); 450 if (!mgmt_work->msg) { 451 kfree(mgmt_work); 452 return; 453 } 454 } 455 456 mgmt_work->pf_to_mgmt = pf_to_mgmt; 457 mgmt_work->msg_len = recv_msg->msg_len; 458 memcpy(mgmt_work->msg, recv_msg->msg, recv_msg->msg_len); 459 mgmt_work->msg_id = recv_msg->msg_id; 460 mgmt_work->mod = recv_msg->mod; 461 mgmt_work->cmd = recv_msg->cmd; 462 mgmt_work->async_mgmt_to_pf = recv_msg->async_mgmt_to_pf; 463 464 INIT_WORK(&mgmt_work->work, recv_mgmt_msg_work_handler); 465 queue_work(pf_to_mgmt->workq, &mgmt_work->work); 466 } 467 468 /** 469 * mgmt_resp_msg_handler - handler for a response message from mgmt cpu 470 * @pf_to_mgmt: PF to MGMT channel 471 * @recv_msg: received message details 472 **/ 473 static void mgmt_resp_msg_handler(struct hinic_pf_to_mgmt *pf_to_mgmt, 474 struct hinic_recv_msg *recv_msg) 475 { 476 wmb(); /* verify writing all, before reading */ 477 478 complete(&recv_msg->recv_done); 479 } 480 481 /** 482 * recv_mgmt_msg_handler - handler for a message from mgmt cpu 483 * @pf_to_mgmt: PF to MGMT channel 484 * @header: the header of the message 485 * @recv_msg: received message details 486 **/ 487 static void recv_mgmt_msg_handler(struct hinic_pf_to_mgmt *pf_to_mgmt, 488 u64 *header, struct hinic_recv_msg *recv_msg) 489 { 490 struct hinic_hwif *hwif = pf_to_mgmt->hwif; 491 struct pci_dev *pdev = hwif->pdev; 492 int seq_id, seg_len; 493 u8 *msg_body; 494 495 seq_id = HINIC_MSG_HEADER_GET(*header, SEQID); 496 seg_len = HINIC_MSG_HEADER_GET(*header, SEG_LEN); 497 498 if (seq_id >= (MAX_MSG_LEN / SEGMENT_LEN)) { 499 dev_err(&pdev->dev, "recv big mgmt msg\n"); 500 return; 501 } 502 503 msg_body = (u8 *)header + sizeof(*header); 504 memcpy(recv_msg->msg + seq_id * SEGMENT_LEN, msg_body, seg_len); 505 506 if (!HINIC_MSG_HEADER_GET(*header, LAST)) 507 return; 508 509 recv_msg->cmd = HINIC_MSG_HEADER_GET(*header, CMD); 510 recv_msg->mod = HINIC_MSG_HEADER_GET(*header, MODULE); 511 recv_msg->async_mgmt_to_pf = HINIC_MSG_HEADER_GET(*header, 512 ASYNC_MGMT_TO_PF); 513 recv_msg->msg_len = HINIC_MSG_HEADER_GET(*header, MSG_LEN); 514 recv_msg->msg_id = HINIC_MSG_HEADER_GET(*header, MSG_ID); 515 516 if (HINIC_MSG_HEADER_GET(*header, DIRECTION) == MGMT_RESP) 517 mgmt_resp_msg_handler(pf_to_mgmt, recv_msg); 518 else 519 mgmt_recv_msg_handler(pf_to_mgmt, recv_msg); 520 } 521 522 /** 523 * mgmt_msg_aeqe_handler - handler for a mgmt message event 524 * @handle: PF to MGMT channel 525 * @data: the header of the message 526 * @size: unused 527 **/ 528 static void mgmt_msg_aeqe_handler(void *handle, void *data, u8 size) 529 { 530 struct hinic_pf_to_mgmt *pf_to_mgmt = handle; 531 struct hinic_recv_msg *recv_msg; 532 u64 *header = (u64 *)data; 533 534 recv_msg = HINIC_MSG_HEADER_GET(*header, DIRECTION) == 535 MGMT_DIRECT_SEND ? 536 &pf_to_mgmt->recv_msg_from_mgmt : 537 &pf_to_mgmt->recv_resp_msg_from_mgmt; 538 539 recv_mgmt_msg_handler(pf_to_mgmt, header, recv_msg); 540 } 541 542 /** 543 * alloc_recv_msg - allocate receive message memory 544 * @pf_to_mgmt: PF to MGMT channel 545 * @recv_msg: pointer that will hold the allocated data 546 * 547 * Return 0 - Success, negative - Failure 548 **/ 549 static int alloc_recv_msg(struct hinic_pf_to_mgmt *pf_to_mgmt, 550 struct hinic_recv_msg *recv_msg) 551 { 552 struct hinic_hwif *hwif = pf_to_mgmt->hwif; 553 struct pci_dev *pdev = hwif->pdev; 554 555 recv_msg->msg = devm_kzalloc(&pdev->dev, MAX_PF_MGMT_BUF_SIZE, 556 GFP_KERNEL); 557 if (!recv_msg->msg) 558 return -ENOMEM; 559 560 recv_msg->buf_out = devm_kzalloc(&pdev->dev, MAX_PF_MGMT_BUF_SIZE, 561 GFP_KERNEL); 562 if (!recv_msg->buf_out) 563 return -ENOMEM; 564 565 return 0; 566 } 567 568 /** 569 * alloc_msg_buf - allocate all the message buffers of PF to MGMT channel 570 * @pf_to_mgmt: PF to MGMT channel 571 * 572 * Return 0 - Success, negative - Failure 573 **/ 574 static int alloc_msg_buf(struct hinic_pf_to_mgmt *pf_to_mgmt) 575 { 576 struct hinic_hwif *hwif = pf_to_mgmt->hwif; 577 struct pci_dev *pdev = hwif->pdev; 578 int err; 579 580 err = alloc_recv_msg(pf_to_mgmt, 581 &pf_to_mgmt->recv_msg_from_mgmt); 582 if (err) { 583 dev_err(&pdev->dev, "Failed to allocate recv msg\n"); 584 return err; 585 } 586 587 err = alloc_recv_msg(pf_to_mgmt, 588 &pf_to_mgmt->recv_resp_msg_from_mgmt); 589 if (err) { 590 dev_err(&pdev->dev, "Failed to allocate resp recv msg\n"); 591 return err; 592 } 593 594 pf_to_mgmt->sync_msg_buf = devm_kzalloc(&pdev->dev, 595 MAX_PF_MGMT_BUF_SIZE, 596 GFP_KERNEL); 597 if (!pf_to_mgmt->sync_msg_buf) 598 return -ENOMEM; 599 600 pf_to_mgmt->mgmt_ack_buf = devm_kzalloc(&pdev->dev, 601 MAX_PF_MGMT_BUF_SIZE, 602 GFP_KERNEL); 603 if (!pf_to_mgmt->mgmt_ack_buf) 604 return -ENOMEM; 605 606 return 0; 607 } 608 609 /** 610 * hinic_pf_to_mgmt_init - initialize PF to MGMT channel 611 * @pf_to_mgmt: PF to MGMT channel 612 * @hwif: HW interface the PF to MGMT will use for accessing HW 613 * 614 * Return 0 - Success, negative - Failure 615 **/ 616 int hinic_pf_to_mgmt_init(struct hinic_pf_to_mgmt *pf_to_mgmt, 617 struct hinic_hwif *hwif) 618 { 619 struct hinic_pfhwdev *pfhwdev = mgmt_to_pfhwdev(pf_to_mgmt); 620 struct hinic_hwdev *hwdev = &pfhwdev->hwdev; 621 struct pci_dev *pdev = hwif->pdev; 622 int err; 623 624 pf_to_mgmt->hwif = hwif; 625 pf_to_mgmt->hwdev = hwdev; 626 627 if (HINIC_IS_VF(hwif)) 628 return 0; 629 630 err = hinic_health_reporters_create(hwdev->devlink_dev); 631 if (err) 632 return err; 633 634 sema_init(&pf_to_mgmt->sync_msg_lock, 1); 635 pf_to_mgmt->workq = create_singlethread_workqueue("hinic_mgmt"); 636 if (!pf_to_mgmt->workq) { 637 dev_err(&pdev->dev, "Failed to initialize MGMT workqueue\n"); 638 hinic_health_reporters_destroy(hwdev->devlink_dev); 639 return -ENOMEM; 640 } 641 pf_to_mgmt->sync_msg_id = 0; 642 643 err = alloc_msg_buf(pf_to_mgmt); 644 if (err) { 645 dev_err(&pdev->dev, "Failed to allocate msg buffers\n"); 646 destroy_workqueue(pf_to_mgmt->workq); 647 hinic_health_reporters_destroy(hwdev->devlink_dev); 648 return err; 649 } 650 651 err = hinic_api_cmd_init(pf_to_mgmt->cmd_chain, hwif); 652 if (err) { 653 dev_err(&pdev->dev, "Failed to initialize cmd chains\n"); 654 destroy_workqueue(pf_to_mgmt->workq); 655 hinic_health_reporters_destroy(hwdev->devlink_dev); 656 return err; 657 } 658 659 hinic_aeq_register_hw_cb(&hwdev->aeqs, HINIC_MSG_FROM_MGMT_CPU, 660 pf_to_mgmt, 661 mgmt_msg_aeqe_handler); 662 return 0; 663 } 664 665 /** 666 * hinic_pf_to_mgmt_free - free PF to MGMT channel 667 * @pf_to_mgmt: PF to MGMT channel 668 **/ 669 void hinic_pf_to_mgmt_free(struct hinic_pf_to_mgmt *pf_to_mgmt) 670 { 671 struct hinic_pfhwdev *pfhwdev = mgmt_to_pfhwdev(pf_to_mgmt); 672 struct hinic_hwdev *hwdev = &pfhwdev->hwdev; 673 674 if (HINIC_IS_VF(hwdev->hwif)) 675 return; 676 677 hinic_aeq_unregister_hw_cb(&hwdev->aeqs, HINIC_MSG_FROM_MGMT_CPU); 678 hinic_api_cmd_free(pf_to_mgmt->cmd_chain); 679 destroy_workqueue(pf_to_mgmt->workq); 680 hinic_health_reporters_destroy(hwdev->devlink_dev); 681 } 682