drivers/net/ethernet/huawei/hinic/hinic_hw_mgmt.c

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