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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Huawei HiNIC PCI Express Linux driver
   3  * Copyright(c) 2017 Huawei Technologies Co., Ltd
   4  */
   5 #include <linux/pci.h>
   6 #include <linux/delay.h>
   7 #include <linux/types.h>
   8 #include <linux/completion.h>
   9 #include <linux/semaphore.h>
  10 #include <linux/spinlock.h>
  11 #include <linux/workqueue.h>
  12
  13 #include "hinic_hw_if.h"
  14 #include "hinic_hw_mgmt.h"
  15 #include "hinic_hw_csr.h"
  16 #include "hinic_hw_dev.h"
  17 #include "hinic_hw_mbox.h"
  18
  19 #define HINIC_MBOX_INT_DST_FUNC_SHIFT                           0
  20 #define HINIC_MBOX_INT_DST_AEQN_SHIFT                           10
  21 #define HINIC_MBOX_INT_SRC_RESP_AEQN_SHIFT                      12
  22 #define HINIC_MBOX_INT_STAT_DMA_SHIFT                           14
  23 /* The size of data to be sended (unit of 4 bytes) */
  24 #define HINIC_MBOX_INT_TX_SIZE_SHIFT                            20
  25 /* SO_RO(strong order, relax order) */
  26 #define HINIC_MBOX_INT_STAT_DMA_SO_RO_SHIFT                     25
  27 #define HINIC_MBOX_INT_WB_EN_SHIFT                              28
  28
  29 #define HINIC_MBOX_INT_DST_FUNC_MASK                            0x3FF
  30 #define HINIC_MBOX_INT_DST_AEQN_MASK                            0x3
  31 #define HINIC_MBOX_INT_SRC_RESP_AEQN_MASK                       0x3
  32 #define HINIC_MBOX_INT_STAT_DMA_MASK                            0x3F
  33 #define HINIC_MBOX_INT_TX_SIZE_MASK                             0x1F
  34 #define HINIC_MBOX_INT_STAT_DMA_SO_RO_MASK                      0x3
  35 #define HINIC_MBOX_INT_WB_EN_MASK                               0x1
  36
  37 #define HINIC_MBOX_INT_SET(val, field)  \
  38                         (((val) & HINIC_MBOX_INT_##field##_MASK) << \
  39                         HINIC_MBOX_INT_##field##_SHIFT)
  40
  41 enum hinic_mbox_tx_status {
  42         TX_NOT_DONE = 1,
  43 };
  44
  45 #define HINIC_MBOX_CTRL_TRIGGER_AEQE_SHIFT                      0
  46
  47 /* specifies the issue request for the message data.
  48  * 0 - Tx request is done;
  49  * 1 - Tx request is in process.
  50  */
  51 #define HINIC_MBOX_CTRL_TX_STATUS_SHIFT                         1
  52
  53 #define HINIC_MBOX_CTRL_TRIGGER_AEQE_MASK                       0x1
  54 #define HINIC_MBOX_CTRL_TX_STATUS_MASK                          0x1
  55
  56 #define HINIC_MBOX_CTRL_SET(val, field) \
  57                         (((val) & HINIC_MBOX_CTRL_##field##_MASK) << \
  58                         HINIC_MBOX_CTRL_##field##_SHIFT)
  59
  60 #define HINIC_MBOX_HEADER_MSG_LEN_SHIFT                         0
  61 #define HINIC_MBOX_HEADER_MODULE_SHIFT                          11
  62 #define HINIC_MBOX_HEADER_SEG_LEN_SHIFT                         16
  63 #define HINIC_MBOX_HEADER_NO_ACK_SHIFT                          22
  64 #define HINIC_MBOX_HEADER_SEQID_SHIFT                           24
  65 #define HINIC_MBOX_HEADER_LAST_SHIFT                            30
  66
  67 /* specifies the mailbox message direction
  68  * 0 - send
  69  * 1 - receive
  70  */
  71 #define HINIC_MBOX_HEADER_DIRECTION_SHIFT                       31
  72 #define HINIC_MBOX_HEADER_CMD_SHIFT                             32
  73 #define HINIC_MBOX_HEADER_MSG_ID_SHIFT                          40
  74 #define HINIC_MBOX_HEADER_STATUS_SHIFT                          48
  75 #define HINIC_MBOX_HEADER_SRC_GLB_FUNC_IDX_SHIFT                54
  76
  77 #define HINIC_MBOX_HEADER_MSG_LEN_MASK                          0x7FF
  78 #define HINIC_MBOX_HEADER_MODULE_MASK                           0x1F
  79 #define HINIC_MBOX_HEADER_SEG_LEN_MASK                          0x3F
  80 #define HINIC_MBOX_HEADER_NO_ACK_MASK                           0x1
  81 #define HINIC_MBOX_HEADER_SEQID_MASK                            0x3F
  82 #define HINIC_MBOX_HEADER_LAST_MASK                             0x1
  83 #define HINIC_MBOX_HEADER_DIRECTION_MASK                        0x1
  84 #define HINIC_MBOX_HEADER_CMD_MASK                              0xFF
  85 #define HINIC_MBOX_HEADER_MSG_ID_MASK                           0xFF
  86 #define HINIC_MBOX_HEADER_STATUS_MASK                           0x3F
  87 #define HINIC_MBOX_HEADER_SRC_GLB_FUNC_IDX_MASK                 0x3FF
  88
  89 #define HINIC_MBOX_HEADER_GET(val, field)       \
  90                         (((val) >> HINIC_MBOX_HEADER_##field##_SHIFT) & \
  91                         HINIC_MBOX_HEADER_##field##_MASK)
  92 #define HINIC_MBOX_HEADER_SET(val, field)       \
  93                         ((u64)((val) & HINIC_MBOX_HEADER_##field##_MASK) << \
  94                         HINIC_MBOX_HEADER_##field##_SHIFT)
  95
  96 #define MBOX_SEGLEN_MASK                        \
  97                 HINIC_MBOX_HEADER_SET(HINIC_MBOX_HEADER_SEG_LEN_MASK, SEG_LEN)
  98
  99 #define HINIC_MBOX_SEG_LEN                      48
 100 #define HINIC_MBOX_COMP_TIME                    8000U
 101 #define MBOX_MSG_POLLING_TIMEOUT                8000
 102
 103 #define HINIC_MBOX_DATA_SIZE                    2040
 104
 105 #define MBOX_MAX_BUF_SZ                         2048UL
 106 #define MBOX_HEADER_SZ                          8
 107
 108 #define MBOX_INFO_SZ                            4
 109
 110 /* MBOX size is 64B, 8B for mbox_header, 4B reserved */
 111 #define MBOX_SEG_LEN                            48
 112 #define MBOX_SEG_LEN_ALIGN                      4
 113 #define MBOX_WB_STATUS_LEN                      16UL
 114
 115 /* mbox write back status is 16B, only first 4B is used */
 116 #define MBOX_WB_STATUS_ERRCODE_MASK             0xFFFF
 117 #define MBOX_WB_STATUS_MASK                     0xFF
 118 #define MBOX_WB_ERROR_CODE_MASK                 0xFF00
 119 #define MBOX_WB_STATUS_FINISHED_SUCCESS         0xFF
 120 #define MBOX_WB_STATUS_NOT_FINISHED             0x00
 121
 122 #define MBOX_STATUS_FINISHED(wb)        \
 123         (((wb) & MBOX_WB_STATUS_MASK) != MBOX_WB_STATUS_NOT_FINISHED)
 124 #define MBOX_STATUS_SUCCESS(wb)         \
 125         (((wb) & MBOX_WB_STATUS_MASK) == MBOX_WB_STATUS_FINISHED_SUCCESS)
 126 #define MBOX_STATUS_ERRCODE(wb)         \
 127         ((wb) & MBOX_WB_ERROR_CODE_MASK)
 128
 129 #define SEQ_ID_START_VAL                        0
 130 #define SEQ_ID_MAX_VAL                          42
 131
 132 #define NO_DMA_ATTRIBUTE_VAL                    0
 133
 134 #define HINIC_MBOX_RSP_AEQN                     2
 135 #define HINIC_MBOX_RECV_AEQN                    0
 136
 137 #define MBOX_MSG_NO_DATA_LEN                    1
 138
 139 #define MBOX_BODY_FROM_HDR(header)      ((u8 *)(header) + MBOX_HEADER_SZ)
 140 #define MBOX_AREA(hwif)                 \
 141         ((hwif)->cfg_regs_bar + HINIC_FUNC_CSR_MAILBOX_DATA_OFF)
 142
 143 #define IS_PF_OR_PPF_SRC(src_func_idx)  ((src_func_idx) < HINIC_MAX_PF_FUNCS)
 144
 145 #define MBOX_MSG_ID_MASK                0xFF
 146 #define MBOX_MSG_ID(func_to_func)       ((func_to_func)->send_msg_id)
 147 #define MBOX_MSG_ID_INC(func_to_func_mbox) (MBOX_MSG_ID(func_to_func_mbox) = \
 148                         (MBOX_MSG_ID(func_to_func_mbox) + 1) & MBOX_MSG_ID_MASK)
 149
 150 #define FUNC_ID_OFF_SET_8B              8
 151
 152 /* max message counter wait to process for one function */
 153 #define HINIC_MAX_MSG_CNT_TO_PROCESS    10
 154
 155 #define HINIC_QUEUE_MIN_DEPTH           6
 156 #define HINIC_QUEUE_MAX_DEPTH           12
 157 #define HINIC_MAX_RX_BUFFER_SIZE                15
 158
 159 enum hinic_hwif_direction_type {
 160         HINIC_HWIF_DIRECT_SEND  = 0,
 161         HINIC_HWIF_RESPONSE     = 1,
 162 };
 163
 164 enum mbox_send_mod {
 165         MBOX_SEND_MSG_INT,
 166 };
 167
 168 enum mbox_seg_type {
 169         NOT_LAST_SEG,
 170         LAST_SEG,
 171 };
 172
 173 enum mbox_ordering_type {
 174         STRONG_ORDER,
 175 };
 176
 177 enum mbox_write_back_type {
 178         WRITE_BACK = 1,
 179 };
 180
 181 enum mbox_aeq_trig_type {
 182         NOT_TRIGGER,
 183         TRIGGER,
 184 };
 185
 186 static bool check_func_id(struct hinic_hwdev *hwdev, u16 src_func_idx,
 187                           const void *buf_in, u16 in_size, u16 offset)
 188 {
 189         u16 func_idx;
 190
 191         if (in_size < offset + sizeof(func_idx)) {
 192                 dev_warn(&hwdev->hwif->pdev->dev,
 193                          "Receive mailbox msg len: %d less than %d Bytes is invalid\n",
 194                          in_size, offset);
 195                 return false;
 196         }
 197
 198         func_idx = *((u16 *)((u8 *)buf_in + offset));
 199
 200         if (src_func_idx != func_idx) {
 201                 dev_warn(&hwdev->hwif->pdev->dev,
 202                          "Receive mailbox function id: 0x%x not equal to msg function id: 0x%x\n",
 203                          src_func_idx, func_idx);
 204                 return false;
 205         }
 206
 207         return true;
 208 }
 209
 210 bool hinic_mbox_check_func_id_8B(struct hinic_hwdev *hwdev, u16 func_idx,
 211                                  void *buf_in, u16 in_size)
 212 {
 213         return check_func_id(hwdev, func_idx, buf_in, in_size,
 214                              FUNC_ID_OFF_SET_8B);
 215 }
 216
 217 /**
 218  * hinic_register_pf_mbox_cb - register mbox callback for pf
 219  * @hwdev: the pointer to hw device
 220  * @mod:        specific mod that the callback will handle
 221  * @callback:   callback function
 222  * Return: 0 - success, negative - failure
 223  */
 224 int hinic_register_pf_mbox_cb(struct hinic_hwdev *hwdev,
 225                               enum hinic_mod_type mod,
 226                               hinic_pf_mbox_cb callback)
 227 {
 228         struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func;
 229
 230         if (mod >= HINIC_MOD_MAX)
 231                 return -EFAULT;
 232
 233         func_to_func->pf_mbox_cb[mod] = callback;
 234
 235         set_bit(HINIC_PF_MBOX_CB_REG, &func_to_func->pf_mbox_cb_state[mod]);
 236
 237         return 0;
 238 }
 239
 240 /**
 241  * hinic_register_vf_mbox_cb - register mbox callback for vf
 242  * @hwdev: the pointer to hw device
 243  * @mod:        specific mod that the callback will handle
 244  * @callback:   callback function
 245  * Return: 0 - success, negative - failure
 246  */
 247 int hinic_register_vf_mbox_cb(struct hinic_hwdev *hwdev,
 248                               enum hinic_mod_type mod,
 249                               hinic_vf_mbox_cb callback)
 250 {
 251         struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func;
 252
 253         if (mod >= HINIC_MOD_MAX)
 254                 return -EFAULT;
 255
 256         func_to_func->vf_mbox_cb[mod] = callback;
 257
 258         set_bit(HINIC_VF_MBOX_CB_REG, &func_to_func->vf_mbox_cb_state[mod]);
 259
 260         return 0;
 261 }
 262
 263 /**
 264  * hinic_unregister_pf_mbox_cb - unregister the mbox callback for pf
 265  * @hwdev:      the pointer to hw device
 266  * @mod:        specific mod that the callback will handle
 267  */
 268 void hinic_unregister_pf_mbox_cb(struct hinic_hwdev *hwdev,
 269                                  enum hinic_mod_type mod)
 270 {
 271         struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func;
 272
 273         clear_bit(HINIC_PF_MBOX_CB_REG, &func_to_func->pf_mbox_cb_state[mod]);
 274
 275         while (test_bit(HINIC_PF_MBOX_CB_RUNNING,
 276                         &func_to_func->pf_mbox_cb_state[mod]))
 277                 usleep_range(900, 1000);
 278
 279         func_to_func->pf_mbox_cb[mod] = NULL;
 280 }
 281
 282 /**
 283  * hinic_unregister_vf_mbox_cb - unregister the mbox callback for vf
 284  * @hwdev:      the pointer to hw device
 285  * @mod:        specific mod that the callback will handle
 286  */
 287 void hinic_unregister_vf_mbox_cb(struct hinic_hwdev *hwdev,
 288                                  enum hinic_mod_type mod)
 289 {
 290         struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func;
 291
 292         clear_bit(HINIC_VF_MBOX_CB_REG, &func_to_func->vf_mbox_cb_state[mod]);
 293
 294         while (test_bit(HINIC_VF_MBOX_CB_RUNNING,
 295                         &func_to_func->vf_mbox_cb_state[mod]))
 296                 usleep_range(900, 1000);
 297
 298         func_to_func->vf_mbox_cb[mod] = NULL;
 299 }
 300
 301 static int recv_vf_mbox_handler(struct hinic_mbox_func_to_func *func_to_func,
 302                                 struct hinic_recv_mbox *recv_mbox,
 303                                 void *buf_out, u16 *out_size)
 304 {
 305         hinic_vf_mbox_cb cb;
 306         int ret = 0;
 307
 308         if (recv_mbox->mod >= HINIC_MOD_MAX) {
 309                 dev_err(&func_to_func->hwif->pdev->dev, "Receive illegal mbox message, mod = %d\n",
 310                         recv_mbox->mod);
 311                 return -EINVAL;
 312         }
 313
 314         set_bit(HINIC_VF_MBOX_CB_RUNNING,
 315                 &func_to_func->vf_mbox_cb_state[recv_mbox->mod]);
 316
 317         cb = func_to_func->vf_mbox_cb[recv_mbox->mod];
 318         if (cb && test_bit(HINIC_VF_MBOX_CB_REG,
 319                            &func_to_func->vf_mbox_cb_state[recv_mbox->mod])) {
 320                 cb(func_to_func->hwdev, recv_mbox->cmd, recv_mbox->mbox,
 321                    recv_mbox->mbox_len, buf_out, out_size);
 322         } else {
 323                 dev_err(&func_to_func->hwif->pdev->dev, "VF mbox cb is not registered\n");
 324                 ret = -EINVAL;
 325         }
 326
 327         clear_bit(HINIC_VF_MBOX_CB_RUNNING,
 328                   &func_to_func->vf_mbox_cb_state[recv_mbox->mod]);
 329
 330         return ret;
 331 }
 332
 333 static int
 334 recv_pf_from_vf_mbox_handler(struct hinic_mbox_func_to_func *func_to_func,
 335                              struct hinic_recv_mbox *recv_mbox,
 336                              u16 src_func_idx, void *buf_out,
 337                              u16 *out_size)
 338 {
 339         hinic_pf_mbox_cb cb;
 340         u16 vf_id = 0;
 341         int ret;
 342
 343         if (recv_mbox->mod >= HINIC_MOD_MAX) {
 344                 dev_err(&func_to_func->hwif->pdev->dev, "Receive illegal mbox message, mod = %d\n",
 345                         recv_mbox->mod);
 346                 return -EINVAL;
 347         }
 348
 349         set_bit(HINIC_PF_MBOX_CB_RUNNING,
 350                 &func_to_func->pf_mbox_cb_state[recv_mbox->mod]);
 351
 352         cb = func_to_func->pf_mbox_cb[recv_mbox->mod];
 353         if (cb && test_bit(HINIC_PF_MBOX_CB_REG,
 354                            &func_to_func->pf_mbox_cb_state[recv_mbox->mod])) {
 355                 vf_id = src_func_idx -
 356                         hinic_glb_pf_vf_offset(func_to_func->hwif);
 357                 ret = cb(func_to_func->hwdev, vf_id, recv_mbox->cmd,
 358                          recv_mbox->mbox, recv_mbox->mbox_len,
 359                          buf_out, out_size);
 360         } else {
 361                 dev_err(&func_to_func->hwif->pdev->dev, "PF mbox mod(0x%x) cb is not registered\n",
 362                         recv_mbox->mod);
 363                 ret = -EINVAL;
 364         }
 365
 366         clear_bit(HINIC_PF_MBOX_CB_RUNNING,
 367                   &func_to_func->pf_mbox_cb_state[recv_mbox->mod]);
 368
 369         return ret;
 370 }
 371
 372 static bool check_mbox_seq_id_and_seg_len(struct hinic_recv_mbox *recv_mbox,
 373                                           u8 seq_id, u8 seg_len)
 374 {
 375         if (seq_id > SEQ_ID_MAX_VAL || seg_len > MBOX_SEG_LEN)
 376                 return false;
 377
 378         if (seq_id == 0) {
 379                 recv_mbox->seq_id = seq_id;
 380         } else {
 381                 if (seq_id != recv_mbox->seq_id + 1)
 382                         return false;
 383
 384                 recv_mbox->seq_id = seq_id;
 385         }
 386
 387         return true;
 388 }
 389
 390 static void resp_mbox_handler(struct hinic_mbox_func_to_func *func_to_func,
 391                               struct hinic_recv_mbox *recv_mbox)
 392 {
 393         spin_lock(&func_to_func->mbox_lock);
 394         if (recv_mbox->msg_info.msg_id == func_to_func->send_msg_id &&
 395             func_to_func->event_flag == EVENT_START)
 396                 complete(&recv_mbox->recv_done);
 397         else
 398                 dev_err(&func_to_func->hwif->pdev->dev,
 399                         "Mbox response timeout, current send msg id(0x%x), recv msg id(0x%x), status(0x%x)\n",
 400                         func_to_func->send_msg_id, recv_mbox->msg_info.msg_id,
 401                         recv_mbox->msg_info.status);
 402         spin_unlock(&func_to_func->mbox_lock);
 403 }
 404
 405 static void recv_func_mbox_handler(struct hinic_mbox_func_to_func *func_to_func,
 406                                    struct hinic_recv_mbox *recv_mbox,
 407                                    u16 src_func_idx);
 408
 409 static void recv_func_mbox_work_handler(struct work_struct *work)
 410 {
 411         struct hinic_mbox_work *mbox_work =
 412                         container_of(work, struct hinic_mbox_work, work);
 413         struct hinic_recv_mbox *recv_mbox;
 414
 415         recv_func_mbox_handler(mbox_work->func_to_func, mbox_work->recv_mbox,
 416                                mbox_work->src_func_idx);
 417
 418         recv_mbox =
 419                 &mbox_work->func_to_func->mbox_send[mbox_work->src_func_idx];
 420
 421         atomic_dec(&recv_mbox->msg_cnt);
 422
 423         kfree(mbox_work);
 424 }
 425
 426 static void recv_mbox_handler(struct hinic_mbox_func_to_func *func_to_func,
 427                               void *header, struct hinic_recv_mbox *recv_mbox)
 428 {
 429         void *mbox_body = MBOX_BODY_FROM_HDR(header);
 430         struct hinic_recv_mbox *rcv_mbox_temp = NULL;
 431         u64 mbox_header = *((u64 *)header);
 432         struct hinic_mbox_work *mbox_work;
 433         u8 seq_id, seg_len;
 434         u16 src_func_idx;
 435         int pos;
 436
 437         seq_id = HINIC_MBOX_HEADER_GET(mbox_header, SEQID);
 438         seg_len = HINIC_MBOX_HEADER_GET(mbox_header, SEG_LEN);
 439         src_func_idx = HINIC_MBOX_HEADER_GET(mbox_header, SRC_GLB_FUNC_IDX);
 440
 441         if (!check_mbox_seq_id_and_seg_len(recv_mbox, seq_id, seg_len)) {
 442                 dev_err(&func_to_func->hwif->pdev->dev,
 443                         "Mailbox sequence and segment check fail, src func id: 0x%x, front id: 0x%x, current id: 0x%x, seg len: 0x%x\n",
 444                         src_func_idx, recv_mbox->seq_id, seq_id, seg_len);
 445                 recv_mbox->seq_id = SEQ_ID_MAX_VAL;
 446                 return;
 447         }
 448
 449         pos = seq_id * MBOX_SEG_LEN;
 450         memcpy((u8 *)recv_mbox->mbox + pos, mbox_body,
 451                HINIC_MBOX_HEADER_GET(mbox_header, SEG_LEN));
 452
 453         if (!HINIC_MBOX_HEADER_GET(mbox_header, LAST))
 454                 return;
 455
 456         recv_mbox->cmd = HINIC_MBOX_HEADER_GET(mbox_header, CMD);
 457         recv_mbox->mod = HINIC_MBOX_HEADER_GET(mbox_header, MODULE);
 458         recv_mbox->mbox_len = HINIC_MBOX_HEADER_GET(mbox_header, MSG_LEN);
 459         recv_mbox->ack_type = HINIC_MBOX_HEADER_GET(mbox_header, NO_ACK);
 460         recv_mbox->msg_info.msg_id = HINIC_MBOX_HEADER_GET(mbox_header, MSG_ID);
 461         recv_mbox->msg_info.status = HINIC_MBOX_HEADER_GET(mbox_header, STATUS);
 462         recv_mbox->seq_id = SEQ_ID_MAX_VAL;
 463
 464         if (HINIC_MBOX_HEADER_GET(mbox_header, DIRECTION) ==
 465             HINIC_HWIF_RESPONSE) {
 466                 resp_mbox_handler(func_to_func, recv_mbox);
 467                 return;
 468         }
 469
 470         if (atomic_read(&recv_mbox->msg_cnt) > HINIC_MAX_MSG_CNT_TO_PROCESS) {
 471                 dev_warn(&func_to_func->hwif->pdev->dev,
 472                          "This function(%u) have %d message wait to process,can't add to work queue\n",
 473                          src_func_idx, atomic_read(&recv_mbox->msg_cnt));
 474                 return;
 475         }
 476
 477         rcv_mbox_temp = kmemdup(recv_mbox, sizeof(*rcv_mbox_temp), GFP_KERNEL);
 478         if (!rcv_mbox_temp)
 479                 return;
 480
 481         rcv_mbox_temp->mbox = kmemdup(recv_mbox->mbox, MBOX_MAX_BUF_SZ,
 482                                       GFP_KERNEL);
 483         if (!rcv_mbox_temp->mbox)
 484                 goto err_alloc_rcv_mbox_msg;
 485
 486         rcv_mbox_temp->buf_out = kzalloc(MBOX_MAX_BUF_SZ, GFP_KERNEL);
 487         if (!rcv_mbox_temp->buf_out)
 488                 goto err_alloc_rcv_mbox_buf;
 489
 490         mbox_work = kzalloc(sizeof(*mbox_work), GFP_KERNEL);
 491         if (!mbox_work)
 492                 goto err_alloc_mbox_work;
 493
 494         mbox_work->func_to_func = func_to_func;
 495         mbox_work->recv_mbox = rcv_mbox_temp;
 496         mbox_work->src_func_idx = src_func_idx;
 497
 498         atomic_inc(&recv_mbox->msg_cnt);
 499         INIT_WORK(&mbox_work->work, recv_func_mbox_work_handler);
 500         queue_work(func_to_func->workq, &mbox_work->work);
 501
 502         return;
 503
 504 err_alloc_mbox_work:
 505         kfree(rcv_mbox_temp->buf_out);
 506
 507 err_alloc_rcv_mbox_buf:
 508         kfree(rcv_mbox_temp->mbox);
 509
 510 err_alloc_rcv_mbox_msg:
 511         kfree(rcv_mbox_temp);
 512 }
 513
 514 static int set_vf_mbox_random_id(struct hinic_hwdev *hwdev, u16 func_id)
 515 {
 516         struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func;
 517         struct hinic_set_random_id rand_info = {0};
 518         u16 out_size = sizeof(rand_info);
 519         struct hinic_pfhwdev *pfhwdev;
 520         int ret;
 521
 522         pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev);
 523
 524         rand_info.version = HINIC_CMD_VER_FUNC_ID;
 525         rand_info.func_idx = func_id;
 526         rand_info.vf_in_pf = func_id - hinic_glb_pf_vf_offset(hwdev->hwif);
 527         rand_info.random_id = get_random_u32();
 528
 529         func_to_func->vf_mbx_rand_id[func_id] = rand_info.random_id;
 530
 531         ret = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_COMM,
 532                                 HINIC_MGMT_CMD_SET_VF_RANDOM_ID,
 533                                 &rand_info, sizeof(rand_info),
 534                                 &rand_info, &out_size, HINIC_MGMT_MSG_SYNC);
 535         if ((rand_info.status != HINIC_MGMT_CMD_UNSUPPORTED &&
 536              rand_info.status) || !out_size || ret) {
 537                 dev_err(&hwdev->hwif->pdev->dev, "Set VF random id failed, err: %d, status: 0x%x, out size: 0x%x\n",
 538                         ret, rand_info.status, out_size);
 539                 return -EIO;
 540         }
 541
 542         if (rand_info.status == HINIC_MGMT_CMD_UNSUPPORTED)
 543                 return rand_info.status;
 544
 545         func_to_func->vf_mbx_old_rand_id[func_id] =
 546                                 func_to_func->vf_mbx_rand_id[func_id];
 547
 548         return 0;
 549 }
 550
 551 static void update_random_id_work_handler(struct work_struct *work)
 552 {
 553         struct hinic_mbox_work *mbox_work =
 554                         container_of(work, struct hinic_mbox_work, work);
 555         struct hinic_mbox_func_to_func *func_to_func;
 556         u16 src = mbox_work->src_func_idx;
 557
 558         func_to_func = mbox_work->func_to_func;
 559
 560         if (set_vf_mbox_random_id(func_to_func->hwdev, src))
 561                 dev_warn(&func_to_func->hwdev->hwif->pdev->dev, "Update VF id: 0x%x random id failed\n",
 562                          mbox_work->src_func_idx);
 563
 564         kfree(mbox_work);
 565 }
 566
 567 static bool check_vf_mbox_random_id(struct hinic_mbox_func_to_func *func_to_func,
 568                                     u8 *header)
 569 {
 570         struct hinic_hwdev *hwdev = func_to_func->hwdev;
 571         struct hinic_mbox_work *mbox_work = NULL;
 572         u64 mbox_header = *((u64 *)header);
 573         u16 offset, src;
 574         u32 random_id;
 575         int vf_in_pf;
 576
 577         src = HINIC_MBOX_HEADER_GET(mbox_header, SRC_GLB_FUNC_IDX);
 578
 579         if (IS_PF_OR_PPF_SRC(src) || !func_to_func->support_vf_random)
 580                 return true;
 581
 582         if (!HINIC_IS_PPF(hwdev->hwif)) {
 583                 offset = hinic_glb_pf_vf_offset(hwdev->hwif);
 584                 vf_in_pf = src - offset;
 585
 586                 if (vf_in_pf < 1 || vf_in_pf > hwdev->nic_cap.max_vf) {
 587                         dev_warn(&hwdev->hwif->pdev->dev,
 588                                  "Receive vf id(0x%x) is invalid, vf id should be from 0x%x to 0x%x\n",
 589                                  src, offset + 1,
 590                                  hwdev->nic_cap.max_vf + offset);
 591                         return false;
 592                 }
 593         }
 594
 595         random_id = be32_to_cpu(*(u32 *)(header + MBOX_SEG_LEN +
 596                                          MBOX_HEADER_SZ));
 597
 598         if (random_id == func_to_func->vf_mbx_rand_id[src] ||
 599             random_id == func_to_func->vf_mbx_old_rand_id[src])
 600                 return true;
 601
 602         dev_warn(&hwdev->hwif->pdev->dev,
 603                  "The mailbox random id(0x%x) of func_id(0x%x) doesn't match with pf reservation(0x%x)\n",
 604                  random_id, src, func_to_func->vf_mbx_rand_id[src]);
 605
 606         mbox_work = kzalloc(sizeof(*mbox_work), GFP_KERNEL);
 607         if (!mbox_work)
 608                 return false;
 609
 610         mbox_work->func_to_func = func_to_func;
 611         mbox_work->src_func_idx = src;
 612
 613         INIT_WORK(&mbox_work->work, update_random_id_work_handler);
 614         queue_work(func_to_func->workq, &mbox_work->work);
 615
 616         return false;
 617 }
 618
 619 static void hinic_mbox_func_aeqe_handler(void *handle, void *header, u8 size)
 620 {
 621         struct hinic_mbox_func_to_func *func_to_func;
 622         u64 mbox_header = *((u64 *)header);
 623         struct hinic_recv_mbox *recv_mbox;
 624         u64 src, dir;
 625
 626         func_to_func = ((struct hinic_hwdev *)handle)->func_to_func;
 627
 628         dir = HINIC_MBOX_HEADER_GET(mbox_header, DIRECTION);
 629         src = HINIC_MBOX_HEADER_GET(mbox_header, SRC_GLB_FUNC_IDX);
 630
 631         if (src >= HINIC_MAX_FUNCTIONS) {
 632                 dev_err(&func_to_func->hwif->pdev->dev,
 633                         "Mailbox source function id:%u is invalid\n", (u32)src);
 634                 return;
 635         }
 636
 637         if (!check_vf_mbox_random_id(func_to_func, header))
 638                 return;
 639
 640         recv_mbox = (dir == HINIC_HWIF_DIRECT_SEND) ?
 641                     &func_to_func->mbox_send[src] :
 642                     &func_to_func->mbox_resp[src];
 643
 644         recv_mbox_handler(func_to_func, (u64 *)header, recv_mbox);
 645 }
 646
 647 static void hinic_mbox_self_aeqe_handler(void *handle, void *header, u8 size)
 648 {
 649         struct hinic_mbox_func_to_func *func_to_func;
 650         struct hinic_send_mbox *send_mbox;
 651
 652         func_to_func = ((struct hinic_hwdev *)handle)->func_to_func;
 653         send_mbox = &func_to_func->send_mbox;
 654
 655         complete(&send_mbox->send_done);
 656 }
 657
 658 static void clear_mbox_status(struct hinic_send_mbox *mbox)
 659 {
 660         *mbox->wb_status = 0;
 661
 662         /* clear mailbox write back status */
 663         wmb();
 664 }
 665
 666 static void mbox_copy_header(struct hinic_hwdev *hwdev,
 667                              struct hinic_send_mbox *mbox, u64 *header)
 668 {
 669         u32 i, idx_max = MBOX_HEADER_SZ / sizeof(u32);
 670         u32 *data = (u32 *)header;
 671
 672         for (i = 0; i < idx_max; i++)
 673                 __raw_writel(*(data + i), mbox->data + i * sizeof(u32));
 674 }
 675
 676 static void mbox_copy_send_data(struct hinic_hwdev *hwdev,
 677                                 struct hinic_send_mbox *mbox, void *seg,
 678                                 u16 seg_len)
 679 {
 680         u8 mbox_max_buf[MBOX_SEG_LEN] = {0};
 681         u32 data_len, chk_sz = sizeof(u32);
 682         u32 *data = seg;
 683         u32 i, idx_max;
 684
 685         /* The mbox message should be aligned in 4 bytes. */
 686         if (seg_len % chk_sz) {
 687                 memcpy(mbox_max_buf, seg, seg_len);
 688                 data = (u32 *)mbox_max_buf;
 689         }
 690
 691         data_len = seg_len;
 692         idx_max = ALIGN(data_len, chk_sz) / chk_sz;
 693
 694         for (i = 0; i < idx_max; i++)
 695                 __raw_writel(*(data + i),
 696                              mbox->data + MBOX_HEADER_SZ + i * sizeof(u32));
 697 }
 698
 699 static void write_mbox_msg_attr(struct hinic_mbox_func_to_func *func_to_func,
 700                                 u16 dst_func, u16 dst_aeqn, u16 seg_len,
 701                                 int poll)
 702 {
 703         u16 rsp_aeq = (dst_aeqn == 0) ? 0 : HINIC_MBOX_RSP_AEQN;
 704         u32 mbox_int, mbox_ctrl;
 705
 706         mbox_int = HINIC_MBOX_INT_SET(dst_func, DST_FUNC) |
 707                    HINIC_MBOX_INT_SET(dst_aeqn, DST_AEQN) |
 708                    HINIC_MBOX_INT_SET(rsp_aeq, SRC_RESP_AEQN) |
 709                    HINIC_MBOX_INT_SET(NO_DMA_ATTRIBUTE_VAL, STAT_DMA) |
 710                    HINIC_MBOX_INT_SET(ALIGN(MBOX_SEG_LEN + MBOX_HEADER_SZ +
 711                                       MBOX_INFO_SZ, MBOX_SEG_LEN_ALIGN) >> 2,
 712                                       TX_SIZE) |
 713                    HINIC_MBOX_INT_SET(STRONG_ORDER, STAT_DMA_SO_RO) |
 714                    HINIC_MBOX_INT_SET(WRITE_BACK, WB_EN);
 715
 716         hinic_hwif_write_reg(func_to_func->hwif,
 717                              HINIC_FUNC_CSR_MAILBOX_INT_OFFSET_OFF, mbox_int);
 718
 719         wmb(); /* writing the mbox int attributes */
 720         mbox_ctrl = HINIC_MBOX_CTRL_SET(TX_NOT_DONE, TX_STATUS);
 721
 722         if (poll)
 723                 mbox_ctrl |= HINIC_MBOX_CTRL_SET(NOT_TRIGGER, TRIGGER_AEQE);
 724         else
 725                 mbox_ctrl |= HINIC_MBOX_CTRL_SET(TRIGGER, TRIGGER_AEQE);
 726
 727         hinic_hwif_write_reg(func_to_func->hwif,
 728                              HINIC_FUNC_CSR_MAILBOX_CONTROL_OFF, mbox_ctrl);
 729 }
 730
 731 static void dump_mox_reg(struct hinic_hwdev *hwdev)
 732 {
 733         u32 val;
 734
 735         val = hinic_hwif_read_reg(hwdev->hwif,
 736                                   HINIC_FUNC_CSR_MAILBOX_CONTROL_OFF);
 737         dev_err(&hwdev->hwif->pdev->dev, "Mailbox control reg: 0x%x\n", val);
 738
 739         val = hinic_hwif_read_reg(hwdev->hwif,
 740                                   HINIC_FUNC_CSR_MAILBOX_INT_OFFSET_OFF);
 741         dev_err(&hwdev->hwif->pdev->dev, "Mailbox interrupt offset: 0x%x\n",
 742                 val);
 743 }
 744
 745 static u16 get_mbox_status(struct hinic_send_mbox *mbox)
 746 {
 747         /* write back is 16B, but only use first 4B */
 748         u64 wb_val = be64_to_cpu(*mbox->wb_status);
 749
 750         rmb(); /* verify reading before check */
 751
 752         return (u16)(wb_val & MBOX_WB_STATUS_ERRCODE_MASK);
 753 }
 754
 755 static int
 756 wait_for_mbox_seg_completion(struct hinic_mbox_func_to_func *func_to_func,
 757                              int poll, u16 *wb_status)
 758 {
 759         struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox;
 760         struct hinic_hwdev *hwdev = func_to_func->hwdev;
 761         struct completion *done = &send_mbox->send_done;
 762         u32 cnt = 0;
 763         unsigned long jif;
 764
 765         if (poll) {
 766                 while (cnt < MBOX_MSG_POLLING_TIMEOUT) {
 767                         *wb_status = get_mbox_status(send_mbox);
 768                         if (MBOX_STATUS_FINISHED(*wb_status))
 769                                 break;
 770
 771                         usleep_range(900, 1000);
 772                         cnt++;
 773                 }
 774
 775                 if (cnt == MBOX_MSG_POLLING_TIMEOUT) {
 776                         dev_err(&hwdev->hwif->pdev->dev, "Send mailbox segment timeout, wb status: 0x%x\n",
 777                                 *wb_status);
 778                         dump_mox_reg(hwdev);
 779                         return -ETIMEDOUT;
 780                 }
 781         } else {
 782                 jif = msecs_to_jiffies(HINIC_MBOX_COMP_TIME);
 783                 if (!wait_for_completion_timeout(done, jif)) {
 784                         dev_err(&hwdev->hwif->pdev->dev, "Send mailbox segment timeout\n");
 785                         dump_mox_reg(hwdev);
 786                         hinic_dump_aeq_info(hwdev);
 787                         return -ETIMEDOUT;
 788                 }
 789
 790                 *wb_status = get_mbox_status(send_mbox);
 791         }
 792
 793         return 0;
 794 }
 795
 796 static int send_mbox_seg(struct hinic_mbox_func_to_func *func_to_func,
 797                          u64 header, u16 dst_func, void *seg, u16 seg_len,
 798                          int poll, void *msg_info)
 799 {
 800         struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox;
 801         u16 seq_dir = HINIC_MBOX_HEADER_GET(header, DIRECTION);
 802         struct hinic_hwdev *hwdev = func_to_func->hwdev;
 803         struct completion *done = &send_mbox->send_done;
 804         u8 num_aeqs = hwdev->hwif->attr.num_aeqs;
 805         u16 dst_aeqn, wb_status = 0, errcode;
 806
 807         if (num_aeqs >= 4)
 808                 dst_aeqn = (seq_dir == HINIC_HWIF_DIRECT_SEND) ?
 809                            HINIC_MBOX_RECV_AEQN : HINIC_MBOX_RSP_AEQN;
 810         else
 811                 dst_aeqn = 0;
 812
 813         if (!poll)
 814                 init_completion(done);
 815
 816         clear_mbox_status(send_mbox);
 817
 818         mbox_copy_header(hwdev, send_mbox, &header);
 819
 820         mbox_copy_send_data(hwdev, send_mbox, seg, seg_len);
 821
 822         write_mbox_msg_attr(func_to_func, dst_func, dst_aeqn, seg_len, poll);
 823
 824         wmb(); /* writing the mbox msg attributes */
 825
 826         if (wait_for_mbox_seg_completion(func_to_func, poll, &wb_status))
 827                 return -ETIMEDOUT;
 828
 829         if (!MBOX_STATUS_SUCCESS(wb_status)) {
 830                 dev_err(&hwdev->hwif->pdev->dev, "Send mailbox segment to function %d error, wb status: 0x%x\n",
 831                         dst_func, wb_status);
 832                 errcode = MBOX_STATUS_ERRCODE(wb_status);
 833                 return errcode ? errcode : -EFAULT;
 834         }
 835
 836         return 0;
 837 }
 838
 839 static int send_mbox_to_func(struct hinic_mbox_func_to_func *func_to_func,
 840                              enum hinic_mod_type mod, u16 cmd, void *msg,
 841                              u16 msg_len, u16 dst_func,
 842                              enum hinic_hwif_direction_type direction,
 843                              enum hinic_mbox_ack_type ack_type,
 844                              struct mbox_msg_info *msg_info)
 845 {
 846         struct hinic_hwdev *hwdev = func_to_func->hwdev;
 847         u16 seg_len = MBOX_SEG_LEN;
 848         u8 *msg_seg = (u8 *)msg;
 849         u16 left = msg_len;
 850         u32 seq_id = 0;
 851         u64 header = 0;
 852         int err = 0;
 853
 854         down(&func_to_func->msg_send_sem);
 855
 856         header = HINIC_MBOX_HEADER_SET(msg_len, MSG_LEN) |
 857                  HINIC_MBOX_HEADER_SET(mod, MODULE) |
 858                  HINIC_MBOX_HEADER_SET(seg_len, SEG_LEN) |
 859                  HINIC_MBOX_HEADER_SET(ack_type, NO_ACK) |
 860                  HINIC_MBOX_HEADER_SET(SEQ_ID_START_VAL, SEQID) |
 861                  HINIC_MBOX_HEADER_SET(NOT_LAST_SEG, LAST) |
 862                  HINIC_MBOX_HEADER_SET(direction, DIRECTION) |
 863                  HINIC_MBOX_HEADER_SET(cmd, CMD) |
 864                  /* The vf's offset to it's associated pf */
 865                  HINIC_MBOX_HEADER_SET(msg_info->msg_id, MSG_ID) |
 866                  HINIC_MBOX_HEADER_SET(msg_info->status, STATUS) |
 867                  HINIC_MBOX_HEADER_SET(hinic_global_func_id_hw(hwdev->hwif),
 868                                        SRC_GLB_FUNC_IDX);
 869
 870         while (!(HINIC_MBOX_HEADER_GET(header, LAST))) {
 871                 if (left <= HINIC_MBOX_SEG_LEN) {
 872                         header &= ~MBOX_SEGLEN_MASK;
 873                         header |= HINIC_MBOX_HEADER_SET(left, SEG_LEN);
 874                         header |= HINIC_MBOX_HEADER_SET(LAST_SEG, LAST);
 875
 876                         seg_len = left;
 877                 }
 878
 879                 err = send_mbox_seg(func_to_func, header, dst_func, msg_seg,
 880                                     seg_len, MBOX_SEND_MSG_INT, msg_info);
 881                 if (err) {
 882                         dev_err(&hwdev->hwif->pdev->dev, "Failed to send mbox seg, seq_id=0x%llx\n",
 883                                 HINIC_MBOX_HEADER_GET(header, SEQID));
 884                         goto err_send_mbox_seg;
 885                 }
 886
 887                 left -= HINIC_MBOX_SEG_LEN;
 888                 msg_seg += HINIC_MBOX_SEG_LEN;
 889
 890                 seq_id++;
 891                 header &= ~(HINIC_MBOX_HEADER_SET(HINIC_MBOX_HEADER_SEQID_MASK,
 892                                                   SEQID));
 893                 header |= HINIC_MBOX_HEADER_SET(seq_id, SEQID);
 894         }
 895
 896 err_send_mbox_seg:
 897         up(&func_to_func->msg_send_sem);
 898
 899         return err;
 900 }
 901
 902 static void
 903 response_for_recv_func_mbox(struct hinic_mbox_func_to_func *func_to_func,
 904                             struct hinic_recv_mbox *recv_mbox, int err,
 905                             u16 out_size, u16 src_func_idx)
 906 {
 907         struct mbox_msg_info msg_info = {0};
 908
 909         if (recv_mbox->ack_type == MBOX_ACK) {
 910                 msg_info.msg_id = recv_mbox->msg_info.msg_id;
 911                 if (err == HINIC_MBOX_PF_BUSY_ACTIVE_FW)
 912                         msg_info.status = HINIC_MBOX_PF_BUSY_ACTIVE_FW;
 913                 else if (err == HINIC_MBOX_VF_CMD_ERROR)
 914                         msg_info.status = HINIC_MBOX_VF_CMD_ERROR;
 915                 else if (err)
 916                         msg_info.status = HINIC_MBOX_PF_SEND_ERR;
 917
 918                 /* if no data needs to response, set out_size to 1 */
 919                 if (!out_size || err)
 920                         out_size = MBOX_MSG_NO_DATA_LEN;
 921
 922                 send_mbox_to_func(func_to_func, recv_mbox->mod, recv_mbox->cmd,
 923                                   recv_mbox->buf_out, out_size, src_func_idx,
 924                                   HINIC_HWIF_RESPONSE, MBOX_ACK,
 925                                   &msg_info);
 926         }
 927 }
 928
 929 static void recv_func_mbox_handler(struct hinic_mbox_func_to_func *func_to_func,
 930                                    struct hinic_recv_mbox *recv_mbox,
 931                                    u16 src_func_idx)
 932 {
 933         void *buf_out = recv_mbox->buf_out;
 934         u16 out_size = MBOX_MAX_BUF_SZ;
 935         int err = 0;
 936
 937         if (HINIC_IS_VF(func_to_func->hwif)) {
 938                 err = recv_vf_mbox_handler(func_to_func, recv_mbox, buf_out,
 939                                            &out_size);
 940         } else {
 941                 if (IS_PF_OR_PPF_SRC(src_func_idx))
 942                         dev_warn(&func_to_func->hwif->pdev->dev,
 943                                  "Unsupported pf2pf mbox msg\n");
 944                 else
 945                         err = recv_pf_from_vf_mbox_handler(func_to_func,
 946                                                            recv_mbox,
 947                                                            src_func_idx,
 948                                                            buf_out, &out_size);
 949         }
 950
 951         response_for_recv_func_mbox(func_to_func, recv_mbox, err, out_size,
 952                                     src_func_idx);
 953         kfree(recv_mbox->buf_out);
 954         kfree(recv_mbox->mbox);
 955         kfree(recv_mbox);
 956 }
 957
 958 static void set_mbox_to_func_event(struct hinic_mbox_func_to_func *func_to_func,
 959                                    enum mbox_event_state event_flag)
 960 {
 961         spin_lock(&func_to_func->mbox_lock);
 962         func_to_func->event_flag = event_flag;
 963         spin_unlock(&func_to_func->mbox_lock);
 964 }
 965
 966 static int mbox_resp_info_handler(struct hinic_mbox_func_to_func *func_to_func,
 967                                   struct hinic_recv_mbox *mbox_for_resp,
 968                                   enum hinic_mod_type mod, u16 cmd,
 969                                   void *buf_out, u16 *out_size)
 970 {
 971         int err;
 972
 973         if (mbox_for_resp->msg_info.status) {
 974                 err = mbox_for_resp->msg_info.status;
 975                 if (err != HINIC_MBOX_PF_BUSY_ACTIVE_FW)
 976                         dev_err(&func_to_func->hwif->pdev->dev, "Mbox response error(0x%x)\n",
 977                                 mbox_for_resp->msg_info.status);
 978                 return err;
 979         }
 980
 981         if (buf_out && out_size) {
 982                 if (*out_size < mbox_for_resp->mbox_len) {
 983                         dev_err(&func_to_func->hwif->pdev->dev,
 984                                 "Invalid response mbox message length: %d for mod %d cmd %d, should less than: %d\n",
 985                                 mbox_for_resp->mbox_len, mod, cmd, *out_size);
 986                         return -EFAULT;
 987                 }
 988
 989                 if (mbox_for_resp->mbox_len)
 990                         memcpy(buf_out, mbox_for_resp->mbox,
 991                                mbox_for_resp->mbox_len);
 992
 993                 *out_size = mbox_for_resp->mbox_len;
 994         }
 995
 996         return 0;
 997 }
 998
 999 int hinic_mbox_to_func(struct hinic_mbox_func_to_func *func_to_func,
1000                        enum hinic_mod_type mod, u16 cmd, u16 dst_func,
1001                        void *buf_in, u16 in_size, void *buf_out,
1002                        u16 *out_size, u32 timeout)
1003 {
1004         struct hinic_recv_mbox *mbox_for_resp;
1005         struct mbox_msg_info msg_info = {0};
1006         unsigned long timeo;
1007         int err;
1008
1009         mbox_for_resp = &func_to_func->mbox_resp[dst_func];
1010
1011         down(&func_to_func->mbox_send_sem);
1012
1013         init_completion(&mbox_for_resp->recv_done);
1014
1015         msg_info.msg_id = MBOX_MSG_ID_INC(func_to_func);
1016
1017         set_mbox_to_func_event(func_to_func, EVENT_START);
1018
1019         err = send_mbox_to_func(func_to_func, mod, cmd, buf_in, in_size,
1020                                 dst_func, HINIC_HWIF_DIRECT_SEND, MBOX_ACK,
1021                                 &msg_info);
1022         if (err) {
1023                 dev_err(&func_to_func->hwif->pdev->dev, "Send mailbox failed, msg_id: %d\n",
1024                         msg_info.msg_id);
1025                 set_mbox_to_func_event(func_to_func, EVENT_FAIL);
1026                 goto err_send_mbox;
1027         }
1028
1029         timeo = msecs_to_jiffies(timeout ? timeout : HINIC_MBOX_COMP_TIME);
1030         if (!wait_for_completion_timeout(&mbox_for_resp->recv_done, timeo)) {
1031                 set_mbox_to_func_event(func_to_func, EVENT_TIMEOUT);
1032                 dev_err(&func_to_func->hwif->pdev->dev,
1033                         "Send mbox msg timeout, msg_id: %d\n", msg_info.msg_id);
1034                 hinic_dump_aeq_info(func_to_func->hwdev);
1035                 err = -ETIMEDOUT;
1036                 goto err_send_mbox;
1037         }
1038
1039         set_mbox_to_func_event(func_to_func, EVENT_END);
1040
1041         err = mbox_resp_info_handler(func_to_func, mbox_for_resp, mod, cmd,
1042                                      buf_out, out_size);
1043
1044 err_send_mbox:
1045         up(&func_to_func->mbox_send_sem);
1046
1047         return err;
1048 }
1049
1050 static int mbox_func_params_valid(struct hinic_mbox_func_to_func *func_to_func,
1051                                   void *buf_in, u16 in_size)
1052 {
1053         if (in_size > HINIC_MBOX_DATA_SIZE) {
1054                 dev_err(&func_to_func->hwif->pdev->dev,
1055                         "Mbox msg len(%d) exceed limit(%d)\n",
1056                         in_size, HINIC_MBOX_DATA_SIZE);
1057                 return -EINVAL;
1058         }
1059
1060         return 0;
1061 }
1062
1063 int hinic_mbox_to_pf(struct hinic_hwdev *hwdev,
1064                      enum hinic_mod_type mod, u8 cmd, void *buf_in,
1065                      u16 in_size, void *buf_out, u16 *out_size, u32 timeout)
1066 {
1067         struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func;
1068         int err = mbox_func_params_valid(func_to_func, buf_in, in_size);
1069
1070         if (err)
1071                 return err;
1072
1073         if (!HINIC_IS_VF(hwdev->hwif)) {
1074                 dev_err(&hwdev->hwif->pdev->dev, "Params error, func_type: %d\n",
1075                         HINIC_FUNC_TYPE(hwdev->hwif));
1076                 return -EINVAL;
1077         }
1078
1079         return hinic_mbox_to_func(func_to_func, mod, cmd,
1080                                   hinic_pf_id_of_vf_hw(hwdev->hwif), buf_in,
1081                                   in_size, buf_out, out_size, timeout);
1082 }
1083
1084 int hinic_mbox_to_vf(struct hinic_hwdev *hwdev,
1085                      enum hinic_mod_type mod, u16 vf_id, u8 cmd, void *buf_in,
1086                      u16 in_size, void *buf_out, u16 *out_size, u32 timeout)
1087 {
1088         struct hinic_mbox_func_to_func *func_to_func;
1089         u16 dst_func_idx;
1090         int err;
1091
1092         if (!hwdev)
1093                 return -EINVAL;
1094
1095         func_to_func = hwdev->func_to_func;
1096         err = mbox_func_params_valid(func_to_func, buf_in, in_size);
1097         if (err)
1098                 return err;
1099
1100         if (HINIC_IS_VF(hwdev->hwif)) {
1101                 dev_err(&hwdev->hwif->pdev->dev, "Params error, func_type: %d\n",
1102                         HINIC_FUNC_TYPE(hwdev->hwif));
1103                 return -EINVAL;
1104         }
1105
1106         if (!vf_id) {
1107                 dev_err(&hwdev->hwif->pdev->dev,
1108                         "VF id(%d) error!\n", vf_id);
1109                 return -EINVAL;
1110         }
1111
1112         /* vf_offset_to_pf + vf_id is the vf's global function id of vf in
1113          * this pf
1114          */
1115         dst_func_idx = hinic_glb_pf_vf_offset(hwdev->hwif) + vf_id;
1116
1117         return hinic_mbox_to_func(func_to_func, mod, cmd, dst_func_idx, buf_in,
1118                                   in_size, buf_out, out_size, timeout);
1119 }
1120
1121 static int init_mbox_info(struct hinic_recv_mbox *mbox_info)
1122 {
1123         int err;
1124
1125         mbox_info->seq_id = SEQ_ID_MAX_VAL;
1126
1127         mbox_info->mbox = kzalloc(MBOX_MAX_BUF_SZ, GFP_KERNEL);
1128         if (!mbox_info->mbox)
1129                 return -ENOMEM;
1130
1131         mbox_info->buf_out = kzalloc(MBOX_MAX_BUF_SZ, GFP_KERNEL);
1132         if (!mbox_info->buf_out) {
1133                 err = -ENOMEM;
1134                 goto err_alloc_buf_out;
1135         }
1136
1137         atomic_set(&mbox_info->msg_cnt, 0);
1138
1139         return 0;
1140
1141 err_alloc_buf_out:
1142         kfree(mbox_info->mbox);
1143
1144         return err;
1145 }
1146
1147 static void clean_mbox_info(struct hinic_recv_mbox *mbox_info)
1148 {
1149         kfree(mbox_info->buf_out);
1150         kfree(mbox_info->mbox);
1151 }
1152
1153 static int alloc_mbox_info(struct hinic_hwdev *hwdev,
1154                            struct hinic_recv_mbox *mbox_info)
1155 {
1156         u16 func_idx, i;
1157         int err;
1158
1159         for (func_idx = 0; func_idx < HINIC_MAX_FUNCTIONS; func_idx++) {
1160                 err = init_mbox_info(&mbox_info[func_idx]);
1161                 if (err) {
1162                         dev_err(&hwdev->hwif->pdev->dev, "Failed to init function %d mbox info\n",
1163                                 func_idx);
1164                         goto err_init_mbox_info;
1165                 }
1166         }
1167
1168         return 0;
1169
1170 err_init_mbox_info:
1171         for (i = 0; i < func_idx; i++)
1172                 clean_mbox_info(&mbox_info[i]);
1173
1174         return err;
1175 }
1176
1177 static void free_mbox_info(struct hinic_recv_mbox *mbox_info)
1178 {
1179         u16 func_idx;
1180
1181         for (func_idx = 0; func_idx < HINIC_MAX_FUNCTIONS; func_idx++)
1182                 clean_mbox_info(&mbox_info[func_idx]);
1183 }
1184
1185 static void prepare_send_mbox(struct hinic_mbox_func_to_func *func_to_func)
1186 {
1187         struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox;
1188
1189         send_mbox->data = MBOX_AREA(func_to_func->hwif);
1190 }
1191
1192 static int alloc_mbox_wb_status(struct hinic_mbox_func_to_func *func_to_func)
1193 {
1194         struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox;
1195         struct hinic_hwdev *hwdev = func_to_func->hwdev;
1196         u32 addr_h, addr_l;
1197
1198         send_mbox->wb_vaddr = dma_alloc_coherent(&hwdev->hwif->pdev->dev,
1199                                                  MBOX_WB_STATUS_LEN,
1200                                                  &send_mbox->wb_paddr,
1201                                                  GFP_KERNEL);
1202         if (!send_mbox->wb_vaddr)
1203                 return -ENOMEM;
1204
1205         send_mbox->wb_status = send_mbox->wb_vaddr;
1206
1207         addr_h = upper_32_bits(send_mbox->wb_paddr);
1208         addr_l = lower_32_bits(send_mbox->wb_paddr);
1209
1210         hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_H_OFF,
1211                              addr_h);
1212         hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_L_OFF,
1213                              addr_l);
1214
1215         return 0;
1216 }
1217
1218 static void free_mbox_wb_status(struct hinic_mbox_func_to_func *func_to_func)
1219 {
1220         struct hinic_send_mbox *send_mbox = &func_to_func->send_mbox;
1221         struct hinic_hwdev *hwdev = func_to_func->hwdev;
1222
1223         hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_H_OFF,
1224                              0);
1225         hinic_hwif_write_reg(hwdev->hwif, HINIC_FUNC_CSR_MAILBOX_RESULT_L_OFF,
1226                              0);
1227
1228         dma_free_coherent(&hwdev->hwif->pdev->dev, MBOX_WB_STATUS_LEN,
1229                           send_mbox->wb_vaddr,
1230                           send_mbox->wb_paddr);
1231 }
1232
1233 bool hinic_mbox_check_cmd_valid(struct hinic_hwdev *hwdev,
1234                                 struct vf_cmd_check_handle *cmd_handle,
1235                                 u16 vf_id, u8 cmd, void *buf_in,
1236                                 u16 in_size, u8 size)
1237 {
1238         u16 src_idx = vf_id + hinic_glb_pf_vf_offset(hwdev->hwif);
1239         int i;
1240
1241         for (i = 0; i < size; i++) {
1242                 if (cmd == cmd_handle[i].cmd) {
1243                         if (cmd_handle[i].check_cmd)
1244                                 return cmd_handle[i].check_cmd(hwdev, src_idx,
1245                                                                buf_in, in_size);
1246                         else
1247                                 return true;
1248                 }
1249         }
1250
1251         dev_err(&hwdev->hwif->pdev->dev,
1252                 "PF Receive VF(%d) unsupported cmd(0x%x)\n",
1253                 vf_id + hinic_glb_pf_vf_offset(hwdev->hwif), cmd);
1254
1255         return false;
1256 }
1257
1258 static bool hinic_cmdq_check_vf_ctxt(struct hinic_hwdev *hwdev,
1259                                      struct hinic_cmdq_ctxt *cmdq_ctxt)
1260 {
1261         struct hinic_cmdq_ctxt_info *ctxt_info = &cmdq_ctxt->ctxt_info;
1262         u64 curr_pg_pfn, wq_block_pfn;
1263
1264         if (cmdq_ctxt->ppf_idx != HINIC_HWIF_PPF_IDX(hwdev->hwif) ||
1265             cmdq_ctxt->cmdq_type > HINIC_MAX_CMDQ_TYPES)
1266                 return false;
1267
1268         curr_pg_pfn = HINIC_CMDQ_CTXT_PAGE_INFO_GET
1269                 (ctxt_info->curr_wqe_page_pfn, CURR_WQE_PAGE_PFN);
1270         wq_block_pfn = HINIC_CMDQ_CTXT_BLOCK_INFO_GET
1271                 (ctxt_info->wq_block_pfn, WQ_BLOCK_PFN);
1272         /* VF must use 0-level CLA */
1273         if (curr_pg_pfn != wq_block_pfn)
1274                 return false;
1275
1276         return true;
1277 }
1278
1279 static bool check_cmdq_ctxt(struct hinic_hwdev *hwdev, u16 func_idx,
1280                             void *buf_in, u16 in_size)
1281 {
1282         if (!hinic_mbox_check_func_id_8B(hwdev, func_idx, buf_in, in_size))
1283                 return false;
1284
1285         return hinic_cmdq_check_vf_ctxt(hwdev, buf_in);
1286 }
1287
1288 #define HW_CTX_QPS_VALID(hw_ctxt)   \
1289                 ((hw_ctxt)->rq_depth >= HINIC_QUEUE_MIN_DEPTH &&        \
1290                 (hw_ctxt)->rq_depth <= HINIC_QUEUE_MAX_DEPTH && \
1291                 (hw_ctxt)->sq_depth >= HINIC_QUEUE_MIN_DEPTH && \
1292                 (hw_ctxt)->sq_depth <= HINIC_QUEUE_MAX_DEPTH && \
1293                 (hw_ctxt)->rx_buf_sz_idx <= HINIC_MAX_RX_BUFFER_SIZE)
1294
1295 static bool hw_ctxt_qps_param_valid(struct hinic_cmd_hw_ioctxt *hw_ctxt)
1296 {
1297         if (HW_CTX_QPS_VALID(hw_ctxt))
1298                 return true;
1299
1300         if (!hw_ctxt->rq_depth && !hw_ctxt->sq_depth &&
1301             !hw_ctxt->rx_buf_sz_idx)
1302                 return true;
1303
1304         return false;
1305 }
1306
1307 static bool check_hwctxt(struct hinic_hwdev *hwdev, u16 func_idx,
1308                          void *buf_in, u16 in_size)
1309 {
1310         struct hinic_cmd_hw_ioctxt *hw_ctxt = buf_in;
1311
1312         if (!hinic_mbox_check_func_id_8B(hwdev, func_idx, buf_in, in_size))
1313                 return false;
1314
1315         if (hw_ctxt->ppf_idx != HINIC_HWIF_PPF_IDX(hwdev->hwif))
1316                 return false;
1317
1318         if (hw_ctxt->set_cmdq_depth) {
1319                 if (hw_ctxt->cmdq_depth >= HINIC_QUEUE_MIN_DEPTH &&
1320                     hw_ctxt->cmdq_depth <= HINIC_QUEUE_MAX_DEPTH)
1321                         return true;
1322
1323                 return false;
1324         }
1325
1326         return hw_ctxt_qps_param_valid(hw_ctxt);
1327 }
1328
1329 static bool check_set_wq_page_size(struct hinic_hwdev *hwdev, u16 func_idx,
1330                                    void *buf_in, u16 in_size)
1331 {
1332         struct hinic_wq_page_size *page_size_info = buf_in;
1333
1334         if (!hinic_mbox_check_func_id_8B(hwdev, func_idx, buf_in, in_size))
1335                 return false;
1336
1337         if (page_size_info->ppf_idx != HINIC_HWIF_PPF_IDX(hwdev->hwif))
1338                 return false;
1339
1340         if (((1U << page_size_info->page_size) * SZ_4K) !=
1341             HINIC_DEFAULT_WQ_PAGE_SIZE)
1342                 return false;
1343
1344         return true;
1345 }
1346
1347 static struct vf_cmd_check_handle hw_cmd_support_vf[] = {
1348         {HINIC_COMM_CMD_START_FLR, hinic_mbox_check_func_id_8B},
1349         {HINIC_COMM_CMD_DMA_ATTR_SET, hinic_mbox_check_func_id_8B},
1350         {HINIC_COMM_CMD_CMDQ_CTXT_SET, check_cmdq_ctxt},
1351         {HINIC_COMM_CMD_CMDQ_CTXT_GET, check_cmdq_ctxt},
1352         {HINIC_COMM_CMD_HWCTXT_SET, check_hwctxt},
1353         {HINIC_COMM_CMD_HWCTXT_GET, check_hwctxt},
1354         {HINIC_COMM_CMD_SQ_HI_CI_SET, hinic_mbox_check_func_id_8B},
1355         {HINIC_COMM_CMD_RES_STATE_SET, hinic_mbox_check_func_id_8B},
1356         {HINIC_COMM_CMD_IO_RES_CLEAR, hinic_mbox_check_func_id_8B},
1357         {HINIC_COMM_CMD_CEQ_CTRL_REG_WR_BY_UP, hinic_mbox_check_func_id_8B},
1358         {HINIC_COMM_CMD_MSI_CTRL_REG_WR_BY_UP, hinic_mbox_check_func_id_8B},
1359         {HINIC_COMM_CMD_MSI_CTRL_REG_RD_BY_UP, hinic_mbox_check_func_id_8B},
1360         {HINIC_COMM_CMD_L2NIC_RESET, hinic_mbox_check_func_id_8B},
1361         {HINIC_COMM_CMD_PAGESIZE_SET, check_set_wq_page_size},
1362 };
1363
1364 static int comm_pf_mbox_handler(void *handle, u16 vf_id, u8 cmd, void *buf_in,
1365                                 u16 in_size, void *buf_out, u16 *out_size)
1366 {
1367         u8 size = ARRAY_SIZE(hw_cmd_support_vf);
1368         struct hinic_hwdev *hwdev = handle;
1369         struct hinic_pfhwdev *pfhwdev;
1370         int err = 0;
1371
1372         pfhwdev = container_of(hwdev, struct hinic_pfhwdev, hwdev);
1373
1374         if (!hinic_mbox_check_cmd_valid(handle, hw_cmd_support_vf, vf_id, cmd,
1375                                         buf_in, in_size, size)) {
1376                 dev_err(&hwdev->hwif->pdev->dev,
1377                         "PF Receive VF: %d common cmd: 0x%x or mbox len: 0x%x is invalid\n",
1378                         vf_id + hinic_glb_pf_vf_offset(hwdev->hwif), cmd,
1379                         in_size);
1380                 return HINIC_MBOX_VF_CMD_ERROR;
1381         }
1382
1383         if (cmd == HINIC_COMM_CMD_START_FLR) {
1384                 *out_size = 0;
1385         } else {
1386                 err = hinic_msg_to_mgmt(&pfhwdev->pf_to_mgmt, HINIC_MOD_COMM,
1387                                         cmd, buf_in, in_size, buf_out, out_size,
1388                                         HINIC_MGMT_MSG_SYNC);
1389                 if (err && err != HINIC_MBOX_PF_BUSY_ACTIVE_FW)
1390                         dev_err(&hwdev->hwif->pdev->dev,
1391                                 "PF mbox common callback handler err: %d\n",
1392                                 err);
1393         }
1394
1395         return err;
1396 }
1397
1398 int hinic_func_to_func_init(struct hinic_hwdev *hwdev)
1399 {
1400         struct hinic_mbox_func_to_func *func_to_func;
1401         struct hinic_pfhwdev *pfhwdev;
1402         int err;
1403
1404         pfhwdev =  container_of(hwdev, struct hinic_pfhwdev, hwdev);
1405         func_to_func = kzalloc(sizeof(*func_to_func), GFP_KERNEL);
1406         if (!func_to_func)
1407                 return -ENOMEM;
1408
1409         hwdev->func_to_func = func_to_func;
1410         func_to_func->hwdev = hwdev;
1411         func_to_func->hwif = hwdev->hwif;
1412         sema_init(&func_to_func->mbox_send_sem, 1);
1413         sema_init(&func_to_func->msg_send_sem, 1);
1414         spin_lock_init(&func_to_func->mbox_lock);
1415         func_to_func->workq = create_singlethread_workqueue(HINIC_MBOX_WQ_NAME);
1416         if (!func_to_func->workq) {
1417                 dev_err(&hwdev->hwif->pdev->dev, "Failed to initialize MBOX workqueue\n");
1418                 err = -ENOMEM;
1419                 goto err_create_mbox_workq;
1420         }
1421
1422         err = alloc_mbox_info(hwdev, func_to_func->mbox_send);
1423         if (err) {
1424                 dev_err(&hwdev->hwif->pdev->dev, "Failed to alloc mem for mbox_active\n");
1425                 goto err_alloc_mbox_for_send;
1426         }
1427
1428         err = alloc_mbox_info(hwdev, func_to_func->mbox_resp);
1429         if (err) {
1430                 dev_err(&hwdev->hwif->pdev->dev, "Failed to alloc mem for mbox_passive\n");
1431                 goto err_alloc_mbox_for_resp;
1432         }
1433
1434         err = alloc_mbox_wb_status(func_to_func);
1435         if (err) {
1436                 dev_err(&hwdev->hwif->pdev->dev, "Failed to alloc mbox write back status\n");
1437                 goto err_alloc_wb_status;
1438         }
1439
1440         prepare_send_mbox(func_to_func);
1441
1442         hinic_aeq_register_hw_cb(&hwdev->aeqs, HINIC_MBX_FROM_FUNC,
1443                                  &pfhwdev->hwdev, hinic_mbox_func_aeqe_handler);
1444         hinic_aeq_register_hw_cb(&hwdev->aeqs, HINIC_MBX_SEND_RSLT,
1445                                  &pfhwdev->hwdev, hinic_mbox_self_aeqe_handler);
1446
1447         if (!HINIC_IS_VF(hwdev->hwif))
1448                 hinic_register_pf_mbox_cb(hwdev, HINIC_MOD_COMM,
1449                                           comm_pf_mbox_handler);
1450
1451         return 0;
1452
1453 err_alloc_wb_status:
1454         free_mbox_info(func_to_func->mbox_resp);
1455
1456 err_alloc_mbox_for_resp:
1457         free_mbox_info(func_to_func->mbox_send);
1458
1459 err_alloc_mbox_for_send:
1460         destroy_workqueue(func_to_func->workq);
1461
1462 err_create_mbox_workq:
1463         kfree(func_to_func);
1464
1465         return err;
1466 }
1467
1468 void hinic_func_to_func_free(struct hinic_hwdev *hwdev)
1469 {
1470         struct hinic_mbox_func_to_func *func_to_func = hwdev->func_to_func;
1471
1472         hinic_aeq_unregister_hw_cb(&hwdev->aeqs, HINIC_MBX_FROM_FUNC);
1473         hinic_aeq_unregister_hw_cb(&hwdev->aeqs, HINIC_MBX_SEND_RSLT);
1474
1475         hinic_unregister_pf_mbox_cb(hwdev, HINIC_MOD_COMM);
1476         /* destroy workqueue before free related mbox resources in case of
1477          * illegal resource access
1478          */
1479         destroy_workqueue(func_to_func->workq);
1480
1481         free_mbox_wb_status(func_to_func);
1482         free_mbox_info(func_to_func->mbox_resp);
1483         free_mbox_info(func_to_func->mbox_send);
1484
1485         kfree(func_to_func);
1486 }
1487
1488 int hinic_vf_mbox_random_id_init(struct hinic_hwdev *hwdev)
1489 {
1490         u16 vf_offset;
1491         u8 vf_in_pf;
1492         int err = 0;
1493
1494         if (HINIC_IS_VF(hwdev->hwif))
1495                 return 0;
1496
1497         vf_offset = hinic_glb_pf_vf_offset(hwdev->hwif);
1498
1499         for (vf_in_pf = 1; vf_in_pf <= hwdev->nic_cap.max_vf; vf_in_pf++) {
1500                 err = set_vf_mbox_random_id(hwdev, vf_offset + vf_in_pf);
1501                 if (err)
1502                         break;
1503         }
1504
1505         if (err == HINIC_MGMT_CMD_UNSUPPORTED) {
1506                 hwdev->func_to_func->support_vf_random = false;
1507                 err = 0;
1508                 dev_warn(&hwdev->hwif->pdev->dev, "Mgmt is unsupported to set VF%d random id\n",
1509                          vf_in_pf - 1);
1510         } else if (!err) {
1511                 hwdev->func_to_func->support_vf_random = true;
1512         }
1513
1514         return err;
1515 }