drivers/net/ethernet/intel/idpf/idpf_virtchnl.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (C) 2023 Intel Corporation */
   3
   4 #include "idpf.h"
   5
   6 /**
   7  * idpf_recv_event_msg - Receive virtchnl event message
   8  * @vport: virtual port structure
   9  * @ctlq_msg: message to copy from
  10  *
  11  * Receive virtchnl event message
  12  */
  13 static void idpf_recv_event_msg(struct idpf_vport *vport,
  14                                 struct idpf_ctlq_msg *ctlq_msg)
  15 {
  16         struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
  17         struct virtchnl2_event *v2e;
  18         bool link_status;
  19         u32 event;
  20
  21         v2e = (struct virtchnl2_event *)ctlq_msg->ctx.indirect.payload->va;
  22         event = le32_to_cpu(v2e->event);
  23
  24         switch (event) {
  25         case VIRTCHNL2_EVENT_LINK_CHANGE:
  26                 vport->link_speed_mbps = le32_to_cpu(v2e->link_speed);
  27                 link_status = v2e->link_status;
  28
  29                 if (vport->link_up == link_status)
  30                         break;
  31
  32                 vport->link_up = link_status;
  33                 if (np->state == __IDPF_VPORT_UP) {
  34                         if (vport->link_up) {
  35                                 netif_carrier_on(vport->netdev);
  36                                 netif_tx_start_all_queues(vport->netdev);
  37                         } else {
  38                                 netif_tx_stop_all_queues(vport->netdev);
  39                                 netif_carrier_off(vport->netdev);
  40                         }
  41                 }
  42                 break;
  43         default:
  44                 dev_err(&vport->adapter->pdev->dev,
  45                         "Unknown event %d from PF\n", event);
  46                 break;
  47         }
  48 }
  49
  50 /**
  51  * idpf_mb_clean - Reclaim the send mailbox queue entries
  52  * @adapter: Driver specific private structure
  53  *
  54  * Reclaim the send mailbox queue entries to be used to send further messages
  55  *
  56  * Returns 0 on success, negative on failure
  57  */
  58 static int idpf_mb_clean(struct idpf_adapter *adapter)
  59 {
  60         u16 i, num_q_msg = IDPF_DFLT_MBX_Q_LEN;
  61         struct idpf_ctlq_msg **q_msg;
  62         struct idpf_dma_mem *dma_mem;
  63         int err;
  64
  65         q_msg = kcalloc(num_q_msg, sizeof(struct idpf_ctlq_msg *), GFP_ATOMIC);
  66         if (!q_msg)
  67                 return -ENOMEM;
  68
  69         err = idpf_ctlq_clean_sq(adapter->hw.asq, &num_q_msg, q_msg);
  70         if (err)
  71                 goto err_kfree;
  72
  73         for (i = 0; i < num_q_msg; i++) {
  74                 if (!q_msg[i])
  75                         continue;
  76                 dma_mem = q_msg[i]->ctx.indirect.payload;
  77                 if (dma_mem)
  78                         dma_free_coherent(&adapter->pdev->dev, dma_mem->size,
  79                                           dma_mem->va, dma_mem->pa);
  80                 kfree(q_msg[i]);
  81                 kfree(dma_mem);
  82         }
  83
  84 err_kfree:
  85         kfree(q_msg);
  86
  87         return err;
  88 }
  89
  90 /**
  91  * idpf_send_mb_msg - Send message over mailbox
  92  * @adapter: Driver specific private structure
  93  * @op: virtchnl opcode
  94  * @msg_size: size of the payload
  95  * @msg: pointer to buffer holding the payload
  96  *
  97  * Will prepare the control queue message and initiates the send api
  98  *
  99  * Returns 0 on success, negative on failure
 100  */
 101 int idpf_send_mb_msg(struct idpf_adapter *adapter, u32 op,
 102                      u16 msg_size, u8 *msg)
 103 {
 104         struct idpf_ctlq_msg *ctlq_msg;
 105         struct idpf_dma_mem *dma_mem;
 106         int err;
 107
 108         /* If we are here and a reset is detected nothing much can be
 109          * done. This thread should silently abort and expected to
 110          * be corrected with a new run either by user or driver
 111          * flows after reset
 112          */
 113         if (idpf_is_reset_detected(adapter))
 114                 return 0;
 115
 116         err = idpf_mb_clean(adapter);
 117         if (err)
 118                 return err;
 119
 120         ctlq_msg = kzalloc(sizeof(*ctlq_msg), GFP_ATOMIC);
 121         if (!ctlq_msg)
 122                 return -ENOMEM;
 123
 124         dma_mem = kzalloc(sizeof(*dma_mem), GFP_ATOMIC);
 125         if (!dma_mem) {
 126                 err = -ENOMEM;
 127                 goto dma_mem_error;
 128         }
 129
 130         ctlq_msg->opcode = idpf_mbq_opc_send_msg_to_cp;
 131         ctlq_msg->func_id = 0;
 132         ctlq_msg->data_len = msg_size;
 133         ctlq_msg->cookie.mbx.chnl_opcode = op;
 134         ctlq_msg->cookie.mbx.chnl_retval = 0;
 135         dma_mem->size = IDPF_CTLQ_MAX_BUF_LEN;
 136         dma_mem->va = dma_alloc_coherent(&adapter->pdev->dev, dma_mem->size,
 137                                          &dma_mem->pa, GFP_ATOMIC);
 138         if (!dma_mem->va) {
 139                 err = -ENOMEM;
 140                 goto dma_alloc_error;
 141         }
 142         memcpy(dma_mem->va, msg, msg_size);
 143         ctlq_msg->ctx.indirect.payload = dma_mem;
 144
 145         err = idpf_ctlq_send(&adapter->hw, adapter->hw.asq, 1, ctlq_msg);
 146         if (err)
 147                 goto send_error;
 148
 149         return 0;
 150
 151 send_error:
 152         dma_free_coherent(&adapter->pdev->dev, dma_mem->size, dma_mem->va,
 153                           dma_mem->pa);
 154 dma_alloc_error:
 155         kfree(dma_mem);
 156 dma_mem_error:
 157         kfree(ctlq_msg);
 158
 159         return err;
 160 }
 161
 162 /**
 163  * idpf_find_vport - Find vport pointer from control queue message
 164  * @adapter: driver specific private structure
 165  * @vport: address of vport pointer to copy the vport from adapters vport list
 166  * @ctlq_msg: control queue message
 167  *
 168  * Return 0 on success, error value on failure. Also this function does check
 169  * for the opcodes which expect to receive payload and return error value if
 170  * it is not the case.
 171  */
 172 static int idpf_find_vport(struct idpf_adapter *adapter,
 173                            struct idpf_vport **vport,
 174                            struct idpf_ctlq_msg *ctlq_msg)
 175 {
 176         bool no_op = false, vid_found = false;
 177         int i, err = 0;
 178         char *vc_msg;
 179         u32 v_id;
 180
 181         vc_msg = kcalloc(IDPF_CTLQ_MAX_BUF_LEN, sizeof(char), GFP_KERNEL);
 182         if (!vc_msg)
 183                 return -ENOMEM;
 184
 185         if (ctlq_msg->data_len) {
 186                 size_t payload_size = ctlq_msg->ctx.indirect.payload->size;
 187
 188                 if (!payload_size) {
 189                         dev_err(&adapter->pdev->dev, "Failed to receive payload buffer\n");
 190                         kfree(vc_msg);
 191
 192                         return -EINVAL;
 193                 }
 194
 195                 memcpy(vc_msg, ctlq_msg->ctx.indirect.payload->va,
 196                        min_t(size_t, payload_size, IDPF_CTLQ_MAX_BUF_LEN));
 197         }
 198
 199         switch (ctlq_msg->cookie.mbx.chnl_opcode) {
 200         case VIRTCHNL2_OP_VERSION:
 201         case VIRTCHNL2_OP_GET_CAPS:
 202         case VIRTCHNL2_OP_CREATE_VPORT:
 203         case VIRTCHNL2_OP_SET_SRIOV_VFS:
 204         case VIRTCHNL2_OP_ALLOC_VECTORS:
 205         case VIRTCHNL2_OP_DEALLOC_VECTORS:
 206         case VIRTCHNL2_OP_GET_PTYPE_INFO:
 207                 goto free_vc_msg;
 208         case VIRTCHNL2_OP_ENABLE_VPORT:
 209         case VIRTCHNL2_OP_DISABLE_VPORT:
 210         case VIRTCHNL2_OP_DESTROY_VPORT:
 211                 v_id = le32_to_cpu(((struct virtchnl2_vport *)vc_msg)->vport_id);
 212                 break;
 213         case VIRTCHNL2_OP_CONFIG_TX_QUEUES:
 214                 v_id = le32_to_cpu(((struct virtchnl2_config_tx_queues *)vc_msg)->vport_id);
 215                 break;
 216         case VIRTCHNL2_OP_CONFIG_RX_QUEUES:
 217                 v_id = le32_to_cpu(((struct virtchnl2_config_rx_queues *)vc_msg)->vport_id);
 218                 break;
 219         case VIRTCHNL2_OP_ENABLE_QUEUES:
 220         case VIRTCHNL2_OP_DISABLE_QUEUES:
 221         case VIRTCHNL2_OP_DEL_QUEUES:
 222                 v_id = le32_to_cpu(((struct virtchnl2_del_ena_dis_queues *)vc_msg)->vport_id);
 223                 break;
 224         case VIRTCHNL2_OP_ADD_QUEUES:
 225                 v_id = le32_to_cpu(((struct virtchnl2_add_queues *)vc_msg)->vport_id);
 226                 break;
 227         case VIRTCHNL2_OP_MAP_QUEUE_VECTOR:
 228         case VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR:
 229                 v_id = le32_to_cpu(((struct virtchnl2_queue_vector_maps *)vc_msg)->vport_id);
 230                 break;
 231         case VIRTCHNL2_OP_GET_STATS:
 232                 v_id = le32_to_cpu(((struct virtchnl2_vport_stats *)vc_msg)->vport_id);
 233                 break;
 234         case VIRTCHNL2_OP_GET_RSS_LUT:
 235         case VIRTCHNL2_OP_SET_RSS_LUT:
 236                 v_id = le32_to_cpu(((struct virtchnl2_rss_lut *)vc_msg)->vport_id);
 237                 break;
 238         case VIRTCHNL2_OP_GET_RSS_KEY:
 239         case VIRTCHNL2_OP_SET_RSS_KEY:
 240                 v_id = le32_to_cpu(((struct virtchnl2_rss_key *)vc_msg)->vport_id);
 241                 break;
 242         case VIRTCHNL2_OP_EVENT:
 243                 v_id = le32_to_cpu(((struct virtchnl2_event *)vc_msg)->vport_id);
 244                 break;
 245         case VIRTCHNL2_OP_LOOPBACK:
 246                 v_id = le32_to_cpu(((struct virtchnl2_loopback *)vc_msg)->vport_id);
 247                 break;
 248         case VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE:
 249                 v_id = le32_to_cpu(((struct virtchnl2_promisc_info *)vc_msg)->vport_id);
 250                 break;
 251         case VIRTCHNL2_OP_ADD_MAC_ADDR:
 252         case VIRTCHNL2_OP_DEL_MAC_ADDR:
 253                 v_id = le32_to_cpu(((struct virtchnl2_mac_addr_list *)vc_msg)->vport_id);
 254                 break;
 255         default:
 256                 no_op = true;
 257                 break;
 258         }
 259
 260         if (no_op)
 261                 goto free_vc_msg;
 262
 263         for (i = 0; i < idpf_get_max_vports(adapter); i++) {
 264                 if (adapter->vport_ids[i] == v_id) {
 265                         vid_found = true;
 266                         break;
 267                 }
 268         }
 269
 270         if (vid_found)
 271                 *vport = adapter->vports[i];
 272         else
 273                 err = -EINVAL;
 274
 275 free_vc_msg:
 276         kfree(vc_msg);
 277
 278         return err;
 279 }
 280
 281 /**
 282  * idpf_copy_data_to_vc_buf - Copy the virtchnl response data into the buffer.
 283  * @adapter: driver specific private structure
 284  * @vport: virtual port structure
 285  * @ctlq_msg: msg to copy from
 286  * @err_enum: err bit to set on error
 287  *
 288  * Copies the payload from ctlq_msg into virtchnl buffer. Returns 0 on success,
 289  * negative on failure.
 290  */
 291 static int idpf_copy_data_to_vc_buf(struct idpf_adapter *adapter,
 292                                     struct idpf_vport *vport,
 293                                     struct idpf_ctlq_msg *ctlq_msg,
 294                                     enum idpf_vport_vc_state err_enum)
 295 {
 296         if (ctlq_msg->cookie.mbx.chnl_retval) {
 297                 if (vport)
 298                         set_bit(err_enum, vport->vc_state);
 299                 else
 300                         set_bit(err_enum, adapter->vc_state);
 301
 302                 return -EINVAL;
 303         }
 304
 305         if (vport)
 306                 memcpy(vport->vc_msg, ctlq_msg->ctx.indirect.payload->va,
 307                        min_t(int, ctlq_msg->ctx.indirect.payload->size,
 308                              IDPF_CTLQ_MAX_BUF_LEN));
 309         else
 310                 memcpy(adapter->vc_msg, ctlq_msg->ctx.indirect.payload->va,
 311                        min_t(int, ctlq_msg->ctx.indirect.payload->size,
 312                              IDPF_CTLQ_MAX_BUF_LEN));
 313
 314         return 0;
 315 }
 316
 317 /**
 318  * idpf_recv_vchnl_op - helper function with common logic when handling the
 319  * reception of VIRTCHNL OPs.
 320  * @adapter: driver specific private structure
 321  * @vport: virtual port structure
 322  * @ctlq_msg: msg to copy from
 323  * @state: state bit used on timeout check
 324  * @err_state: err bit to set on error
 325  */
 326 static void idpf_recv_vchnl_op(struct idpf_adapter *adapter,
 327                                struct idpf_vport *vport,
 328                                struct idpf_ctlq_msg *ctlq_msg,
 329                                enum idpf_vport_vc_state state,
 330                                enum idpf_vport_vc_state err_state)
 331 {
 332         wait_queue_head_t *vchnl_wq;
 333         int err;
 334
 335         if (vport)
 336                 vchnl_wq = &vport->vchnl_wq;
 337         else
 338                 vchnl_wq = &adapter->vchnl_wq;
 339
 340         err = idpf_copy_data_to_vc_buf(adapter, vport, ctlq_msg, err_state);
 341         if (wq_has_sleeper(vchnl_wq)) {
 342                 if (vport)
 343                         set_bit(state, vport->vc_state);
 344                 else
 345                         set_bit(state, adapter->vc_state);
 346
 347                 wake_up(vchnl_wq);
 348         } else {
 349                 if (!err) {
 350                         dev_warn(&adapter->pdev->dev, "opcode %d received without waiting thread\n",
 351                                  ctlq_msg->cookie.mbx.chnl_opcode);
 352                 } else {
 353                         /* Clear the errors since there is no sleeper to pass
 354                          * them on
 355                          */
 356                         if (vport)
 357                                 clear_bit(err_state, vport->vc_state);
 358                         else
 359                                 clear_bit(err_state, adapter->vc_state);
 360                 }
 361         }
 362 }
 363
 364 /**
 365  * idpf_recv_mb_msg - Receive message over mailbox
 366  * @adapter: Driver specific private structure
 367  * @op: virtchannel operation code
 368  * @msg: Received message holding buffer
 369  * @msg_size: message size
 370  *
 371  * Will receive control queue message and posts the receive buffer. Returns 0
 372  * on success and negative on failure.
 373  */
 374 int idpf_recv_mb_msg(struct idpf_adapter *adapter, u32 op,
 375                      void *msg, int msg_size)
 376 {
 377         struct idpf_vport *vport = NULL;
 378         struct idpf_ctlq_msg ctlq_msg;
 379         struct idpf_dma_mem *dma_mem;
 380         bool work_done = false;
 381         int num_retry = 2000;
 382         u16 num_q_msg;
 383         int err;
 384
 385         while (1) {
 386                 struct idpf_vport_config *vport_config;
 387                 int payload_size = 0;
 388
 389                 /* Try to get one message */
 390                 num_q_msg = 1;
 391                 dma_mem = NULL;
 392                 err = idpf_ctlq_recv(adapter->hw.arq, &num_q_msg, &ctlq_msg);
 393                 /* If no message then decide if we have to retry based on
 394                  * opcode
 395                  */
 396                 if (err || !num_q_msg) {
 397                         /* Increasing num_retry to consider the delayed
 398                          * responses because of large number of VF's mailbox
 399                          * messages. If the mailbox message is received from
 400                          * the other side, we come out of the sleep cycle
 401                          * immediately else we wait for more time.
 402                          */
 403                         if (!op || !num_retry--)
 404                                 break;
 405                         if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags)) {
 406                                 err = -EIO;
 407                                 break;
 408                         }
 409                         msleep(20);
 410                         continue;
 411                 }
 412
 413                 /* If we are here a message is received. Check if we are looking
 414                  * for a specific message based on opcode. If it is different
 415                  * ignore and post buffers
 416                  */
 417                 if (op && ctlq_msg.cookie.mbx.chnl_opcode != op)
 418                         goto post_buffs;
 419
 420                 err = idpf_find_vport(adapter, &vport, &ctlq_msg);
 421                 if (err)
 422                         goto post_buffs;
 423
 424                 if (ctlq_msg.data_len)
 425                         payload_size = ctlq_msg.ctx.indirect.payload->size;
 426
 427                 /* All conditions are met. Either a message requested is
 428                  * received or we received a message to be processed
 429                  */
 430                 switch (ctlq_msg.cookie.mbx.chnl_opcode) {
 431                 case VIRTCHNL2_OP_VERSION:
 432                 case VIRTCHNL2_OP_GET_CAPS:
 433                         if (ctlq_msg.cookie.mbx.chnl_retval) {
 434                                 dev_err(&adapter->pdev->dev, "Failure initializing, vc op: %u retval: %u\n",
 435                                         ctlq_msg.cookie.mbx.chnl_opcode,
 436                                         ctlq_msg.cookie.mbx.chnl_retval);
 437                                 err = -EBADMSG;
 438                         } else if (msg) {
 439                                 memcpy(msg, ctlq_msg.ctx.indirect.payload->va,
 440                                        min_t(int, payload_size, msg_size));
 441                         }
 442                         work_done = true;
 443                         break;
 444                 case VIRTCHNL2_OP_CREATE_VPORT:
 445                         idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 446                                            IDPF_VC_CREATE_VPORT,
 447                                            IDPF_VC_CREATE_VPORT_ERR);
 448                         break;
 449                 case VIRTCHNL2_OP_ENABLE_VPORT:
 450                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 451                                            IDPF_VC_ENA_VPORT,
 452                                            IDPF_VC_ENA_VPORT_ERR);
 453                         break;
 454                 case VIRTCHNL2_OP_DISABLE_VPORT:
 455                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 456                                            IDPF_VC_DIS_VPORT,
 457                                            IDPF_VC_DIS_VPORT_ERR);
 458                         break;
 459                 case VIRTCHNL2_OP_DESTROY_VPORT:
 460                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 461                                            IDPF_VC_DESTROY_VPORT,
 462                                            IDPF_VC_DESTROY_VPORT_ERR);
 463                         break;
 464                 case VIRTCHNL2_OP_CONFIG_TX_QUEUES:
 465                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 466                                            IDPF_VC_CONFIG_TXQ,
 467                                            IDPF_VC_CONFIG_TXQ_ERR);
 468                         break;
 469                 case VIRTCHNL2_OP_CONFIG_RX_QUEUES:
 470                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 471                                            IDPF_VC_CONFIG_RXQ,
 472                                            IDPF_VC_CONFIG_RXQ_ERR);
 473                         break;
 474                 case VIRTCHNL2_OP_ENABLE_QUEUES:
 475                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 476                                            IDPF_VC_ENA_QUEUES,
 477                                            IDPF_VC_ENA_QUEUES_ERR);
 478                         break;
 479                 case VIRTCHNL2_OP_DISABLE_QUEUES:
 480                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 481                                            IDPF_VC_DIS_QUEUES,
 482                                            IDPF_VC_DIS_QUEUES_ERR);
 483                         break;
 484                 case VIRTCHNL2_OP_ADD_QUEUES:
 485                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 486                                            IDPF_VC_ADD_QUEUES,
 487                                            IDPF_VC_ADD_QUEUES_ERR);
 488                         break;
 489                 case VIRTCHNL2_OP_DEL_QUEUES:
 490                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 491                                            IDPF_VC_DEL_QUEUES,
 492                                            IDPF_VC_DEL_QUEUES_ERR);
 493                         break;
 494                 case VIRTCHNL2_OP_MAP_QUEUE_VECTOR:
 495                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 496                                            IDPF_VC_MAP_IRQ,
 497                                            IDPF_VC_MAP_IRQ_ERR);
 498                         break;
 499                 case VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR:
 500                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 501                                            IDPF_VC_UNMAP_IRQ,
 502                                            IDPF_VC_UNMAP_IRQ_ERR);
 503                         break;
 504                 case VIRTCHNL2_OP_GET_STATS:
 505                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 506                                            IDPF_VC_GET_STATS,
 507                                            IDPF_VC_GET_STATS_ERR);
 508                         break;
 509                 case VIRTCHNL2_OP_GET_RSS_LUT:
 510                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 511                                            IDPF_VC_GET_RSS_LUT,
 512                                            IDPF_VC_GET_RSS_LUT_ERR);
 513                         break;
 514                 case VIRTCHNL2_OP_SET_RSS_LUT:
 515                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 516                                            IDPF_VC_SET_RSS_LUT,
 517                                            IDPF_VC_SET_RSS_LUT_ERR);
 518                         break;
 519                 case VIRTCHNL2_OP_GET_RSS_KEY:
 520                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 521                                            IDPF_VC_GET_RSS_KEY,
 522                                            IDPF_VC_GET_RSS_KEY_ERR);
 523                         break;
 524                 case VIRTCHNL2_OP_SET_RSS_KEY:
 525                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 526                                            IDPF_VC_SET_RSS_KEY,
 527                                            IDPF_VC_SET_RSS_KEY_ERR);
 528                         break;
 529                 case VIRTCHNL2_OP_SET_SRIOV_VFS:
 530                         idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 531                                            IDPF_VC_SET_SRIOV_VFS,
 532                                            IDPF_VC_SET_SRIOV_VFS_ERR);
 533                         break;
 534                 case VIRTCHNL2_OP_ALLOC_VECTORS:
 535                         idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 536                                            IDPF_VC_ALLOC_VECTORS,
 537                                            IDPF_VC_ALLOC_VECTORS_ERR);
 538                         break;
 539                 case VIRTCHNL2_OP_DEALLOC_VECTORS:
 540                         idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 541                                            IDPF_VC_DEALLOC_VECTORS,
 542                                            IDPF_VC_DEALLOC_VECTORS_ERR);
 543                         break;
 544                 case VIRTCHNL2_OP_GET_PTYPE_INFO:
 545                         idpf_recv_vchnl_op(adapter, NULL, &ctlq_msg,
 546                                            IDPF_VC_GET_PTYPE_INFO,
 547                                            IDPF_VC_GET_PTYPE_INFO_ERR);
 548                         break;
 549                 case VIRTCHNL2_OP_LOOPBACK:
 550                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 551                                            IDPF_VC_LOOPBACK_STATE,
 552                                            IDPF_VC_LOOPBACK_STATE_ERR);
 553                         break;
 554                 case VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE:
 555                         /* This message can only be sent asynchronously. As
 556                          * such we'll have lost the context in which it was
 557                          * called and thus can only really report if it looks
 558                          * like an error occurred. Don't bother setting ERR bit
 559                          * or waking chnl_wq since no work queue will be waiting
 560                          * to read the message.
 561                          */
 562                         if (ctlq_msg.cookie.mbx.chnl_retval) {
 563                                 dev_err(&adapter->pdev->dev, "Failed to set promiscuous mode: %d\n",
 564                                         ctlq_msg.cookie.mbx.chnl_retval);
 565                         }
 566                         break;
 567                 case VIRTCHNL2_OP_ADD_MAC_ADDR:
 568                         vport_config = adapter->vport_config[vport->idx];
 569                         if (test_and_clear_bit(IDPF_VPORT_ADD_MAC_REQ,
 570                                                vport_config->flags)) {
 571                                 /* Message was sent asynchronously. We don't
 572                                  * normally print errors here, instead
 573                                  * prefer to handle errors in the function
 574                                  * calling wait_for_event. However, if
 575                                  * asynchronous, the context in which the
 576                                  * message was sent is lost. We can't really do
 577                                  * anything about at it this point, but we
 578                                  * should at a minimum indicate that it looks
 579                                  * like something went wrong. Also don't bother
 580                                  * setting ERR bit or waking vchnl_wq since no
 581                                  * one will be waiting to read the async
 582                                  * message.
 583                                  */
 584                                 if (ctlq_msg.cookie.mbx.chnl_retval)
 585                                         dev_err(&adapter->pdev->dev, "Failed to add MAC address: %d\n",
 586                                                 ctlq_msg.cookie.mbx.chnl_retval);
 587                                 break;
 588                         }
 589                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 590                                            IDPF_VC_ADD_MAC_ADDR,
 591                                            IDPF_VC_ADD_MAC_ADDR_ERR);
 592                         break;
 593                 case VIRTCHNL2_OP_DEL_MAC_ADDR:
 594                         vport_config = adapter->vport_config[vport->idx];
 595                         if (test_and_clear_bit(IDPF_VPORT_DEL_MAC_REQ,
 596                                                vport_config->flags)) {
 597                                 /* Message was sent asynchronously like the
 598                                  * VIRTCHNL2_OP_ADD_MAC_ADDR
 599                                  */
 600                                 if (ctlq_msg.cookie.mbx.chnl_retval)
 601                                         dev_err(&adapter->pdev->dev, "Failed to delete MAC address: %d\n",
 602                                                 ctlq_msg.cookie.mbx.chnl_retval);
 603                                 break;
 604                         }
 605                         idpf_recv_vchnl_op(adapter, vport, &ctlq_msg,
 606                                            IDPF_VC_DEL_MAC_ADDR,
 607                                            IDPF_VC_DEL_MAC_ADDR_ERR);
 608                         break;
 609                 case VIRTCHNL2_OP_EVENT:
 610                         idpf_recv_event_msg(vport, &ctlq_msg);
 611                         break;
 612                 default:
 613                         dev_warn(&adapter->pdev->dev,
 614                                  "Unhandled virtchnl response %d\n",
 615                                  ctlq_msg.cookie.mbx.chnl_opcode);
 616                         break;
 617                 }
 618
 619 post_buffs:
 620                 if (ctlq_msg.data_len)
 621                         dma_mem = ctlq_msg.ctx.indirect.payload;
 622                 else
 623                         num_q_msg = 0;
 624
 625                 err = idpf_ctlq_post_rx_buffs(&adapter->hw, adapter->hw.arq,
 626                                               &num_q_msg, &dma_mem);
 627                 /* If post failed clear the only buffer we supplied */
 628                 if (err && dma_mem)
 629                         dma_free_coherent(&adapter->pdev->dev, dma_mem->size,
 630                                           dma_mem->va, dma_mem->pa);
 631
 632                 /* Applies only if we are looking for a specific opcode */
 633                 if (work_done)
 634                         break;
 635         }
 636
 637         return err;
 638 }
 639
 640 /**
 641  * __idpf_wait_for_event - wrapper function for wait on virtchannel response
 642  * @adapter: Driver private data structure
 643  * @vport: virtual port structure
 644  * @state: check on state upon timeout
 645  * @err_check: check if this specific error bit is set
 646  * @timeout: Max time to wait
 647  *
 648  * Checks if state is set upon expiry of timeout.  Returns 0 on success,
 649  * negative on failure.
 650  */
 651 static int __idpf_wait_for_event(struct idpf_adapter *adapter,
 652                                  struct idpf_vport *vport,
 653                                  enum idpf_vport_vc_state state,
 654                                  enum idpf_vport_vc_state err_check,
 655                                  int timeout)
 656 {
 657         int time_to_wait, num_waits;
 658         wait_queue_head_t *vchnl_wq;
 659         unsigned long *vc_state;
 660
 661         time_to_wait = ((timeout <= IDPF_MAX_WAIT) ? timeout : IDPF_MAX_WAIT);
 662         num_waits = ((timeout <= IDPF_MAX_WAIT) ? 1 : timeout / IDPF_MAX_WAIT);
 663
 664         if (vport) {
 665                 vchnl_wq = &vport->vchnl_wq;
 666                 vc_state = vport->vc_state;
 667         } else {
 668                 vchnl_wq = &adapter->vchnl_wq;
 669                 vc_state = adapter->vc_state;
 670         }
 671
 672         while (num_waits) {
 673                 int event;
 674
 675                 /* If we are here and a reset is detected do not wait but
 676                  * return. Reset timing is out of drivers control. So
 677                  * while we are cleaning resources as part of reset if the
 678                  * underlying HW mailbox is gone, wait on mailbox messages
 679                  * is not meaningful
 680                  */
 681                 if (idpf_is_reset_detected(adapter))
 682                         return 0;
 683
 684                 event = wait_event_timeout(*vchnl_wq,
 685                                            test_and_clear_bit(state, vc_state),
 686                                            msecs_to_jiffies(time_to_wait));
 687                 if (event) {
 688                         if (test_and_clear_bit(err_check, vc_state)) {
 689                                 dev_err(&adapter->pdev->dev, "VC response error %s\n",
 690                                         idpf_vport_vc_state_str[err_check]);
 691
 692                                 return -EINVAL;
 693                         }
 694
 695                         return 0;
 696                 }
 697                 num_waits--;
 698         }
 699
 700         /* Timeout occurred */
 701         dev_err(&adapter->pdev->dev, "VC timeout, state = %s\n",
 702                 idpf_vport_vc_state_str[state]);
 703
 704         return -ETIMEDOUT;
 705 }
 706
 707 /**
 708  * idpf_min_wait_for_event - wait for virtchannel response
 709  * @adapter: Driver private data structure
 710  * @vport: virtual port structure
 711  * @state: check on state upon timeout
 712  * @err_check: check if this specific error bit is set
 713  *
 714  * Returns 0 on success, negative on failure.
 715  */
 716 static int idpf_min_wait_for_event(struct idpf_adapter *adapter,
 717                                    struct idpf_vport *vport,
 718                                    enum idpf_vport_vc_state state,
 719                                    enum idpf_vport_vc_state err_check)
 720 {
 721         return __idpf_wait_for_event(adapter, vport, state, err_check,
 722                                      IDPF_WAIT_FOR_EVENT_TIMEO_MIN);
 723 }
 724
 725 /**
 726  * idpf_wait_for_event - wait for virtchannel response
 727  * @adapter: Driver private data structure
 728  * @vport: virtual port structure
 729  * @state: check on state upon timeout after 500ms
 730  * @err_check: check if this specific error bit is set
 731  *
 732  * Returns 0 on success, negative on failure.
 733  */
 734 static int idpf_wait_for_event(struct idpf_adapter *adapter,
 735                                struct idpf_vport *vport,
 736                                enum idpf_vport_vc_state state,
 737                                enum idpf_vport_vc_state err_check)
 738 {
 739         /* Increasing the timeout in __IDPF_INIT_SW flow to consider large
 740          * number of VF's mailbox message responses. When a message is received
 741          * on mailbox, this thread is woken up by the idpf_recv_mb_msg before
 742          * the timeout expires. Only in the error case i.e. if no message is
 743          * received on mailbox, we wait for the complete timeout which is
 744          * less likely to happen.
 745          */
 746         return __idpf_wait_for_event(adapter, vport, state, err_check,
 747                                      IDPF_WAIT_FOR_EVENT_TIMEO);
 748 }
 749
 750 /**
 751  * idpf_wait_for_marker_event - wait for software marker response
 752  * @vport: virtual port data structure
 753  *
 754  * Returns 0 success, negative on failure.
 755  **/
 756 static int idpf_wait_for_marker_event(struct idpf_vport *vport)
 757 {
 758         int event;
 759         int i;
 760
 761         for (i = 0; i < vport->num_txq; i++)
 762                 set_bit(__IDPF_Q_SW_MARKER, vport->txqs[i]->flags);
 763
 764         event = wait_event_timeout(vport->sw_marker_wq,
 765                                    test_and_clear_bit(IDPF_VPORT_SW_MARKER,
 766                                                       vport->flags),
 767                                    msecs_to_jiffies(500));
 768
 769         for (i = 0; i < vport->num_txq; i++)
 770                 clear_bit(__IDPF_Q_POLL_MODE, vport->txqs[i]->flags);
 771
 772         if (event)
 773                 return 0;
 774
 775         dev_warn(&vport->adapter->pdev->dev, "Failed to receive marker packets\n");
 776
 777         return -ETIMEDOUT;
 778 }
 779
 780 /**
 781  * idpf_send_ver_msg - send virtchnl version message
 782  * @adapter: Driver specific private structure
 783  *
 784  * Send virtchnl version message.  Returns 0 on success, negative on failure.
 785  */
 786 static int idpf_send_ver_msg(struct idpf_adapter *adapter)
 787 {
 788         struct virtchnl2_version_info vvi;
 789
 790         if (adapter->virt_ver_maj) {
 791                 vvi.major = cpu_to_le32(adapter->virt_ver_maj);
 792                 vvi.minor = cpu_to_le32(adapter->virt_ver_min);
 793         } else {
 794                 vvi.major = cpu_to_le32(IDPF_VIRTCHNL_VERSION_MAJOR);
 795                 vvi.minor = cpu_to_le32(IDPF_VIRTCHNL_VERSION_MINOR);
 796         }
 797
 798         return idpf_send_mb_msg(adapter, VIRTCHNL2_OP_VERSION, sizeof(vvi),
 799                                 (u8 *)&vvi);
 800 }
 801
 802 /**
 803  * idpf_recv_ver_msg - Receive virtchnl version message
 804  * @adapter: Driver specific private structure
 805  *
 806  * Receive virtchnl version message. Returns 0 on success, -EAGAIN if we need
 807  * to send version message again, otherwise negative on failure.
 808  */
 809 static int idpf_recv_ver_msg(struct idpf_adapter *adapter)
 810 {
 811         struct virtchnl2_version_info vvi;
 812         u32 major, minor;
 813         int err;
 814
 815         err = idpf_recv_mb_msg(adapter, VIRTCHNL2_OP_VERSION, &vvi,
 816                                sizeof(vvi));
 817         if (err)
 818                 return err;
 819
 820         major = le32_to_cpu(vvi.major);
 821         minor = le32_to_cpu(vvi.minor);
 822
 823         if (major > IDPF_VIRTCHNL_VERSION_MAJOR) {
 824                 dev_warn(&adapter->pdev->dev,
 825                          "Virtchnl major version (%d) greater than supported\n",
 826                          major);
 827
 828                 return -EINVAL;
 829         }
 830
 831         if (major == IDPF_VIRTCHNL_VERSION_MAJOR &&
 832             minor > IDPF_VIRTCHNL_VERSION_MINOR)
 833                 dev_warn(&adapter->pdev->dev,
 834                          "Virtchnl minor version (%d) didn't match\n", minor);
 835
 836         /* If we have a mismatch, resend version to update receiver on what
 837          * version we will use.
 838          */
 839         if (!adapter->virt_ver_maj &&
 840             major != IDPF_VIRTCHNL_VERSION_MAJOR &&
 841             minor != IDPF_VIRTCHNL_VERSION_MINOR)
 842                 err = -EAGAIN;
 843
 844         adapter->virt_ver_maj = major;
 845         adapter->virt_ver_min = minor;
 846
 847         return err;
 848 }
 849
 850 /**
 851  * idpf_send_get_caps_msg - Send virtchnl get capabilities message
 852  * @adapter: Driver specific private structure
 853  *
 854  * Send virtchl get capabilities message. Returns 0 on success, negative on
 855  * failure.
 856  */
 857 static int idpf_send_get_caps_msg(struct idpf_adapter *adapter)
 858 {
 859         struct virtchnl2_get_capabilities caps = { };
 860
 861         caps.csum_caps =
 862                 cpu_to_le32(VIRTCHNL2_CAP_TX_CSUM_L3_IPV4       |
 863                             VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_TCP   |
 864                             VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_UDP   |
 865                             VIRTCHNL2_CAP_TX_CSUM_L4_IPV4_SCTP  |
 866                             VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_TCP   |
 867                             VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_UDP   |
 868                             VIRTCHNL2_CAP_TX_CSUM_L4_IPV6_SCTP  |
 869                             VIRTCHNL2_CAP_RX_CSUM_L3_IPV4       |
 870                             VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_TCP   |
 871                             VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_UDP   |
 872                             VIRTCHNL2_CAP_RX_CSUM_L4_IPV4_SCTP  |
 873                             VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_TCP   |
 874                             VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_UDP   |
 875                             VIRTCHNL2_CAP_RX_CSUM_L4_IPV6_SCTP  |
 876                             VIRTCHNL2_CAP_TX_CSUM_L3_SINGLE_TUNNEL |
 877                             VIRTCHNL2_CAP_RX_CSUM_L3_SINGLE_TUNNEL |
 878                             VIRTCHNL2_CAP_TX_CSUM_L4_SINGLE_TUNNEL |
 879                             VIRTCHNL2_CAP_RX_CSUM_L4_SINGLE_TUNNEL |
 880                             VIRTCHNL2_CAP_RX_CSUM_GENERIC);
 881
 882         caps.seg_caps =
 883                 cpu_to_le32(VIRTCHNL2_CAP_SEG_IPV4_TCP          |
 884                             VIRTCHNL2_CAP_SEG_IPV4_UDP          |
 885                             VIRTCHNL2_CAP_SEG_IPV4_SCTP         |
 886                             VIRTCHNL2_CAP_SEG_IPV6_TCP          |
 887                             VIRTCHNL2_CAP_SEG_IPV6_UDP          |
 888                             VIRTCHNL2_CAP_SEG_IPV6_SCTP         |
 889                             VIRTCHNL2_CAP_SEG_TX_SINGLE_TUNNEL);
 890
 891         caps.rss_caps =
 892                 cpu_to_le64(VIRTCHNL2_CAP_RSS_IPV4_TCP          |
 893                             VIRTCHNL2_CAP_RSS_IPV4_UDP          |
 894                             VIRTCHNL2_CAP_RSS_IPV4_SCTP         |
 895                             VIRTCHNL2_CAP_RSS_IPV4_OTHER        |
 896                             VIRTCHNL2_CAP_RSS_IPV6_TCP          |
 897                             VIRTCHNL2_CAP_RSS_IPV6_UDP          |
 898                             VIRTCHNL2_CAP_RSS_IPV6_SCTP         |
 899                             VIRTCHNL2_CAP_RSS_IPV6_OTHER);
 900
 901         caps.hsplit_caps =
 902                 cpu_to_le32(VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V4     |
 903                             VIRTCHNL2_CAP_RX_HSPLIT_AT_L4V6);
 904
 905         caps.rsc_caps =
 906                 cpu_to_le32(VIRTCHNL2_CAP_RSC_IPV4_TCP          |
 907                             VIRTCHNL2_CAP_RSC_IPV6_TCP);
 908
 909         caps.other_caps =
 910                 cpu_to_le64(VIRTCHNL2_CAP_SRIOV                 |
 911                             VIRTCHNL2_CAP_MACFILTER             |
 912                             VIRTCHNL2_CAP_SPLITQ_QSCHED         |
 913                             VIRTCHNL2_CAP_PROMISC               |
 914                             VIRTCHNL2_CAP_LOOPBACK);
 915
 916         return idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_CAPS, sizeof(caps),
 917                                 (u8 *)&caps);
 918 }
 919
 920 /**
 921  * idpf_recv_get_caps_msg - Receive virtchnl get capabilities message
 922  * @adapter: Driver specific private structure
 923  *
 924  * Receive virtchnl get capabilities message. Returns 0 on success, negative on
 925  * failure.
 926  */
 927 static int idpf_recv_get_caps_msg(struct idpf_adapter *adapter)
 928 {
 929         return idpf_recv_mb_msg(adapter, VIRTCHNL2_OP_GET_CAPS, &adapter->caps,
 930                                 sizeof(struct virtchnl2_get_capabilities));
 931 }
 932
 933 /**
 934  * idpf_vport_alloc_max_qs - Allocate max queues for a vport
 935  * @adapter: Driver specific private structure
 936  * @max_q: vport max queue structure
 937  */
 938 int idpf_vport_alloc_max_qs(struct idpf_adapter *adapter,
 939                             struct idpf_vport_max_q *max_q)
 940 {
 941         struct idpf_avail_queue_info *avail_queues = &adapter->avail_queues;
 942         struct virtchnl2_get_capabilities *caps = &adapter->caps;
 943         u16 default_vports = idpf_get_default_vports(adapter);
 944         int max_rx_q, max_tx_q;
 945
 946         mutex_lock(&adapter->queue_lock);
 947
 948         max_rx_q = le16_to_cpu(caps->max_rx_q) / default_vports;
 949         max_tx_q = le16_to_cpu(caps->max_tx_q) / default_vports;
 950         if (adapter->num_alloc_vports < default_vports) {
 951                 max_q->max_rxq = min_t(u16, max_rx_q, IDPF_MAX_Q);
 952                 max_q->max_txq = min_t(u16, max_tx_q, IDPF_MAX_Q);
 953         } else {
 954                 max_q->max_rxq = IDPF_MIN_Q;
 955                 max_q->max_txq = IDPF_MIN_Q;
 956         }
 957         max_q->max_bufq = max_q->max_rxq * IDPF_MAX_BUFQS_PER_RXQ_GRP;
 958         max_q->max_complq = max_q->max_txq;
 959
 960         if (avail_queues->avail_rxq < max_q->max_rxq ||
 961             avail_queues->avail_txq < max_q->max_txq ||
 962             avail_queues->avail_bufq < max_q->max_bufq ||
 963             avail_queues->avail_complq < max_q->max_complq) {
 964                 mutex_unlock(&adapter->queue_lock);
 965
 966                 return -EINVAL;
 967         }
 968
 969         avail_queues->avail_rxq -= max_q->max_rxq;
 970         avail_queues->avail_txq -= max_q->max_txq;
 971         avail_queues->avail_bufq -= max_q->max_bufq;
 972         avail_queues->avail_complq -= max_q->max_complq;
 973
 974         mutex_unlock(&adapter->queue_lock);
 975
 976         return 0;
 977 }
 978
 979 /**
 980  * idpf_vport_dealloc_max_qs - Deallocate max queues of a vport
 981  * @adapter: Driver specific private structure
 982  * @max_q: vport max queue structure
 983  */
 984 void idpf_vport_dealloc_max_qs(struct idpf_adapter *adapter,
 985                                struct idpf_vport_max_q *max_q)
 986 {
 987         struct idpf_avail_queue_info *avail_queues;
 988
 989         mutex_lock(&adapter->queue_lock);
 990         avail_queues = &adapter->avail_queues;
 991
 992         avail_queues->avail_rxq += max_q->max_rxq;
 993         avail_queues->avail_txq += max_q->max_txq;
 994         avail_queues->avail_bufq += max_q->max_bufq;
 995         avail_queues->avail_complq += max_q->max_complq;
 996
 997         mutex_unlock(&adapter->queue_lock);
 998 }
 999
1000 /**
1001  * idpf_init_avail_queues - Initialize available queues on the device
1002  * @adapter: Driver specific private structure
1003  */
1004 static void idpf_init_avail_queues(struct idpf_adapter *adapter)
1005 {
1006         struct idpf_avail_queue_info *avail_queues = &adapter->avail_queues;
1007         struct virtchnl2_get_capabilities *caps = &adapter->caps;
1008
1009         avail_queues->avail_rxq = le16_to_cpu(caps->max_rx_q);
1010         avail_queues->avail_txq = le16_to_cpu(caps->max_tx_q);
1011         avail_queues->avail_bufq = le16_to_cpu(caps->max_rx_bufq);
1012         avail_queues->avail_complq = le16_to_cpu(caps->max_tx_complq);
1013 }
1014
1015 /**
1016  * idpf_get_reg_intr_vecs - Get vector queue register offset
1017  * @vport: virtual port structure
1018  * @reg_vals: Register offsets to store in
1019  *
1020  * Returns number of registers that got populated
1021  */
1022 int idpf_get_reg_intr_vecs(struct idpf_vport *vport,
1023                            struct idpf_vec_regs *reg_vals)
1024 {
1025         struct virtchnl2_vector_chunks *chunks;
1026         struct idpf_vec_regs reg_val;
1027         u16 num_vchunks, num_vec;
1028         int num_regs = 0, i, j;
1029
1030         chunks = &vport->adapter->req_vec_chunks->vchunks;
1031         num_vchunks = le16_to_cpu(chunks->num_vchunks);
1032
1033         for (j = 0; j < num_vchunks; j++) {
1034                 struct virtchnl2_vector_chunk *chunk;
1035                 u32 dynctl_reg_spacing;
1036                 u32 itrn_reg_spacing;
1037
1038                 chunk = &chunks->vchunks[j];
1039                 num_vec = le16_to_cpu(chunk->num_vectors);
1040                 reg_val.dyn_ctl_reg = le32_to_cpu(chunk->dynctl_reg_start);
1041                 reg_val.itrn_reg = le32_to_cpu(chunk->itrn_reg_start);
1042                 reg_val.itrn_index_spacing = le32_to_cpu(chunk->itrn_index_spacing);
1043
1044                 dynctl_reg_spacing = le32_to_cpu(chunk->dynctl_reg_spacing);
1045                 itrn_reg_spacing = le32_to_cpu(chunk->itrn_reg_spacing);
1046
1047                 for (i = 0; i < num_vec; i++) {
1048                         reg_vals[num_regs].dyn_ctl_reg = reg_val.dyn_ctl_reg;
1049                         reg_vals[num_regs].itrn_reg = reg_val.itrn_reg;
1050                         reg_vals[num_regs].itrn_index_spacing =
1051                                                 reg_val.itrn_index_spacing;
1052
1053                         reg_val.dyn_ctl_reg += dynctl_reg_spacing;
1054                         reg_val.itrn_reg += itrn_reg_spacing;
1055                         num_regs++;
1056                 }
1057         }
1058
1059         return num_regs;
1060 }
1061
1062 /**
1063  * idpf_vport_get_q_reg - Get the queue registers for the vport
1064  * @reg_vals: register values needing to be set
1065  * @num_regs: amount we expect to fill
1066  * @q_type: queue model
1067  * @chunks: queue regs received over mailbox
1068  *
1069  * This function parses the queue register offsets from the queue register
1070  * chunk information, with a specific queue type and stores it into the array
1071  * passed as an argument. It returns the actual number of queue registers that
1072  * are filled.
1073  */
1074 static int idpf_vport_get_q_reg(u32 *reg_vals, int num_regs, u32 q_type,
1075                                 struct virtchnl2_queue_reg_chunks *chunks)
1076 {
1077         u16 num_chunks = le16_to_cpu(chunks->num_chunks);
1078         int reg_filled = 0, i;
1079         u32 reg_val;
1080
1081         while (num_chunks--) {
1082                 struct virtchnl2_queue_reg_chunk *chunk;
1083                 u16 num_q;
1084
1085                 chunk = &chunks->chunks[num_chunks];
1086                 if (le32_to_cpu(chunk->type) != q_type)
1087                         continue;
1088
1089                 num_q = le32_to_cpu(chunk->num_queues);
1090                 reg_val = le64_to_cpu(chunk->qtail_reg_start);
1091                 for (i = 0; i < num_q && reg_filled < num_regs ; i++) {
1092                         reg_vals[reg_filled++] = reg_val;
1093                         reg_val += le32_to_cpu(chunk->qtail_reg_spacing);
1094                 }
1095         }
1096
1097         return reg_filled;
1098 }
1099
1100 /**
1101  * __idpf_queue_reg_init - initialize queue registers
1102  * @vport: virtual port structure
1103  * @reg_vals: registers we are initializing
1104  * @num_regs: how many registers there are in total
1105  * @q_type: queue model
1106  *
1107  * Return number of queues that are initialized
1108  */
1109 static int __idpf_queue_reg_init(struct idpf_vport *vport, u32 *reg_vals,
1110                                  int num_regs, u32 q_type)
1111 {
1112         struct idpf_adapter *adapter = vport->adapter;
1113         struct idpf_queue *q;
1114         int i, j, k = 0;
1115
1116         switch (q_type) {
1117         case VIRTCHNL2_QUEUE_TYPE_TX:
1118                 for (i = 0; i < vport->num_txq_grp; i++) {
1119                         struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1120
1121                         for (j = 0; j < tx_qgrp->num_txq && k < num_regs; j++, k++)
1122                                 tx_qgrp->txqs[j]->tail =
1123                                         idpf_get_reg_addr(adapter, reg_vals[k]);
1124                 }
1125                 break;
1126         case VIRTCHNL2_QUEUE_TYPE_RX:
1127                 for (i = 0; i < vport->num_rxq_grp; i++) {
1128                         struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1129                         u16 num_rxq = rx_qgrp->singleq.num_rxq;
1130
1131                         for (j = 0; j < num_rxq && k < num_regs; j++, k++) {
1132                                 q = rx_qgrp->singleq.rxqs[j];
1133                                 q->tail = idpf_get_reg_addr(adapter,
1134                                                             reg_vals[k]);
1135                         }
1136                 }
1137                 break;
1138         case VIRTCHNL2_QUEUE_TYPE_RX_BUFFER:
1139                 for (i = 0; i < vport->num_rxq_grp; i++) {
1140                         struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1141                         u8 num_bufqs = vport->num_bufqs_per_qgrp;
1142
1143                         for (j = 0; j < num_bufqs && k < num_regs; j++, k++) {
1144                                 q = &rx_qgrp->splitq.bufq_sets[j].bufq;
1145                                 q->tail = idpf_get_reg_addr(adapter,
1146                                                             reg_vals[k]);
1147                         }
1148                 }
1149                 break;
1150         default:
1151                 break;
1152         }
1153
1154         return k;
1155 }
1156
1157 /**
1158  * idpf_queue_reg_init - initialize queue registers
1159  * @vport: virtual port structure
1160  *
1161  * Return 0 on success, negative on failure
1162  */
1163 int idpf_queue_reg_init(struct idpf_vport *vport)
1164 {
1165         struct virtchnl2_create_vport *vport_params;
1166         struct virtchnl2_queue_reg_chunks *chunks;
1167         struct idpf_vport_config *vport_config;
1168         u16 vport_idx = vport->idx;
1169         int num_regs, ret = 0;
1170         u32 *reg_vals;
1171
1172         /* We may never deal with more than 256 same type of queues */
1173         reg_vals = kzalloc(sizeof(void *) * IDPF_LARGE_MAX_Q, GFP_KERNEL);
1174         if (!reg_vals)
1175                 return -ENOMEM;
1176
1177         vport_config = vport->adapter->vport_config[vport_idx];
1178         if (vport_config->req_qs_chunks) {
1179                 struct virtchnl2_add_queues *vc_aq =
1180                   (struct virtchnl2_add_queues *)vport_config->req_qs_chunks;
1181                 chunks = &vc_aq->chunks;
1182         } else {
1183                 vport_params = vport->adapter->vport_params_recvd[vport_idx];
1184                 chunks = &vport_params->chunks;
1185         }
1186
1187         /* Initialize Tx queue tail register address */
1188         num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q,
1189                                         VIRTCHNL2_QUEUE_TYPE_TX,
1190                                         chunks);
1191         if (num_regs < vport->num_txq) {
1192                 ret = -EINVAL;
1193                 goto free_reg_vals;
1194         }
1195
1196         num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs,
1197                                          VIRTCHNL2_QUEUE_TYPE_TX);
1198         if (num_regs < vport->num_txq) {
1199                 ret = -EINVAL;
1200                 goto free_reg_vals;
1201         }
1202
1203         /* Initialize Rx/buffer queue tail register address based on Rx queue
1204          * model
1205          */
1206         if (idpf_is_queue_model_split(vport->rxq_model)) {
1207                 num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q,
1208                                                 VIRTCHNL2_QUEUE_TYPE_RX_BUFFER,
1209                                                 chunks);
1210                 if (num_regs < vport->num_bufq) {
1211                         ret = -EINVAL;
1212                         goto free_reg_vals;
1213                 }
1214
1215                 num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs,
1216                                                  VIRTCHNL2_QUEUE_TYPE_RX_BUFFER);
1217                 if (num_regs < vport->num_bufq) {
1218                         ret = -EINVAL;
1219                         goto free_reg_vals;
1220                 }
1221         } else {
1222                 num_regs = idpf_vport_get_q_reg(reg_vals, IDPF_LARGE_MAX_Q,
1223                                                 VIRTCHNL2_QUEUE_TYPE_RX,
1224                                                 chunks);
1225                 if (num_regs < vport->num_rxq) {
1226                         ret = -EINVAL;
1227                         goto free_reg_vals;
1228                 }
1229
1230                 num_regs = __idpf_queue_reg_init(vport, reg_vals, num_regs,
1231                                                  VIRTCHNL2_QUEUE_TYPE_RX);
1232                 if (num_regs < vport->num_rxq) {
1233                         ret = -EINVAL;
1234                         goto free_reg_vals;
1235                 }
1236         }
1237
1238 free_reg_vals:
1239         kfree(reg_vals);
1240
1241         return ret;
1242 }
1243
1244 /**
1245  * idpf_send_create_vport_msg - Send virtchnl create vport message
1246  * @adapter: Driver specific private structure
1247  * @max_q: vport max queue info
1248  *
1249  * send virtchnl creae vport message
1250  *
1251  * Returns 0 on success, negative on failure
1252  */
1253 int idpf_send_create_vport_msg(struct idpf_adapter *adapter,
1254                                struct idpf_vport_max_q *max_q)
1255 {
1256         struct virtchnl2_create_vport *vport_msg;
1257         u16 idx = adapter->next_vport;
1258         int err, buf_size;
1259
1260         buf_size = sizeof(struct virtchnl2_create_vport);
1261         if (!adapter->vport_params_reqd[idx]) {
1262                 adapter->vport_params_reqd[idx] = kzalloc(buf_size,
1263                                                           GFP_KERNEL);
1264                 if (!adapter->vport_params_reqd[idx])
1265                         return -ENOMEM;
1266         }
1267
1268         vport_msg = adapter->vport_params_reqd[idx];
1269         vport_msg->vport_type = cpu_to_le16(VIRTCHNL2_VPORT_TYPE_DEFAULT);
1270         vport_msg->vport_index = cpu_to_le16(idx);
1271
1272         if (adapter->req_tx_splitq)
1273                 vport_msg->txq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SPLIT);
1274         else
1275                 vport_msg->txq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SINGLE);
1276
1277         if (adapter->req_rx_splitq)
1278                 vport_msg->rxq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SPLIT);
1279         else
1280                 vport_msg->rxq_model = cpu_to_le16(VIRTCHNL2_QUEUE_MODEL_SINGLE);
1281
1282         err = idpf_vport_calc_total_qs(adapter, idx, vport_msg, max_q);
1283         if (err) {
1284                 dev_err(&adapter->pdev->dev, "Enough queues are not available");
1285
1286                 return err;
1287         }
1288
1289         mutex_lock(&adapter->vc_buf_lock);
1290
1291         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_CREATE_VPORT, buf_size,
1292                                (u8 *)vport_msg);
1293         if (err)
1294                 goto rel_lock;
1295
1296         err = idpf_wait_for_event(adapter, NULL, IDPF_VC_CREATE_VPORT,
1297                                   IDPF_VC_CREATE_VPORT_ERR);
1298         if (err) {
1299                 dev_err(&adapter->pdev->dev, "Failed to receive create vport message");
1300
1301                 goto rel_lock;
1302         }
1303
1304         if (!adapter->vport_params_recvd[idx]) {
1305                 adapter->vport_params_recvd[idx] = kzalloc(IDPF_CTLQ_MAX_BUF_LEN,
1306                                                            GFP_KERNEL);
1307                 if (!adapter->vport_params_recvd[idx]) {
1308                         err = -ENOMEM;
1309                         goto rel_lock;
1310                 }
1311         }
1312
1313         vport_msg = adapter->vport_params_recvd[idx];
1314         memcpy(vport_msg, adapter->vc_msg, IDPF_CTLQ_MAX_BUF_LEN);
1315
1316 rel_lock:
1317         mutex_unlock(&adapter->vc_buf_lock);
1318
1319         return err;
1320 }
1321
1322 /**
1323  * idpf_check_supported_desc_ids - Verify we have required descriptor support
1324  * @vport: virtual port structure
1325  *
1326  * Return 0 on success, error on failure
1327  */
1328 int idpf_check_supported_desc_ids(struct idpf_vport *vport)
1329 {
1330         struct idpf_adapter *adapter = vport->adapter;
1331         struct virtchnl2_create_vport *vport_msg;
1332         u64 rx_desc_ids, tx_desc_ids;
1333
1334         vport_msg = adapter->vport_params_recvd[vport->idx];
1335
1336         rx_desc_ids = le64_to_cpu(vport_msg->rx_desc_ids);
1337         tx_desc_ids = le64_to_cpu(vport_msg->tx_desc_ids);
1338
1339         if (vport->rxq_model == VIRTCHNL2_QUEUE_MODEL_SPLIT) {
1340                 if (!(rx_desc_ids & VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M)) {
1341                         dev_info(&adapter->pdev->dev, "Minimum RX descriptor support not provided, using the default\n");
1342                         vport_msg->rx_desc_ids = cpu_to_le64(VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M);
1343                 }
1344         } else {
1345                 if (!(rx_desc_ids & VIRTCHNL2_RXDID_2_FLEX_SQ_NIC_M))
1346                         vport->base_rxd = true;
1347         }
1348
1349         if (vport->txq_model != VIRTCHNL2_QUEUE_MODEL_SPLIT)
1350                 return 0;
1351
1352         if ((tx_desc_ids & MIN_SUPPORT_TXDID) != MIN_SUPPORT_TXDID) {
1353                 dev_info(&adapter->pdev->dev, "Minimum TX descriptor support not provided, using the default\n");
1354                 vport_msg->tx_desc_ids = cpu_to_le64(MIN_SUPPORT_TXDID);
1355         }
1356
1357         return 0;
1358 }
1359
1360 /**
1361  * idpf_send_destroy_vport_msg - Send virtchnl destroy vport message
1362  * @vport: virtual port data structure
1363  *
1364  * Send virtchnl destroy vport message.  Returns 0 on success, negative on
1365  * failure.
1366  */
1367 int idpf_send_destroy_vport_msg(struct idpf_vport *vport)
1368 {
1369         struct idpf_adapter *adapter = vport->adapter;
1370         struct virtchnl2_vport v_id;
1371         int err;
1372
1373         v_id.vport_id = cpu_to_le32(vport->vport_id);
1374
1375         mutex_lock(&vport->vc_buf_lock);
1376
1377         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DESTROY_VPORT,
1378                                sizeof(v_id), (u8 *)&v_id);
1379         if (err)
1380                 goto rel_lock;
1381
1382         err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DESTROY_VPORT,
1383                                       IDPF_VC_DESTROY_VPORT_ERR);
1384
1385 rel_lock:
1386         mutex_unlock(&vport->vc_buf_lock);
1387
1388         return err;
1389 }
1390
1391 /**
1392  * idpf_send_enable_vport_msg - Send virtchnl enable vport message
1393  * @vport: virtual port data structure
1394  *
1395  * Send enable vport virtchnl message.  Returns 0 on success, negative on
1396  * failure.
1397  */
1398 int idpf_send_enable_vport_msg(struct idpf_vport *vport)
1399 {
1400         struct idpf_adapter *adapter = vport->adapter;
1401         struct virtchnl2_vport v_id;
1402         int err;
1403
1404         v_id.vport_id = cpu_to_le32(vport->vport_id);
1405
1406         mutex_lock(&vport->vc_buf_lock);
1407
1408         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ENABLE_VPORT,
1409                                sizeof(v_id), (u8 *)&v_id);
1410         if (err)
1411                 goto rel_lock;
1412
1413         err = idpf_wait_for_event(adapter, vport, IDPF_VC_ENA_VPORT,
1414                                   IDPF_VC_ENA_VPORT_ERR);
1415
1416 rel_lock:
1417         mutex_unlock(&vport->vc_buf_lock);
1418
1419         return err;
1420 }
1421
1422 /**
1423  * idpf_send_disable_vport_msg - Send virtchnl disable vport message
1424  * @vport: virtual port data structure
1425  *
1426  * Send disable vport virtchnl message.  Returns 0 on success, negative on
1427  * failure.
1428  */
1429 int idpf_send_disable_vport_msg(struct idpf_vport *vport)
1430 {
1431         struct idpf_adapter *adapter = vport->adapter;
1432         struct virtchnl2_vport v_id;
1433         int err;
1434
1435         v_id.vport_id = cpu_to_le32(vport->vport_id);
1436
1437         mutex_lock(&vport->vc_buf_lock);
1438
1439         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DISABLE_VPORT,
1440                                sizeof(v_id), (u8 *)&v_id);
1441         if (err)
1442                 goto rel_lock;
1443
1444         err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DIS_VPORT,
1445                                       IDPF_VC_DIS_VPORT_ERR);
1446
1447 rel_lock:
1448         mutex_unlock(&vport->vc_buf_lock);
1449
1450         return err;
1451 }
1452
1453 /**
1454  * idpf_send_config_tx_queues_msg - Send virtchnl config tx queues message
1455  * @vport: virtual port data structure
1456  *
1457  * Send config tx queues virtchnl message. Returns 0 on success, negative on
1458  * failure.
1459  */
1460 static int idpf_send_config_tx_queues_msg(struct idpf_vport *vport)
1461 {
1462         struct virtchnl2_config_tx_queues *ctq;
1463         u32 config_sz, chunk_sz, buf_sz;
1464         int totqs, num_msgs, num_chunks;
1465         struct virtchnl2_txq_info *qi;
1466         int err = 0, i, k = 0;
1467
1468         totqs = vport->num_txq + vport->num_complq;
1469         qi = kcalloc(totqs, sizeof(struct virtchnl2_txq_info), GFP_KERNEL);
1470         if (!qi)
1471                 return -ENOMEM;
1472
1473         /* Populate the queue info buffer with all queue context info */
1474         for (i = 0; i < vport->num_txq_grp; i++) {
1475                 struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1476                 int j, sched_mode;
1477
1478                 for (j = 0; j < tx_qgrp->num_txq; j++, k++) {
1479                         qi[k].queue_id =
1480                                 cpu_to_le32(tx_qgrp->txqs[j]->q_id);
1481                         qi[k].model =
1482                                 cpu_to_le16(vport->txq_model);
1483                         qi[k].type =
1484                                 cpu_to_le32(tx_qgrp->txqs[j]->q_type);
1485                         qi[k].ring_len =
1486                                 cpu_to_le16(tx_qgrp->txqs[j]->desc_count);
1487                         qi[k].dma_ring_addr =
1488                                 cpu_to_le64(tx_qgrp->txqs[j]->dma);
1489                         if (idpf_is_queue_model_split(vport->txq_model)) {
1490                                 struct idpf_queue *q = tx_qgrp->txqs[j];
1491
1492                                 qi[k].tx_compl_queue_id =
1493                                         cpu_to_le16(tx_qgrp->complq->q_id);
1494                                 qi[k].relative_queue_id = cpu_to_le16(j);
1495
1496                                 if (test_bit(__IDPF_Q_FLOW_SCH_EN, q->flags))
1497                                         qi[k].sched_mode =
1498                                         cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_FLOW);
1499                                 else
1500                                         qi[k].sched_mode =
1501                                         cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_QUEUE);
1502                         } else {
1503                                 qi[k].sched_mode =
1504                                         cpu_to_le16(VIRTCHNL2_TXQ_SCHED_MODE_QUEUE);
1505                         }
1506                 }
1507
1508                 if (!idpf_is_queue_model_split(vport->txq_model))
1509                         continue;
1510
1511                 qi[k].queue_id = cpu_to_le32(tx_qgrp->complq->q_id);
1512                 qi[k].model = cpu_to_le16(vport->txq_model);
1513                 qi[k].type = cpu_to_le32(tx_qgrp->complq->q_type);
1514                 qi[k].ring_len = cpu_to_le16(tx_qgrp->complq->desc_count);
1515                 qi[k].dma_ring_addr = cpu_to_le64(tx_qgrp->complq->dma);
1516
1517                 if (test_bit(__IDPF_Q_FLOW_SCH_EN, tx_qgrp->complq->flags))
1518                         sched_mode = VIRTCHNL2_TXQ_SCHED_MODE_FLOW;
1519                 else
1520                         sched_mode = VIRTCHNL2_TXQ_SCHED_MODE_QUEUE;
1521                 qi[k].sched_mode = cpu_to_le16(sched_mode);
1522
1523                 k++;
1524         }
1525
1526         /* Make sure accounting agrees */
1527         if (k != totqs) {
1528                 err = -EINVAL;
1529                 goto error;
1530         }
1531
1532         /* Chunk up the queue contexts into multiple messages to avoid
1533          * sending a control queue message buffer that is too large
1534          */
1535         config_sz = sizeof(struct virtchnl2_config_tx_queues);
1536         chunk_sz = sizeof(struct virtchnl2_txq_info);
1537
1538         num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
1539                            totqs);
1540         num_msgs = DIV_ROUND_UP(totqs, num_chunks);
1541
1542         buf_sz = struct_size(ctq, qinfo, num_chunks);
1543         ctq = kzalloc(buf_sz, GFP_KERNEL);
1544         if (!ctq) {
1545                 err = -ENOMEM;
1546                 goto error;
1547         }
1548
1549         mutex_lock(&vport->vc_buf_lock);
1550
1551         for (i = 0, k = 0; i < num_msgs; i++) {
1552                 memset(ctq, 0, buf_sz);
1553                 ctq->vport_id = cpu_to_le32(vport->vport_id);
1554                 ctq->num_qinfo = cpu_to_le16(num_chunks);
1555                 memcpy(ctq->qinfo, &qi[k], chunk_sz * num_chunks);
1556
1557                 err = idpf_send_mb_msg(vport->adapter,
1558                                        VIRTCHNL2_OP_CONFIG_TX_QUEUES,
1559                                        buf_sz, (u8 *)ctq);
1560                 if (err)
1561                         goto mbx_error;
1562
1563                 err = idpf_wait_for_event(vport->adapter, vport,
1564                                           IDPF_VC_CONFIG_TXQ,
1565                                           IDPF_VC_CONFIG_TXQ_ERR);
1566                 if (err)
1567                         goto mbx_error;
1568
1569                 k += num_chunks;
1570                 totqs -= num_chunks;
1571                 num_chunks = min(num_chunks, totqs);
1572                 /* Recalculate buffer size */
1573                 buf_sz = struct_size(ctq, qinfo, num_chunks);
1574         }
1575
1576 mbx_error:
1577         mutex_unlock(&vport->vc_buf_lock);
1578         kfree(ctq);
1579 error:
1580         kfree(qi);
1581
1582         return err;
1583 }
1584
1585 /**
1586  * idpf_send_config_rx_queues_msg - Send virtchnl config rx queues message
1587  * @vport: virtual port data structure
1588  *
1589  * Send config rx queues virtchnl message.  Returns 0 on success, negative on
1590  * failure.
1591  */
1592 static int idpf_send_config_rx_queues_msg(struct idpf_vport *vport)
1593 {
1594         struct virtchnl2_config_rx_queues *crq;
1595         u32 config_sz, chunk_sz, buf_sz;
1596         int totqs, num_msgs, num_chunks;
1597         struct virtchnl2_rxq_info *qi;
1598         int err = 0, i, k = 0;
1599
1600         totqs = vport->num_rxq + vport->num_bufq;
1601         qi = kcalloc(totqs, sizeof(struct virtchnl2_rxq_info), GFP_KERNEL);
1602         if (!qi)
1603                 return -ENOMEM;
1604
1605         /* Populate the queue info buffer with all queue context info */
1606         for (i = 0; i < vport->num_rxq_grp; i++) {
1607                 struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1608                 u16 num_rxq;
1609                 int j;
1610
1611                 if (!idpf_is_queue_model_split(vport->rxq_model))
1612                         goto setup_rxqs;
1613
1614                 for (j = 0; j < vport->num_bufqs_per_qgrp; j++, k++) {
1615                         struct idpf_queue *bufq =
1616                                 &rx_qgrp->splitq.bufq_sets[j].bufq;
1617
1618                         qi[k].queue_id = cpu_to_le32(bufq->q_id);
1619                         qi[k].model = cpu_to_le16(vport->rxq_model);
1620                         qi[k].type = cpu_to_le32(bufq->q_type);
1621                         qi[k].desc_ids = cpu_to_le64(VIRTCHNL2_RXDID_2_FLEX_SPLITQ_M);
1622                         qi[k].ring_len = cpu_to_le16(bufq->desc_count);
1623                         qi[k].dma_ring_addr = cpu_to_le64(bufq->dma);
1624                         qi[k].data_buffer_size = cpu_to_le32(bufq->rx_buf_size);
1625                         qi[k].buffer_notif_stride = bufq->rx_buf_stride;
1626                         qi[k].rx_buffer_low_watermark =
1627                                 cpu_to_le16(bufq->rx_buffer_low_watermark);
1628                         if (idpf_is_feature_ena(vport, NETIF_F_GRO_HW))
1629                                 qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RXQ_RSC);
1630                 }
1631
1632 setup_rxqs:
1633                 if (idpf_is_queue_model_split(vport->rxq_model))
1634                         num_rxq = rx_qgrp->splitq.num_rxq_sets;
1635                 else
1636                         num_rxq = rx_qgrp->singleq.num_rxq;
1637
1638                 for (j = 0; j < num_rxq; j++, k++) {
1639                         struct idpf_queue *rxq;
1640
1641                         if (!idpf_is_queue_model_split(vport->rxq_model)) {
1642                                 rxq = rx_qgrp->singleq.rxqs[j];
1643                                 goto common_qi_fields;
1644                         }
1645                         rxq = &rx_qgrp->splitq.rxq_sets[j]->rxq;
1646                         qi[k].rx_bufq1_id =
1647                           cpu_to_le16(rxq->rxq_grp->splitq.bufq_sets[0].bufq.q_id);
1648                         if (vport->num_bufqs_per_qgrp > IDPF_SINGLE_BUFQ_PER_RXQ_GRP) {
1649                                 qi[k].bufq2_ena = IDPF_BUFQ2_ENA;
1650                                 qi[k].rx_bufq2_id =
1651                                   cpu_to_le16(rxq->rxq_grp->splitq.bufq_sets[1].bufq.q_id);
1652                         }
1653                         qi[k].rx_buffer_low_watermark =
1654                                 cpu_to_le16(rxq->rx_buffer_low_watermark);
1655                         if (idpf_is_feature_ena(vport, NETIF_F_GRO_HW))
1656                                 qi[k].qflags |= cpu_to_le16(VIRTCHNL2_RXQ_RSC);
1657
1658 common_qi_fields:
1659                         if (rxq->rx_hsplit_en) {
1660                                 qi[k].qflags |=
1661                                         cpu_to_le16(VIRTCHNL2_RXQ_HDR_SPLIT);
1662                                 qi[k].hdr_buffer_size =
1663                                         cpu_to_le16(rxq->rx_hbuf_size);
1664                         }
1665                         qi[k].queue_id = cpu_to_le32(rxq->q_id);
1666                         qi[k].model = cpu_to_le16(vport->rxq_model);
1667                         qi[k].type = cpu_to_le32(rxq->q_type);
1668                         qi[k].ring_len = cpu_to_le16(rxq->desc_count);
1669                         qi[k].dma_ring_addr = cpu_to_le64(rxq->dma);
1670                         qi[k].max_pkt_size = cpu_to_le32(rxq->rx_max_pkt_size);
1671                         qi[k].data_buffer_size = cpu_to_le32(rxq->rx_buf_size);
1672                         qi[k].qflags |=
1673                                 cpu_to_le16(VIRTCHNL2_RX_DESC_SIZE_32BYTE);
1674                         qi[k].desc_ids = cpu_to_le64(rxq->rxdids);
1675                 }
1676         }
1677
1678         /* Make sure accounting agrees */
1679         if (k != totqs) {
1680                 err = -EINVAL;
1681                 goto error;
1682         }
1683
1684         /* Chunk up the queue contexts into multiple messages to avoid
1685          * sending a control queue message buffer that is too large
1686          */
1687         config_sz = sizeof(struct virtchnl2_config_rx_queues);
1688         chunk_sz = sizeof(struct virtchnl2_rxq_info);
1689
1690         num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
1691                            totqs);
1692         num_msgs = DIV_ROUND_UP(totqs, num_chunks);
1693
1694         buf_sz = struct_size(crq, qinfo, num_chunks);
1695         crq = kzalloc(buf_sz, GFP_KERNEL);
1696         if (!crq) {
1697                 err = -ENOMEM;
1698                 goto error;
1699         }
1700
1701         mutex_lock(&vport->vc_buf_lock);
1702
1703         for (i = 0, k = 0; i < num_msgs; i++) {
1704                 memset(crq, 0, buf_sz);
1705                 crq->vport_id = cpu_to_le32(vport->vport_id);
1706                 crq->num_qinfo = cpu_to_le16(num_chunks);
1707                 memcpy(crq->qinfo, &qi[k], chunk_sz * num_chunks);
1708
1709                 err = idpf_send_mb_msg(vport->adapter,
1710                                        VIRTCHNL2_OP_CONFIG_RX_QUEUES,
1711                                        buf_sz, (u8 *)crq);
1712                 if (err)
1713                         goto mbx_error;
1714
1715                 err = idpf_wait_for_event(vport->adapter, vport,
1716                                           IDPF_VC_CONFIG_RXQ,
1717                                           IDPF_VC_CONFIG_RXQ_ERR);
1718                 if (err)
1719                         goto mbx_error;
1720
1721                 k += num_chunks;
1722                 totqs -= num_chunks;
1723                 num_chunks = min(num_chunks, totqs);
1724                 /* Recalculate buffer size */
1725                 buf_sz = struct_size(crq, qinfo, num_chunks);
1726         }
1727
1728 mbx_error:
1729         mutex_unlock(&vport->vc_buf_lock);
1730         kfree(crq);
1731 error:
1732         kfree(qi);
1733
1734         return err;
1735 }
1736
1737 /**
1738  * idpf_send_ena_dis_queues_msg - Send virtchnl enable or disable
1739  * queues message
1740  * @vport: virtual port data structure
1741  * @vc_op: virtchnl op code to send
1742  *
1743  * Send enable or disable queues virtchnl message. Returns 0 on success,
1744  * negative on failure.
1745  */
1746 static int idpf_send_ena_dis_queues_msg(struct idpf_vport *vport, u32 vc_op)
1747 {
1748         u32 num_msgs, num_chunks, num_txq, num_rxq, num_q;
1749         struct idpf_adapter *adapter = vport->adapter;
1750         struct virtchnl2_del_ena_dis_queues *eq;
1751         struct virtchnl2_queue_chunks *qcs;
1752         struct virtchnl2_queue_chunk *qc;
1753         u32 config_sz, chunk_sz, buf_sz;
1754         int i, j, k = 0, err = 0;
1755
1756         /* validate virtchnl op */
1757         switch (vc_op) {
1758         case VIRTCHNL2_OP_ENABLE_QUEUES:
1759         case VIRTCHNL2_OP_DISABLE_QUEUES:
1760                 break;
1761         default:
1762                 return -EINVAL;
1763         }
1764
1765         num_txq = vport->num_txq + vport->num_complq;
1766         num_rxq = vport->num_rxq + vport->num_bufq;
1767         num_q = num_txq + num_rxq;
1768         buf_sz = sizeof(struct virtchnl2_queue_chunk) * num_q;
1769         qc = kzalloc(buf_sz, GFP_KERNEL);
1770         if (!qc)
1771                 return -ENOMEM;
1772
1773         for (i = 0; i < vport->num_txq_grp; i++) {
1774                 struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1775
1776                 for (j = 0; j < tx_qgrp->num_txq; j++, k++) {
1777                         qc[k].type = cpu_to_le32(tx_qgrp->txqs[j]->q_type);
1778                         qc[k].start_queue_id = cpu_to_le32(tx_qgrp->txqs[j]->q_id);
1779                         qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1780                 }
1781         }
1782         if (vport->num_txq != k) {
1783                 err = -EINVAL;
1784                 goto error;
1785         }
1786
1787         if (!idpf_is_queue_model_split(vport->txq_model))
1788                 goto setup_rx;
1789
1790         for (i = 0; i < vport->num_txq_grp; i++, k++) {
1791                 struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1792
1793                 qc[k].type = cpu_to_le32(tx_qgrp->complq->q_type);
1794                 qc[k].start_queue_id = cpu_to_le32(tx_qgrp->complq->q_id);
1795                 qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1796         }
1797         if (vport->num_complq != (k - vport->num_txq)) {
1798                 err = -EINVAL;
1799                 goto error;
1800         }
1801
1802 setup_rx:
1803         for (i = 0; i < vport->num_rxq_grp; i++) {
1804                 struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1805
1806                 if (idpf_is_queue_model_split(vport->rxq_model))
1807                         num_rxq = rx_qgrp->splitq.num_rxq_sets;
1808                 else
1809                         num_rxq = rx_qgrp->singleq.num_rxq;
1810
1811                 for (j = 0; j < num_rxq; j++, k++) {
1812                         if (idpf_is_queue_model_split(vport->rxq_model)) {
1813                                 qc[k].start_queue_id =
1814                                 cpu_to_le32(rx_qgrp->splitq.rxq_sets[j]->rxq.q_id);
1815                                 qc[k].type =
1816                                 cpu_to_le32(rx_qgrp->splitq.rxq_sets[j]->rxq.q_type);
1817                         } else {
1818                                 qc[k].start_queue_id =
1819                                 cpu_to_le32(rx_qgrp->singleq.rxqs[j]->q_id);
1820                                 qc[k].type =
1821                                 cpu_to_le32(rx_qgrp->singleq.rxqs[j]->q_type);
1822                         }
1823                         qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1824                 }
1825         }
1826         if (vport->num_rxq != k - (vport->num_txq + vport->num_complq)) {
1827                 err = -EINVAL;
1828                 goto error;
1829         }
1830
1831         if (!idpf_is_queue_model_split(vport->rxq_model))
1832                 goto send_msg;
1833
1834         for (i = 0; i < vport->num_rxq_grp; i++) {
1835                 struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1836
1837                 for (j = 0; j < vport->num_bufqs_per_qgrp; j++, k++) {
1838                         struct idpf_queue *q;
1839
1840                         q = &rx_qgrp->splitq.bufq_sets[j].bufq;
1841                         qc[k].type = cpu_to_le32(q->q_type);
1842                         qc[k].start_queue_id = cpu_to_le32(q->q_id);
1843                         qc[k].num_queues = cpu_to_le32(IDPF_NUMQ_PER_CHUNK);
1844                 }
1845         }
1846         if (vport->num_bufq != k - (vport->num_txq +
1847                                     vport->num_complq +
1848                                     vport->num_rxq)) {
1849                 err = -EINVAL;
1850                 goto error;
1851         }
1852
1853 send_msg:
1854         /* Chunk up the queue info into multiple messages */
1855         config_sz = sizeof(struct virtchnl2_del_ena_dis_queues);
1856         chunk_sz = sizeof(struct virtchnl2_queue_chunk);
1857
1858         num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
1859                            num_q);
1860         num_msgs = DIV_ROUND_UP(num_q, num_chunks);
1861
1862         buf_sz = struct_size(eq, chunks.chunks, num_chunks);
1863         eq = kzalloc(buf_sz, GFP_KERNEL);
1864         if (!eq) {
1865                 err = -ENOMEM;
1866                 goto error;
1867         }
1868
1869         mutex_lock(&vport->vc_buf_lock);
1870
1871         for (i = 0, k = 0; i < num_msgs; i++) {
1872                 memset(eq, 0, buf_sz);
1873                 eq->vport_id = cpu_to_le32(vport->vport_id);
1874                 eq->chunks.num_chunks = cpu_to_le16(num_chunks);
1875                 qcs = &eq->chunks;
1876                 memcpy(qcs->chunks, &qc[k], chunk_sz * num_chunks);
1877
1878                 err = idpf_send_mb_msg(adapter, vc_op, buf_sz, (u8 *)eq);
1879                 if (err)
1880                         goto mbx_error;
1881
1882                 if (vc_op == VIRTCHNL2_OP_ENABLE_QUEUES)
1883                         err = idpf_wait_for_event(adapter, vport,
1884                                                   IDPF_VC_ENA_QUEUES,
1885                                                   IDPF_VC_ENA_QUEUES_ERR);
1886                 else
1887                         err = idpf_min_wait_for_event(adapter, vport,
1888                                                       IDPF_VC_DIS_QUEUES,
1889                                                       IDPF_VC_DIS_QUEUES_ERR);
1890                 if (err)
1891                         goto mbx_error;
1892
1893                 k += num_chunks;
1894                 num_q -= num_chunks;
1895                 num_chunks = min(num_chunks, num_q);
1896                 /* Recalculate buffer size */
1897                 buf_sz = struct_size(eq, chunks.chunks, num_chunks);
1898         }
1899
1900 mbx_error:
1901         mutex_unlock(&vport->vc_buf_lock);
1902         kfree(eq);
1903 error:
1904         kfree(qc);
1905
1906         return err;
1907 }
1908
1909 /**
1910  * idpf_send_map_unmap_queue_vector_msg - Send virtchnl map or unmap queue
1911  * vector message
1912  * @vport: virtual port data structure
1913  * @map: true for map and false for unmap
1914  *
1915  * Send map or unmap queue vector virtchnl message.  Returns 0 on success,
1916  * negative on failure.
1917  */
1918 int idpf_send_map_unmap_queue_vector_msg(struct idpf_vport *vport, bool map)
1919 {
1920         struct idpf_adapter *adapter = vport->adapter;
1921         struct virtchnl2_queue_vector_maps *vqvm;
1922         struct virtchnl2_queue_vector *vqv;
1923         u32 config_sz, chunk_sz, buf_sz;
1924         u32 num_msgs, num_chunks, num_q;
1925         int i, j, k = 0, err = 0;
1926
1927         num_q = vport->num_txq + vport->num_rxq;
1928
1929         buf_sz = sizeof(struct virtchnl2_queue_vector) * num_q;
1930         vqv = kzalloc(buf_sz, GFP_KERNEL);
1931         if (!vqv)
1932                 return -ENOMEM;
1933
1934         for (i = 0; i < vport->num_txq_grp; i++) {
1935                 struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
1936
1937                 for (j = 0; j < tx_qgrp->num_txq; j++, k++) {
1938                         vqv[k].queue_type = cpu_to_le32(tx_qgrp->txqs[j]->q_type);
1939                         vqv[k].queue_id = cpu_to_le32(tx_qgrp->txqs[j]->q_id);
1940
1941                         if (idpf_is_queue_model_split(vport->txq_model)) {
1942                                 vqv[k].vector_id =
1943                                 cpu_to_le16(tx_qgrp->complq->q_vector->v_idx);
1944                                 vqv[k].itr_idx =
1945                                 cpu_to_le32(tx_qgrp->complq->q_vector->tx_itr_idx);
1946                         } else {
1947                                 vqv[k].vector_id =
1948                                 cpu_to_le16(tx_qgrp->txqs[j]->q_vector->v_idx);
1949                                 vqv[k].itr_idx =
1950                                 cpu_to_le32(tx_qgrp->txqs[j]->q_vector->tx_itr_idx);
1951                         }
1952                 }
1953         }
1954
1955         if (vport->num_txq != k) {
1956                 err = -EINVAL;
1957                 goto error;
1958         }
1959
1960         for (i = 0; i < vport->num_rxq_grp; i++) {
1961                 struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
1962                 u16 num_rxq;
1963
1964                 if (idpf_is_queue_model_split(vport->rxq_model))
1965                         num_rxq = rx_qgrp->splitq.num_rxq_sets;
1966                 else
1967                         num_rxq = rx_qgrp->singleq.num_rxq;
1968
1969                 for (j = 0; j < num_rxq; j++, k++) {
1970                         struct idpf_queue *rxq;
1971
1972                         if (idpf_is_queue_model_split(vport->rxq_model))
1973                                 rxq = &rx_qgrp->splitq.rxq_sets[j]->rxq;
1974                         else
1975                                 rxq = rx_qgrp->singleq.rxqs[j];
1976
1977                         vqv[k].queue_type = cpu_to_le32(rxq->q_type);
1978                         vqv[k].queue_id = cpu_to_le32(rxq->q_id);
1979                         vqv[k].vector_id = cpu_to_le16(rxq->q_vector->v_idx);
1980                         vqv[k].itr_idx = cpu_to_le32(rxq->q_vector->rx_itr_idx);
1981                 }
1982         }
1983
1984         if (idpf_is_queue_model_split(vport->txq_model)) {
1985                 if (vport->num_rxq != k - vport->num_complq) {
1986                         err = -EINVAL;
1987                         goto error;
1988                 }
1989         } else {
1990                 if (vport->num_rxq != k - vport->num_txq) {
1991                         err = -EINVAL;
1992                         goto error;
1993                 }
1994         }
1995
1996         /* Chunk up the vector info into multiple messages */
1997         config_sz = sizeof(struct virtchnl2_queue_vector_maps);
1998         chunk_sz = sizeof(struct virtchnl2_queue_vector);
1999
2000         num_chunks = min_t(u32, IDPF_NUM_CHUNKS_PER_MSG(config_sz, chunk_sz),
2001                            num_q);
2002         num_msgs = DIV_ROUND_UP(num_q, num_chunks);
2003
2004         buf_sz = struct_size(vqvm, qv_maps, num_chunks);
2005         vqvm = kzalloc(buf_sz, GFP_KERNEL);
2006         if (!vqvm) {
2007                 err = -ENOMEM;
2008                 goto error;
2009         }
2010
2011         mutex_lock(&vport->vc_buf_lock);
2012
2013         for (i = 0, k = 0; i < num_msgs; i++) {
2014                 memset(vqvm, 0, buf_sz);
2015                 vqvm->vport_id = cpu_to_le32(vport->vport_id);
2016                 vqvm->num_qv_maps = cpu_to_le16(num_chunks);
2017                 memcpy(vqvm->qv_maps, &vqv[k], chunk_sz * num_chunks);
2018
2019                 if (map) {
2020                         err = idpf_send_mb_msg(adapter,
2021                                                VIRTCHNL2_OP_MAP_QUEUE_VECTOR,
2022                                                buf_sz, (u8 *)vqvm);
2023                         if (!err)
2024                                 err = idpf_wait_for_event(adapter, vport,
2025                                                           IDPF_VC_MAP_IRQ,
2026                                                           IDPF_VC_MAP_IRQ_ERR);
2027                 } else {
2028                         err = idpf_send_mb_msg(adapter,
2029                                                VIRTCHNL2_OP_UNMAP_QUEUE_VECTOR,
2030                                                buf_sz, (u8 *)vqvm);
2031                         if (!err)
2032                                 err =
2033                                 idpf_min_wait_for_event(adapter, vport,
2034                                                         IDPF_VC_UNMAP_IRQ,
2035                                                         IDPF_VC_UNMAP_IRQ_ERR);
2036                 }
2037                 if (err)
2038                         goto mbx_error;
2039
2040                 k += num_chunks;
2041                 num_q -= num_chunks;
2042                 num_chunks = min(num_chunks, num_q);
2043                 /* Recalculate buffer size */
2044                 buf_sz = struct_size(vqvm, qv_maps, num_chunks);
2045         }
2046
2047 mbx_error:
2048         mutex_unlock(&vport->vc_buf_lock);
2049         kfree(vqvm);
2050 error:
2051         kfree(vqv);
2052
2053         return err;
2054 }
2055
2056 /**
2057  * idpf_send_enable_queues_msg - send enable queues virtchnl message
2058  * @vport: Virtual port private data structure
2059  *
2060  * Will send enable queues virtchnl message.  Returns 0 on success, negative on
2061  * failure.
2062  */
2063 int idpf_send_enable_queues_msg(struct idpf_vport *vport)
2064 {
2065         return idpf_send_ena_dis_queues_msg(vport, VIRTCHNL2_OP_ENABLE_QUEUES);
2066 }
2067
2068 /**
2069  * idpf_send_disable_queues_msg - send disable queues virtchnl message
2070  * @vport: Virtual port private data structure
2071  *
2072  * Will send disable queues virtchnl message.  Returns 0 on success, negative
2073  * on failure.
2074  */
2075 int idpf_send_disable_queues_msg(struct idpf_vport *vport)
2076 {
2077         int err, i;
2078
2079         err = idpf_send_ena_dis_queues_msg(vport, VIRTCHNL2_OP_DISABLE_QUEUES);
2080         if (err)
2081                 return err;
2082
2083         /* switch to poll mode as interrupts will be disabled after disable
2084          * queues virtchnl message is sent
2085          */
2086         for (i = 0; i < vport->num_txq; i++)
2087                 set_bit(__IDPF_Q_POLL_MODE, vport->txqs[i]->flags);
2088
2089         /* schedule the napi to receive all the marker packets */
2090         local_bh_disable();
2091         for (i = 0; i < vport->num_q_vectors; i++)
2092                 napi_schedule(&vport->q_vectors[i].napi);
2093         local_bh_enable();
2094
2095         return idpf_wait_for_marker_event(vport);
2096 }
2097
2098 /**
2099  * idpf_convert_reg_to_queue_chunks - Copy queue chunk information to the right
2100  * structure
2101  * @dchunks: Destination chunks to store data to
2102  * @schunks: Source chunks to copy data from
2103  * @num_chunks: number of chunks to copy
2104  */
2105 static void idpf_convert_reg_to_queue_chunks(struct virtchnl2_queue_chunk *dchunks,
2106                                              struct virtchnl2_queue_reg_chunk *schunks,
2107                                              u16 num_chunks)
2108 {
2109         u16 i;
2110
2111         for (i = 0; i < num_chunks; i++) {
2112                 dchunks[i].type = schunks[i].type;
2113                 dchunks[i].start_queue_id = schunks[i].start_queue_id;
2114                 dchunks[i].num_queues = schunks[i].num_queues;
2115         }
2116 }
2117
2118 /**
2119  * idpf_send_delete_queues_msg - send delete queues virtchnl message
2120  * @vport: Virtual port private data structure
2121  *
2122  * Will send delete queues virtchnl message. Return 0 on success, negative on
2123  * failure.
2124  */
2125 int idpf_send_delete_queues_msg(struct idpf_vport *vport)
2126 {
2127         struct idpf_adapter *adapter = vport->adapter;
2128         struct virtchnl2_create_vport *vport_params;
2129         struct virtchnl2_queue_reg_chunks *chunks;
2130         struct virtchnl2_del_ena_dis_queues *eq;
2131         struct idpf_vport_config *vport_config;
2132         u16 vport_idx = vport->idx;
2133         int buf_size, err;
2134         u16 num_chunks;
2135
2136         vport_config = adapter->vport_config[vport_idx];
2137         if (vport_config->req_qs_chunks) {
2138                 struct virtchnl2_add_queues *vc_aq =
2139                         (struct virtchnl2_add_queues *)vport_config->req_qs_chunks;
2140                 chunks = &vc_aq->chunks;
2141         } else {
2142                 vport_params = adapter->vport_params_recvd[vport_idx];
2143                 chunks = &vport_params->chunks;
2144         }
2145
2146         num_chunks = le16_to_cpu(chunks->num_chunks);
2147         buf_size = struct_size(eq, chunks.chunks, num_chunks);
2148
2149         eq = kzalloc(buf_size, GFP_KERNEL);
2150         if (!eq)
2151                 return -ENOMEM;
2152
2153         eq->vport_id = cpu_to_le32(vport->vport_id);
2154         eq->chunks.num_chunks = cpu_to_le16(num_chunks);
2155
2156         idpf_convert_reg_to_queue_chunks(eq->chunks.chunks, chunks->chunks,
2157                                          num_chunks);
2158
2159         mutex_lock(&vport->vc_buf_lock);
2160
2161         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DEL_QUEUES,
2162                                buf_size, (u8 *)eq);
2163         if (err)
2164                 goto rel_lock;
2165
2166         err = idpf_min_wait_for_event(adapter, vport, IDPF_VC_DEL_QUEUES,
2167                                       IDPF_VC_DEL_QUEUES_ERR);
2168
2169 rel_lock:
2170         mutex_unlock(&vport->vc_buf_lock);
2171         kfree(eq);
2172
2173         return err;
2174 }
2175
2176 /**
2177  * idpf_send_config_queues_msg - Send config queues virtchnl message
2178  * @vport: Virtual port private data structure
2179  *
2180  * Will send config queues virtchnl message. Returns 0 on success, negative on
2181  * failure.
2182  */
2183 int idpf_send_config_queues_msg(struct idpf_vport *vport)
2184 {
2185         int err;
2186
2187         err = idpf_send_config_tx_queues_msg(vport);
2188         if (err)
2189                 return err;
2190
2191         return idpf_send_config_rx_queues_msg(vport);
2192 }
2193
2194 /**
2195  * idpf_send_add_queues_msg - Send virtchnl add queues message
2196  * @vport: Virtual port private data structure
2197  * @num_tx_q: number of transmit queues
2198  * @num_complq: number of transmit completion queues
2199  * @num_rx_q: number of receive queues
2200  * @num_rx_bufq: number of receive buffer queues
2201  *
2202  * Returns 0 on success, negative on failure. vport _MUST_ be const here as
2203  * we should not change any fields within vport itself in this function.
2204  */
2205 int idpf_send_add_queues_msg(const struct idpf_vport *vport, u16 num_tx_q,
2206                              u16 num_complq, u16 num_rx_q, u16 num_rx_bufq)
2207 {
2208         struct idpf_adapter *adapter = vport->adapter;
2209         struct idpf_vport_config *vport_config;
2210         struct virtchnl2_add_queues aq = { };
2211         struct virtchnl2_add_queues *vc_msg;
2212         u16 vport_idx = vport->idx;
2213         int size, err;
2214
2215         vport_config = adapter->vport_config[vport_idx];
2216
2217         aq.vport_id = cpu_to_le32(vport->vport_id);
2218         aq.num_tx_q = cpu_to_le16(num_tx_q);
2219         aq.num_tx_complq = cpu_to_le16(num_complq);
2220         aq.num_rx_q = cpu_to_le16(num_rx_q);
2221         aq.num_rx_bufq = cpu_to_le16(num_rx_bufq);
2222
2223         mutex_lock(&((struct idpf_vport *)vport)->vc_buf_lock);
2224
2225         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ADD_QUEUES,
2226                                sizeof(struct virtchnl2_add_queues), (u8 *)&aq);
2227         if (err)
2228                 goto rel_lock;
2229
2230         /* We want vport to be const to prevent incidental code changes making
2231          * changes to the vport config. We're making a special exception here
2232          * to discard const to use the virtchnl.
2233          */
2234         err = idpf_wait_for_event(adapter, (struct idpf_vport *)vport,
2235                                   IDPF_VC_ADD_QUEUES, IDPF_VC_ADD_QUEUES_ERR);
2236         if (err)
2237                 goto rel_lock;
2238
2239         kfree(vport_config->req_qs_chunks);
2240         vport_config->req_qs_chunks = NULL;
2241
2242         vc_msg = (struct virtchnl2_add_queues *)vport->vc_msg;
2243         /* compare vc_msg num queues with vport num queues */
2244         if (le16_to_cpu(vc_msg->num_tx_q) != num_tx_q ||
2245             le16_to_cpu(vc_msg->num_rx_q) != num_rx_q ||
2246             le16_to_cpu(vc_msg->num_tx_complq) != num_complq ||
2247             le16_to_cpu(vc_msg->num_rx_bufq) != num_rx_bufq) {
2248                 err = -EINVAL;
2249                 goto rel_lock;
2250         }
2251
2252         size = struct_size(vc_msg, chunks.chunks,
2253                            le16_to_cpu(vc_msg->chunks.num_chunks));
2254         vport_config->req_qs_chunks = kmemdup(vc_msg, size, GFP_KERNEL);
2255         if (!vport_config->req_qs_chunks) {
2256                 err = -ENOMEM;
2257                 goto rel_lock;
2258         }
2259
2260 rel_lock:
2261         mutex_unlock(&((struct idpf_vport *)vport)->vc_buf_lock);
2262
2263         return err;
2264 }
2265
2266 /**
2267  * idpf_send_alloc_vectors_msg - Send virtchnl alloc vectors message
2268  * @adapter: Driver specific private structure
2269  * @num_vectors: number of vectors to be allocated
2270  *
2271  * Returns 0 on success, negative on failure.
2272  */
2273 int idpf_send_alloc_vectors_msg(struct idpf_adapter *adapter, u16 num_vectors)
2274 {
2275         struct virtchnl2_alloc_vectors *alloc_vec, *rcvd_vec;
2276         struct virtchnl2_alloc_vectors ac = { };
2277         u16 num_vchunks;
2278         int size, err;
2279
2280         ac.num_vectors = cpu_to_le16(num_vectors);
2281
2282         mutex_lock(&adapter->vc_buf_lock);
2283
2284         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_ALLOC_VECTORS,
2285                                sizeof(ac), (u8 *)&ac);
2286         if (err)
2287                 goto rel_lock;
2288
2289         err = idpf_wait_for_event(adapter, NULL, IDPF_VC_ALLOC_VECTORS,
2290                                   IDPF_VC_ALLOC_VECTORS_ERR);
2291         if (err)
2292                 goto rel_lock;
2293
2294         rcvd_vec = (struct virtchnl2_alloc_vectors *)adapter->vc_msg;
2295         num_vchunks = le16_to_cpu(rcvd_vec->vchunks.num_vchunks);
2296
2297         size = struct_size(rcvd_vec, vchunks.vchunks, num_vchunks);
2298         if (size > sizeof(adapter->vc_msg)) {
2299                 err = -EINVAL;
2300                 goto rel_lock;
2301         }
2302
2303         kfree(adapter->req_vec_chunks);
2304         adapter->req_vec_chunks = NULL;
2305         adapter->req_vec_chunks = kmemdup(adapter->vc_msg, size, GFP_KERNEL);
2306         if (!adapter->req_vec_chunks) {
2307                 err = -ENOMEM;
2308                 goto rel_lock;
2309         }
2310
2311         alloc_vec = adapter->req_vec_chunks;
2312         if (le16_to_cpu(alloc_vec->num_vectors) < num_vectors) {
2313                 kfree(adapter->req_vec_chunks);
2314                 adapter->req_vec_chunks = NULL;
2315                 err = -EINVAL;
2316         }
2317
2318 rel_lock:
2319         mutex_unlock(&adapter->vc_buf_lock);
2320
2321         return err;
2322 }
2323
2324 /**
2325  * idpf_send_dealloc_vectors_msg - Send virtchnl de allocate vectors message
2326  * @adapter: Driver specific private structure
2327  *
2328  * Returns 0 on success, negative on failure.
2329  */
2330 int idpf_send_dealloc_vectors_msg(struct idpf_adapter *adapter)
2331 {
2332         struct virtchnl2_alloc_vectors *ac = adapter->req_vec_chunks;
2333         struct virtchnl2_vector_chunks *vcs = &ac->vchunks;
2334         int buf_size, err;
2335
2336         buf_size = struct_size(vcs, vchunks, le16_to_cpu(vcs->num_vchunks));
2337
2338         mutex_lock(&adapter->vc_buf_lock);
2339
2340         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_DEALLOC_VECTORS, buf_size,
2341                                (u8 *)vcs);
2342         if (err)
2343                 goto rel_lock;
2344
2345         err = idpf_min_wait_for_event(adapter, NULL, IDPF_VC_DEALLOC_VECTORS,
2346                                       IDPF_VC_DEALLOC_VECTORS_ERR);
2347         if (err)
2348                 goto rel_lock;
2349
2350         kfree(adapter->req_vec_chunks);
2351         adapter->req_vec_chunks = NULL;
2352
2353 rel_lock:
2354         mutex_unlock(&adapter->vc_buf_lock);
2355
2356         return err;
2357 }
2358
2359 /**
2360  * idpf_get_max_vfs - Get max number of vfs supported
2361  * @adapter: Driver specific private structure
2362  *
2363  * Returns max number of VFs
2364  */
2365 static int idpf_get_max_vfs(struct idpf_adapter *adapter)
2366 {
2367         return le16_to_cpu(adapter->caps.max_sriov_vfs);
2368 }
2369
2370 /**
2371  * idpf_send_set_sriov_vfs_msg - Send virtchnl set sriov vfs message
2372  * @adapter: Driver specific private structure
2373  * @num_vfs: number of virtual functions to be created
2374  *
2375  * Returns 0 on success, negative on failure.
2376  */
2377 int idpf_send_set_sriov_vfs_msg(struct idpf_adapter *adapter, u16 num_vfs)
2378 {
2379         struct virtchnl2_sriov_vfs_info svi = { };
2380         int err;
2381
2382         svi.num_vfs = cpu_to_le16(num_vfs);
2383
2384         mutex_lock(&adapter->vc_buf_lock);
2385
2386         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_SRIOV_VFS,
2387                                sizeof(svi), (u8 *)&svi);
2388         if (err)
2389                 goto rel_lock;
2390
2391         err = idpf_wait_for_event(adapter, NULL, IDPF_VC_SET_SRIOV_VFS,
2392                                   IDPF_VC_SET_SRIOV_VFS_ERR);
2393
2394 rel_lock:
2395         mutex_unlock(&adapter->vc_buf_lock);
2396
2397         return err;
2398 }
2399
2400 /**
2401  * idpf_send_get_stats_msg - Send virtchnl get statistics message
2402  * @vport: vport to get stats for
2403  *
2404  * Returns 0 on success, negative on failure.
2405  */
2406 int idpf_send_get_stats_msg(struct idpf_vport *vport)
2407 {
2408         struct idpf_netdev_priv *np = netdev_priv(vport->netdev);
2409         struct rtnl_link_stats64 *netstats = &np->netstats;
2410         struct idpf_adapter *adapter = vport->adapter;
2411         struct virtchnl2_vport_stats stats_msg = { };
2412         struct virtchnl2_vport_stats *stats;
2413         int err;
2414
2415         /* Don't send get_stats message if the link is down */
2416         if (np->state <= __IDPF_VPORT_DOWN)
2417                 return 0;
2418
2419         stats_msg.vport_id = cpu_to_le32(vport->vport_id);
2420
2421         mutex_lock(&vport->vc_buf_lock);
2422
2423         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_STATS,
2424                                sizeof(struct virtchnl2_vport_stats),
2425                                (u8 *)&stats_msg);
2426         if (err)
2427                 goto rel_lock;
2428
2429         err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_STATS,
2430                                   IDPF_VC_GET_STATS_ERR);
2431         if (err)
2432                 goto rel_lock;
2433
2434         stats = (struct virtchnl2_vport_stats *)vport->vc_msg;
2435
2436         spin_lock_bh(&np->stats_lock);
2437
2438         netstats->rx_packets = le64_to_cpu(stats->rx_unicast) +
2439                                le64_to_cpu(stats->rx_multicast) +
2440                                le64_to_cpu(stats->rx_broadcast);
2441         netstats->rx_bytes = le64_to_cpu(stats->rx_bytes);
2442         netstats->rx_dropped = le64_to_cpu(stats->rx_discards);
2443         netstats->rx_over_errors = le64_to_cpu(stats->rx_overflow_drop);
2444         netstats->rx_length_errors = le64_to_cpu(stats->rx_invalid_frame_length);
2445
2446         netstats->tx_packets = le64_to_cpu(stats->tx_unicast) +
2447                                le64_to_cpu(stats->tx_multicast) +
2448                                le64_to_cpu(stats->tx_broadcast);
2449         netstats->tx_bytes = le64_to_cpu(stats->tx_bytes);
2450         netstats->tx_errors = le64_to_cpu(stats->tx_errors);
2451         netstats->tx_dropped = le64_to_cpu(stats->tx_discards);
2452
2453         vport->port_stats.vport_stats = *stats;
2454
2455         spin_unlock_bh(&np->stats_lock);
2456
2457 rel_lock:
2458         mutex_unlock(&vport->vc_buf_lock);
2459
2460         return err;
2461 }
2462
2463 /**
2464  * idpf_send_get_set_rss_lut_msg - Send virtchnl get or set rss lut message
2465  * @vport: virtual port data structure
2466  * @get: flag to set or get rss look up table
2467  *
2468  * Returns 0 on success, negative on failure.
2469  */
2470 int idpf_send_get_set_rss_lut_msg(struct idpf_vport *vport, bool get)
2471 {
2472         struct idpf_adapter *adapter = vport->adapter;
2473         struct virtchnl2_rss_lut *recv_rl;
2474         struct idpf_rss_data *rss_data;
2475         struct virtchnl2_rss_lut *rl;
2476         int buf_size, lut_buf_size;
2477         int i, err;
2478
2479         rss_data = &adapter->vport_config[vport->idx]->user_config.rss_data;
2480         buf_size = struct_size(rl, lut, rss_data->rss_lut_size);
2481         rl = kzalloc(buf_size, GFP_KERNEL);
2482         if (!rl)
2483                 return -ENOMEM;
2484
2485         rl->vport_id = cpu_to_le32(vport->vport_id);
2486         mutex_lock(&vport->vc_buf_lock);
2487
2488         if (!get) {
2489                 rl->lut_entries = cpu_to_le16(rss_data->rss_lut_size);
2490                 for (i = 0; i < rss_data->rss_lut_size; i++)
2491                         rl->lut[i] = cpu_to_le32(rss_data->rss_lut[i]);
2492
2493                 err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_RSS_LUT,
2494                                        buf_size, (u8 *)rl);
2495                 if (err)
2496                         goto free_mem;
2497
2498                 err = idpf_wait_for_event(adapter, vport, IDPF_VC_SET_RSS_LUT,
2499                                           IDPF_VC_SET_RSS_LUT_ERR);
2500
2501                 goto free_mem;
2502         }
2503
2504         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_RSS_LUT,
2505                                buf_size, (u8 *)rl);
2506         if (err)
2507                 goto free_mem;
2508
2509         err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_RSS_LUT,
2510                                   IDPF_VC_GET_RSS_LUT_ERR);
2511         if (err)
2512                 goto free_mem;
2513
2514         recv_rl = (struct virtchnl2_rss_lut *)vport->vc_msg;
2515         if (rss_data->rss_lut_size == le16_to_cpu(recv_rl->lut_entries))
2516                 goto do_memcpy;
2517
2518         rss_data->rss_lut_size = le16_to_cpu(recv_rl->lut_entries);
2519         kfree(rss_data->rss_lut);
2520
2521         lut_buf_size = rss_data->rss_lut_size * sizeof(u32);
2522         rss_data->rss_lut = kzalloc(lut_buf_size, GFP_KERNEL);
2523         if (!rss_data->rss_lut) {
2524                 rss_data->rss_lut_size = 0;
2525                 err = -ENOMEM;
2526                 goto free_mem;
2527         }
2528
2529 do_memcpy:
2530         memcpy(rss_data->rss_lut, vport->vc_msg, rss_data->rss_lut_size);
2531 free_mem:
2532         mutex_unlock(&vport->vc_buf_lock);
2533         kfree(rl);
2534
2535         return err;
2536 }
2537
2538 /**
2539  * idpf_send_get_set_rss_key_msg - Send virtchnl get or set rss key message
2540  * @vport: virtual port data structure
2541  * @get: flag to set or get rss look up table
2542  *
2543  * Returns 0 on success, negative on failure
2544  */
2545 int idpf_send_get_set_rss_key_msg(struct idpf_vport *vport, bool get)
2546 {
2547         struct idpf_adapter *adapter = vport->adapter;
2548         struct virtchnl2_rss_key *recv_rk;
2549         struct idpf_rss_data *rss_data;
2550         struct virtchnl2_rss_key *rk;
2551         int i, buf_size, err;
2552
2553         rss_data = &adapter->vport_config[vport->idx]->user_config.rss_data;
2554         buf_size = struct_size(rk, key_flex, rss_data->rss_key_size);
2555         rk = kzalloc(buf_size, GFP_KERNEL);
2556         if (!rk)
2557                 return -ENOMEM;
2558
2559         rk->vport_id = cpu_to_le32(vport->vport_id);
2560         mutex_lock(&vport->vc_buf_lock);
2561
2562         if (get) {
2563                 err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_RSS_KEY,
2564                                        buf_size, (u8 *)rk);
2565                 if (err)
2566                         goto error;
2567
2568                 err = idpf_wait_for_event(adapter, vport, IDPF_VC_GET_RSS_KEY,
2569                                           IDPF_VC_GET_RSS_KEY_ERR);
2570                 if (err)
2571                         goto error;
2572
2573                 recv_rk = (struct virtchnl2_rss_key *)vport->vc_msg;
2574                 if (rss_data->rss_key_size !=
2575                     le16_to_cpu(recv_rk->key_len)) {
2576                         rss_data->rss_key_size =
2577                                 min_t(u16, NETDEV_RSS_KEY_LEN,
2578                                       le16_to_cpu(recv_rk->key_len));
2579                         kfree(rss_data->rss_key);
2580                         rss_data->rss_key = kzalloc(rss_data->rss_key_size,
2581                                                     GFP_KERNEL);
2582                         if (!rss_data->rss_key) {
2583                                 rss_data->rss_key_size = 0;
2584                                 err = -ENOMEM;
2585                                 goto error;
2586                         }
2587                 }
2588                 memcpy(rss_data->rss_key, recv_rk->key_flex,
2589                        rss_data->rss_key_size);
2590         } else {
2591                 rk->key_len = cpu_to_le16(rss_data->rss_key_size);
2592                 for (i = 0; i < rss_data->rss_key_size; i++)
2593                         rk->key_flex[i] = rss_data->rss_key[i];
2594
2595                 err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_SET_RSS_KEY,
2596                                        buf_size, (u8 *)rk);
2597                 if (err)
2598                         goto error;
2599
2600                 err = idpf_wait_for_event(adapter, vport, IDPF_VC_SET_RSS_KEY,
2601                                           IDPF_VC_SET_RSS_KEY_ERR);
2602         }
2603
2604 error:
2605         mutex_unlock(&vport->vc_buf_lock);
2606         kfree(rk);
2607
2608         return err;
2609 }
2610
2611 /**
2612  * idpf_fill_ptype_lookup - Fill L3 specific fields in ptype lookup table
2613  * @ptype: ptype lookup table
2614  * @pstate: state machine for ptype lookup table
2615  * @ipv4: ipv4 or ipv6
2616  * @frag: fragmentation allowed
2617  *
2618  */
2619 static void idpf_fill_ptype_lookup(struct idpf_rx_ptype_decoded *ptype,
2620                                    struct idpf_ptype_state *pstate,
2621                                    bool ipv4, bool frag)
2622 {
2623         if (!pstate->outer_ip || !pstate->outer_frag) {
2624                 ptype->outer_ip = IDPF_RX_PTYPE_OUTER_IP;
2625                 pstate->outer_ip = true;
2626
2627                 if (ipv4)
2628                         ptype->outer_ip_ver = IDPF_RX_PTYPE_OUTER_IPV4;
2629                 else
2630                         ptype->outer_ip_ver = IDPF_RX_PTYPE_OUTER_IPV6;
2631
2632                 if (frag) {
2633                         ptype->outer_frag = IDPF_RX_PTYPE_FRAG;
2634                         pstate->outer_frag = true;
2635                 }
2636         } else {
2637                 ptype->tunnel_type = IDPF_RX_PTYPE_TUNNEL_IP_IP;
2638                 pstate->tunnel_state = IDPF_PTYPE_TUNNEL_IP;
2639
2640                 if (ipv4)
2641                         ptype->tunnel_end_prot =
2642                                         IDPF_RX_PTYPE_TUNNEL_END_IPV4;
2643                 else
2644                         ptype->tunnel_end_prot =
2645                                         IDPF_RX_PTYPE_TUNNEL_END_IPV6;
2646
2647                 if (frag)
2648                         ptype->tunnel_end_frag = IDPF_RX_PTYPE_FRAG;
2649         }
2650 }
2651
2652 /**
2653  * idpf_send_get_rx_ptype_msg - Send virtchnl for ptype info
2654  * @vport: virtual port data structure
2655  *
2656  * Returns 0 on success, negative on failure.
2657  */
2658 int idpf_send_get_rx_ptype_msg(struct idpf_vport *vport)
2659 {
2660         struct idpf_rx_ptype_decoded *ptype_lkup = vport->rx_ptype_lkup;
2661         struct virtchnl2_get_ptype_info get_ptype_info;
2662         int max_ptype, ptypes_recvd = 0, ptype_offset;
2663         struct idpf_adapter *adapter = vport->adapter;
2664         struct virtchnl2_get_ptype_info *ptype_info;
2665         u16 next_ptype_id = 0;
2666         int err = 0, i, j, k;
2667
2668         if (idpf_is_queue_model_split(vport->rxq_model))
2669                 max_ptype = IDPF_RX_MAX_PTYPE;
2670         else
2671                 max_ptype = IDPF_RX_MAX_BASE_PTYPE;
2672
2673         memset(vport->rx_ptype_lkup, 0, sizeof(vport->rx_ptype_lkup));
2674
2675         ptype_info = kzalloc(IDPF_CTLQ_MAX_BUF_LEN, GFP_KERNEL);
2676         if (!ptype_info)
2677                 return -ENOMEM;
2678
2679         mutex_lock(&adapter->vc_buf_lock);
2680
2681         while (next_ptype_id < max_ptype) {
2682                 get_ptype_info.start_ptype_id = cpu_to_le16(next_ptype_id);
2683
2684                 if ((next_ptype_id + IDPF_RX_MAX_PTYPES_PER_BUF) > max_ptype)
2685                         get_ptype_info.num_ptypes =
2686                                 cpu_to_le16(max_ptype - next_ptype_id);
2687                 else
2688                         get_ptype_info.num_ptypes =
2689                                 cpu_to_le16(IDPF_RX_MAX_PTYPES_PER_BUF);
2690
2691                 err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_GET_PTYPE_INFO,
2692                                        sizeof(struct virtchnl2_get_ptype_info),
2693                                        (u8 *)&get_ptype_info);
2694                 if (err)
2695                         goto vc_buf_unlock;
2696
2697                 err = idpf_wait_for_event(adapter, NULL, IDPF_VC_GET_PTYPE_INFO,
2698                                           IDPF_VC_GET_PTYPE_INFO_ERR);
2699                 if (err)
2700                         goto vc_buf_unlock;
2701
2702                 memcpy(ptype_info, adapter->vc_msg, IDPF_CTLQ_MAX_BUF_LEN);
2703
2704                 ptypes_recvd += le16_to_cpu(ptype_info->num_ptypes);
2705                 if (ptypes_recvd > max_ptype) {
2706                         err = -EINVAL;
2707                         goto vc_buf_unlock;
2708                 }
2709
2710                 next_ptype_id = le16_to_cpu(get_ptype_info.start_ptype_id) +
2711                                 le16_to_cpu(get_ptype_info.num_ptypes);
2712
2713                 ptype_offset = IDPF_RX_PTYPE_HDR_SZ;
2714
2715                 for (i = 0; i < le16_to_cpu(ptype_info->num_ptypes); i++) {
2716                         struct idpf_ptype_state pstate = { };
2717                         struct virtchnl2_ptype *ptype;
2718                         u16 id;
2719
2720                         ptype = (struct virtchnl2_ptype *)
2721                                         ((u8 *)ptype_info + ptype_offset);
2722
2723                         ptype_offset += IDPF_GET_PTYPE_SIZE(ptype);
2724                         if (ptype_offset > IDPF_CTLQ_MAX_BUF_LEN) {
2725                                 err = -EINVAL;
2726                                 goto vc_buf_unlock;
2727                         }
2728
2729                         /* 0xFFFF indicates end of ptypes */
2730                         if (le16_to_cpu(ptype->ptype_id_10) ==
2731                                                         IDPF_INVALID_PTYPE_ID) {
2732                                 err = 0;
2733                                 goto vc_buf_unlock;
2734                         }
2735
2736                         if (idpf_is_queue_model_split(vport->rxq_model))
2737                                 k = le16_to_cpu(ptype->ptype_id_10);
2738                         else
2739                                 k = ptype->ptype_id_8;
2740
2741                         if (ptype->proto_id_count)
2742                                 ptype_lkup[k].known = 1;
2743
2744                         for (j = 0; j < ptype->proto_id_count; j++) {
2745                                 id = le16_to_cpu(ptype->proto_id[j]);
2746                                 switch (id) {
2747                                 case VIRTCHNL2_PROTO_HDR_GRE:
2748                                         if (pstate.tunnel_state ==
2749                                                         IDPF_PTYPE_TUNNEL_IP) {
2750                                                 ptype_lkup[k].tunnel_type =
2751                                                 IDPF_RX_PTYPE_TUNNEL_IP_GRENAT;
2752                                                 pstate.tunnel_state |=
2753                                                 IDPF_PTYPE_TUNNEL_IP_GRENAT;
2754                                         }
2755                                         break;
2756                                 case VIRTCHNL2_PROTO_HDR_MAC:
2757                                         ptype_lkup[k].outer_ip =
2758                                                 IDPF_RX_PTYPE_OUTER_L2;
2759                                         if (pstate.tunnel_state ==
2760                                                         IDPF_TUN_IP_GRE) {
2761                                                 ptype_lkup[k].tunnel_type =
2762                                                 IDPF_RX_PTYPE_TUNNEL_IP_GRENAT_MAC;
2763                                                 pstate.tunnel_state |=
2764                                                 IDPF_PTYPE_TUNNEL_IP_GRENAT_MAC;
2765                                         }
2766                                         break;
2767                                 case VIRTCHNL2_PROTO_HDR_IPV4:
2768                                         idpf_fill_ptype_lookup(&ptype_lkup[k],
2769                                                                &pstate, true,
2770                                                                false);
2771                                         break;
2772                                 case VIRTCHNL2_PROTO_HDR_IPV6:
2773                                         idpf_fill_ptype_lookup(&ptype_lkup[k],
2774                                                                &pstate, false,
2775                                                                false);
2776                                         break;
2777                                 case VIRTCHNL2_PROTO_HDR_IPV4_FRAG:
2778                                         idpf_fill_ptype_lookup(&ptype_lkup[k],
2779                                                                &pstate, true,
2780                                                                true);
2781                                         break;
2782                                 case VIRTCHNL2_PROTO_HDR_IPV6_FRAG:
2783                                         idpf_fill_ptype_lookup(&ptype_lkup[k],
2784                                                                &pstate, false,
2785                                                                true);
2786                                         break;
2787                                 case VIRTCHNL2_PROTO_HDR_UDP:
2788                                         ptype_lkup[k].inner_prot =
2789                                         IDPF_RX_PTYPE_INNER_PROT_UDP;
2790                                         break;
2791                                 case VIRTCHNL2_PROTO_HDR_TCP:
2792                                         ptype_lkup[k].inner_prot =
2793                                         IDPF_RX_PTYPE_INNER_PROT_TCP;
2794                                         break;
2795                                 case VIRTCHNL2_PROTO_HDR_SCTP:
2796                                         ptype_lkup[k].inner_prot =
2797                                         IDPF_RX_PTYPE_INNER_PROT_SCTP;
2798                                         break;
2799                                 case VIRTCHNL2_PROTO_HDR_ICMP:
2800                                         ptype_lkup[k].inner_prot =
2801                                         IDPF_RX_PTYPE_INNER_PROT_ICMP;
2802                                         break;
2803                                 case VIRTCHNL2_PROTO_HDR_PAY:
2804                                         ptype_lkup[k].payload_layer =
2805                                                 IDPF_RX_PTYPE_PAYLOAD_LAYER_PAY2;
2806                                         break;
2807                                 case VIRTCHNL2_PROTO_HDR_ICMPV6:
2808                                 case VIRTCHNL2_PROTO_HDR_IPV6_EH:
2809                                 case VIRTCHNL2_PROTO_HDR_PRE_MAC:
2810                                 case VIRTCHNL2_PROTO_HDR_POST_MAC:
2811                                 case VIRTCHNL2_PROTO_HDR_ETHERTYPE:
2812                                 case VIRTCHNL2_PROTO_HDR_SVLAN:
2813                                 case VIRTCHNL2_PROTO_HDR_CVLAN:
2814                                 case VIRTCHNL2_PROTO_HDR_MPLS:
2815                                 case VIRTCHNL2_PROTO_HDR_MMPLS:
2816                                 case VIRTCHNL2_PROTO_HDR_PTP:
2817                                 case VIRTCHNL2_PROTO_HDR_CTRL:
2818                                 case VIRTCHNL2_PROTO_HDR_LLDP:
2819                                 case VIRTCHNL2_PROTO_HDR_ARP:
2820                                 case VIRTCHNL2_PROTO_HDR_ECP:
2821                                 case VIRTCHNL2_PROTO_HDR_EAPOL:
2822                                 case VIRTCHNL2_PROTO_HDR_PPPOD:
2823                                 case VIRTCHNL2_PROTO_HDR_PPPOE:
2824                                 case VIRTCHNL2_PROTO_HDR_IGMP:
2825                                 case VIRTCHNL2_PROTO_HDR_AH:
2826                                 case VIRTCHNL2_PROTO_HDR_ESP:
2827                                 case VIRTCHNL2_PROTO_HDR_IKE:
2828                                 case VIRTCHNL2_PROTO_HDR_NATT_KEEP:
2829                                 case VIRTCHNL2_PROTO_HDR_L2TPV2:
2830                                 case VIRTCHNL2_PROTO_HDR_L2TPV2_CONTROL:
2831                                 case VIRTCHNL2_PROTO_HDR_L2TPV3:
2832                                 case VIRTCHNL2_PROTO_HDR_GTP:
2833                                 case VIRTCHNL2_PROTO_HDR_GTP_EH:
2834                                 case VIRTCHNL2_PROTO_HDR_GTPCV2:
2835                                 case VIRTCHNL2_PROTO_HDR_GTPC_TEID:
2836                                 case VIRTCHNL2_PROTO_HDR_GTPU:
2837                                 case VIRTCHNL2_PROTO_HDR_GTPU_UL:
2838                                 case VIRTCHNL2_PROTO_HDR_GTPU_DL:
2839                                 case VIRTCHNL2_PROTO_HDR_ECPRI:
2840                                 case VIRTCHNL2_PROTO_HDR_VRRP:
2841                                 case VIRTCHNL2_PROTO_HDR_OSPF:
2842                                 case VIRTCHNL2_PROTO_HDR_TUN:
2843                                 case VIRTCHNL2_PROTO_HDR_NVGRE:
2844                                 case VIRTCHNL2_PROTO_HDR_VXLAN:
2845                                 case VIRTCHNL2_PROTO_HDR_VXLAN_GPE:
2846                                 case VIRTCHNL2_PROTO_HDR_GENEVE:
2847                                 case VIRTCHNL2_PROTO_HDR_NSH:
2848                                 case VIRTCHNL2_PROTO_HDR_QUIC:
2849                                 case VIRTCHNL2_PROTO_HDR_PFCP:
2850                                 case VIRTCHNL2_PROTO_HDR_PFCP_NODE:
2851                                 case VIRTCHNL2_PROTO_HDR_PFCP_SESSION:
2852                                 case VIRTCHNL2_PROTO_HDR_RTP:
2853                                 case VIRTCHNL2_PROTO_HDR_NO_PROTO:
2854                                         break;
2855                                 default:
2856                                         break;
2857                                 }
2858                         }
2859                 }
2860         }
2861
2862 vc_buf_unlock:
2863         mutex_unlock(&adapter->vc_buf_lock);
2864         kfree(ptype_info);
2865
2866         return err;
2867 }
2868
2869 /**
2870  * idpf_send_ena_dis_loopback_msg - Send virtchnl enable/disable loopback
2871  *                                  message
2872  * @vport: virtual port data structure
2873  *
2874  * Returns 0 on success, negative on failure.
2875  */
2876 int idpf_send_ena_dis_loopback_msg(struct idpf_vport *vport)
2877 {
2878         struct virtchnl2_loopback loopback;
2879         int err;
2880
2881         loopback.vport_id = cpu_to_le32(vport->vport_id);
2882         loopback.enable = idpf_is_feature_ena(vport, NETIF_F_LOOPBACK);
2883
2884         mutex_lock(&vport->vc_buf_lock);
2885
2886         err = idpf_send_mb_msg(vport->adapter, VIRTCHNL2_OP_LOOPBACK,
2887                                sizeof(loopback), (u8 *)&loopback);
2888         if (err)
2889                 goto rel_lock;
2890
2891         err = idpf_wait_for_event(vport->adapter, vport,
2892                                   IDPF_VC_LOOPBACK_STATE,
2893                                   IDPF_VC_LOOPBACK_STATE_ERR);
2894
2895 rel_lock:
2896         mutex_unlock(&vport->vc_buf_lock);
2897
2898         return err;
2899 }
2900
2901 /**
2902  * idpf_find_ctlq - Given a type and id, find ctlq info
2903  * @hw: hardware struct
2904  * @type: type of ctrlq to find
2905  * @id: ctlq id to find
2906  *
2907  * Returns pointer to found ctlq info struct, NULL otherwise.
2908  */
2909 static struct idpf_ctlq_info *idpf_find_ctlq(struct idpf_hw *hw,
2910                                              enum idpf_ctlq_type type, int id)
2911 {
2912         struct idpf_ctlq_info *cq, *tmp;
2913
2914         list_for_each_entry_safe(cq, tmp, &hw->cq_list_head, cq_list)
2915                 if (cq->q_id == id && cq->cq_type == type)
2916                         return cq;
2917
2918         return NULL;
2919 }
2920
2921 /**
2922  * idpf_init_dflt_mbx - Setup default mailbox parameters and make request
2923  * @adapter: adapter info struct
2924  *
2925  * Returns 0 on success, negative otherwise
2926  */
2927 int idpf_init_dflt_mbx(struct idpf_adapter *adapter)
2928 {
2929         struct idpf_ctlq_create_info ctlq_info[] = {
2930                 {
2931                         .type = IDPF_CTLQ_TYPE_MAILBOX_TX,
2932                         .id = IDPF_DFLT_MBX_ID,
2933                         .len = IDPF_DFLT_MBX_Q_LEN,
2934                         .buf_size = IDPF_CTLQ_MAX_BUF_LEN
2935                 },
2936                 {
2937                         .type = IDPF_CTLQ_TYPE_MAILBOX_RX,
2938                         .id = IDPF_DFLT_MBX_ID,
2939                         .len = IDPF_DFLT_MBX_Q_LEN,
2940                         .buf_size = IDPF_CTLQ_MAX_BUF_LEN
2941                 }
2942         };
2943         struct idpf_hw *hw = &adapter->hw;
2944         int err;
2945
2946         adapter->dev_ops.reg_ops.ctlq_reg_init(ctlq_info);
2947
2948         err = idpf_ctlq_init(hw, IDPF_NUM_DFLT_MBX_Q, ctlq_info);
2949         if (err)
2950                 return err;
2951
2952         hw->asq = idpf_find_ctlq(hw, IDPF_CTLQ_TYPE_MAILBOX_TX,
2953                                  IDPF_DFLT_MBX_ID);
2954         hw->arq = idpf_find_ctlq(hw, IDPF_CTLQ_TYPE_MAILBOX_RX,
2955                                  IDPF_DFLT_MBX_ID);
2956
2957         if (!hw->asq || !hw->arq) {
2958                 idpf_ctlq_deinit(hw);
2959
2960                 return -ENOENT;
2961         }
2962
2963         adapter->state = __IDPF_STARTUP;
2964
2965         return 0;
2966 }
2967
2968 /**
2969  * idpf_deinit_dflt_mbx - Free up ctlqs setup
2970  * @adapter: Driver specific private data structure
2971  */
2972 void idpf_deinit_dflt_mbx(struct idpf_adapter *adapter)
2973 {
2974         if (adapter->hw.arq && adapter->hw.asq) {
2975                 idpf_mb_clean(adapter);
2976                 idpf_ctlq_deinit(&adapter->hw);
2977         }
2978         adapter->hw.arq = NULL;
2979         adapter->hw.asq = NULL;
2980 }
2981
2982 /**
2983  * idpf_vport_params_buf_rel - Release memory for MailBox resources
2984  * @adapter: Driver specific private data structure
2985  *
2986  * Will release memory to hold the vport parameters received on MailBox
2987  */
2988 static void idpf_vport_params_buf_rel(struct idpf_adapter *adapter)
2989 {
2990         kfree(adapter->vport_params_recvd);
2991         adapter->vport_params_recvd = NULL;
2992         kfree(adapter->vport_params_reqd);
2993         adapter->vport_params_reqd = NULL;
2994         kfree(adapter->vport_ids);
2995         adapter->vport_ids = NULL;
2996 }
2997
2998 /**
2999  * idpf_vport_params_buf_alloc - Allocate memory for MailBox resources
3000  * @adapter: Driver specific private data structure
3001  *
3002  * Will alloc memory to hold the vport parameters received on MailBox
3003  */
3004 static int idpf_vport_params_buf_alloc(struct idpf_adapter *adapter)
3005 {
3006         u16 num_max_vports = idpf_get_max_vports(adapter);
3007
3008         adapter->vport_params_reqd = kcalloc(num_max_vports,
3009                                              sizeof(*adapter->vport_params_reqd),
3010                                              GFP_KERNEL);
3011         if (!adapter->vport_params_reqd)
3012                 return -ENOMEM;
3013
3014         adapter->vport_params_recvd = kcalloc(num_max_vports,
3015                                               sizeof(*adapter->vport_params_recvd),
3016                                               GFP_KERNEL);
3017         if (!adapter->vport_params_recvd)
3018                 goto err_mem;
3019
3020         adapter->vport_ids = kcalloc(num_max_vports, sizeof(u32), GFP_KERNEL);
3021         if (!adapter->vport_ids)
3022                 goto err_mem;
3023
3024         if (adapter->vport_config)
3025                 return 0;
3026
3027         adapter->vport_config = kcalloc(num_max_vports,
3028                                         sizeof(*adapter->vport_config),
3029                                         GFP_KERNEL);
3030         if (!adapter->vport_config)
3031                 goto err_mem;
3032
3033         return 0;
3034
3035 err_mem:
3036         idpf_vport_params_buf_rel(adapter);
3037
3038         return -ENOMEM;
3039 }
3040
3041 /**
3042  * idpf_vc_core_init - Initialize state machine and get driver specific
3043  * resources
3044  * @adapter: Driver specific private structure
3045  *
3046  * This function will initialize the state machine and request all necessary
3047  * resources required by the device driver. Once the state machine is
3048  * initialized, allocate memory to store vport specific information and also
3049  * requests required interrupts.
3050  *
3051  * Returns 0 on success, -EAGAIN function will get called again,
3052  * otherwise negative on failure.
3053  */
3054 int idpf_vc_core_init(struct idpf_adapter *adapter)
3055 {
3056         int task_delay = 30;
3057         u16 num_max_vports;
3058         int err = 0;
3059
3060         while (adapter->state != __IDPF_INIT_SW) {
3061                 switch (adapter->state) {
3062                 case __IDPF_STARTUP:
3063                         if (idpf_send_ver_msg(adapter))
3064                                 goto init_failed;
3065                         adapter->state = __IDPF_VER_CHECK;
3066                         goto restart;
3067                 case __IDPF_VER_CHECK:
3068                         err = idpf_recv_ver_msg(adapter);
3069                         if (err == -EIO) {
3070                                 return err;
3071                         } else if (err == -EAGAIN) {
3072                                 adapter->state = __IDPF_STARTUP;
3073                                 goto restart;
3074                         } else if (err) {
3075                                 goto init_failed;
3076                         }
3077                         if (idpf_send_get_caps_msg(adapter))
3078                                 goto init_failed;
3079                         adapter->state = __IDPF_GET_CAPS;
3080                         goto restart;
3081                 case __IDPF_GET_CAPS:
3082                         if (idpf_recv_get_caps_msg(adapter))
3083                                 goto init_failed;
3084                         adapter->state = __IDPF_INIT_SW;
3085                         break;
3086                 default:
3087                         dev_err(&adapter->pdev->dev, "Device is in bad state: %d\n",
3088                                 adapter->state);
3089                         goto init_failed;
3090                 }
3091                 break;
3092 restart:
3093                 /* Give enough time before proceeding further with
3094                  * state machine
3095                  */
3096                 msleep(task_delay);
3097         }
3098
3099         pci_sriov_set_totalvfs(adapter->pdev, idpf_get_max_vfs(adapter));
3100         num_max_vports = idpf_get_max_vports(adapter);
3101         adapter->max_vports = num_max_vports;
3102         adapter->vports = kcalloc(num_max_vports, sizeof(*adapter->vports),
3103                                   GFP_KERNEL);
3104         if (!adapter->vports)
3105                 return -ENOMEM;
3106
3107         if (!adapter->netdevs) {
3108                 adapter->netdevs = kcalloc(num_max_vports,
3109                                            sizeof(struct net_device *),
3110                                            GFP_KERNEL);
3111                 if (!adapter->netdevs) {
3112                         err = -ENOMEM;
3113                         goto err_netdev_alloc;
3114                 }
3115         }
3116
3117         err = idpf_vport_params_buf_alloc(adapter);
3118         if (err) {
3119                 dev_err(&adapter->pdev->dev, "Failed to alloc vport params buffer: %d\n",
3120                         err);
3121                 goto err_netdev_alloc;
3122         }
3123
3124         /* Start the mailbox task before requesting vectors. This will ensure
3125          * vector information response from mailbox is handled
3126          */
3127         queue_delayed_work(adapter->mbx_wq, &adapter->mbx_task, 0);
3128
3129         queue_delayed_work(adapter->serv_wq, &adapter->serv_task,
3130                            msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));
3131
3132         err = idpf_intr_req(adapter);
3133         if (err) {
3134                 dev_err(&adapter->pdev->dev, "failed to enable interrupt vectors: %d\n",
3135                         err);
3136                 goto err_intr_req;
3137         }
3138
3139         idpf_init_avail_queues(adapter);
3140
3141         /* Skew the delay for init tasks for each function based on fn number
3142          * to prevent every function from making the same call simultaneously.
3143          */
3144         queue_delayed_work(adapter->init_wq, &adapter->init_task,
3145                            msecs_to_jiffies(5 * (adapter->pdev->devfn & 0x07)));
3146
3147         goto no_err;
3148
3149 err_intr_req:
3150         cancel_delayed_work_sync(&adapter->serv_task);
3151         cancel_delayed_work_sync(&adapter->mbx_task);
3152         idpf_vport_params_buf_rel(adapter);
3153 err_netdev_alloc:
3154         kfree(adapter->vports);
3155         adapter->vports = NULL;
3156 no_err:
3157         return err;
3158
3159 init_failed:
3160         /* Don't retry if we're trying to go down, just bail. */
3161         if (test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
3162                 return err;
3163
3164         if (++adapter->mb_wait_count > IDPF_MB_MAX_ERR) {
3165                 dev_err(&adapter->pdev->dev, "Failed to establish mailbox communications with hardware\n");
3166
3167                 return -EFAULT;
3168         }
3169         /* If it reached here, it is possible that mailbox queue initialization
3170          * register writes might not have taken effect. Retry to initialize
3171          * the mailbox again
3172          */
3173         adapter->state = __IDPF_STARTUP;
3174         idpf_deinit_dflt_mbx(adapter);
3175         set_bit(IDPF_HR_DRV_LOAD, adapter->flags);
3176         queue_delayed_work(adapter->vc_event_wq, &adapter->vc_event_task,
3177                            msecs_to_jiffies(task_delay));
3178
3179         return -EAGAIN;
3180 }
3181
3182 /**
3183  * idpf_vc_core_deinit - Device deinit routine
3184  * @adapter: Driver specific private structure
3185  *
3186  */
3187 void idpf_vc_core_deinit(struct idpf_adapter *adapter)
3188 {
3189         int i;
3190
3191         idpf_deinit_task(adapter);
3192         idpf_intr_rel(adapter);
3193         /* Set all bits as we dont know on which vc_state the vhnl_wq is
3194          * waiting on and wakeup the virtchnl workqueue even if it is waiting
3195          * for the response as we are going down
3196          */
3197         for (i = 0; i < IDPF_VC_NBITS; i++)
3198                 set_bit(i, adapter->vc_state);
3199         wake_up(&adapter->vchnl_wq);
3200
3201         cancel_delayed_work_sync(&adapter->serv_task);
3202         cancel_delayed_work_sync(&adapter->mbx_task);
3203
3204         idpf_vport_params_buf_rel(adapter);
3205
3206         /* Clear all the bits */
3207         for (i = 0; i < IDPF_VC_NBITS; i++)
3208                 clear_bit(i, adapter->vc_state);
3209
3210         kfree(adapter->vports);
3211         adapter->vports = NULL;
3212 }
3213
3214 /**
3215  * idpf_vport_alloc_vec_indexes - Get relative vector indexes
3216  * @vport: virtual port data struct
3217  *
3218  * This function requests the vector information required for the vport and
3219  * stores the vector indexes received from the 'global vector distribution'
3220  * in the vport's queue vectors array.
3221  *
3222  * Return 0 on success, error on failure
3223  */
3224 int idpf_vport_alloc_vec_indexes(struct idpf_vport *vport)
3225 {
3226         struct idpf_vector_info vec_info;
3227         int num_alloc_vecs;
3228
3229         vec_info.num_curr_vecs = vport->num_q_vectors;
3230         vec_info.num_req_vecs = max(vport->num_txq, vport->num_rxq);
3231         vec_info.default_vport = vport->default_vport;
3232         vec_info.index = vport->idx;
3233
3234         num_alloc_vecs = idpf_req_rel_vector_indexes(vport->adapter,
3235                                                      vport->q_vector_idxs,
3236                                                      &vec_info);
3237         if (num_alloc_vecs <= 0) {
3238                 dev_err(&vport->adapter->pdev->dev, "Vector distribution failed: %d\n",
3239                         num_alloc_vecs);
3240                 return -EINVAL;
3241         }
3242
3243         vport->num_q_vectors = num_alloc_vecs;
3244
3245         return 0;
3246 }
3247
3248 /**
3249  * idpf_vport_init - Initialize virtual port
3250  * @vport: virtual port to be initialized
3251  * @max_q: vport max queue info
3252  *
3253  * Will initialize vport with the info received through MB earlier
3254  */
3255 void idpf_vport_init(struct idpf_vport *vport, struct idpf_vport_max_q *max_q)
3256 {
3257         struct idpf_adapter *adapter = vport->adapter;
3258         struct virtchnl2_create_vport *vport_msg;
3259         struct idpf_vport_config *vport_config;
3260         u16 tx_itr[] = {2, 8, 64, 128, 256};
3261         u16 rx_itr[] = {2, 8, 32, 96, 128};
3262         struct idpf_rss_data *rss_data;
3263         u16 idx = vport->idx;
3264
3265         vport_config = adapter->vport_config[idx];
3266         rss_data = &vport_config->user_config.rss_data;
3267         vport_msg = adapter->vport_params_recvd[idx];
3268
3269         vport_config->max_q.max_txq = max_q->max_txq;
3270         vport_config->max_q.max_rxq = max_q->max_rxq;
3271         vport_config->max_q.max_complq = max_q->max_complq;
3272         vport_config->max_q.max_bufq = max_q->max_bufq;
3273
3274         vport->txq_model = le16_to_cpu(vport_msg->txq_model);
3275         vport->rxq_model = le16_to_cpu(vport_msg->rxq_model);
3276         vport->vport_type = le16_to_cpu(vport_msg->vport_type);
3277         vport->vport_id = le32_to_cpu(vport_msg->vport_id);
3278
3279         rss_data->rss_key_size = min_t(u16, NETDEV_RSS_KEY_LEN,
3280                                        le16_to_cpu(vport_msg->rss_key_size));
3281         rss_data->rss_lut_size = le16_to_cpu(vport_msg->rss_lut_size);
3282
3283         ether_addr_copy(vport->default_mac_addr, vport_msg->default_mac_addr);
3284         vport->max_mtu = le16_to_cpu(vport_msg->max_mtu) - IDPF_PACKET_HDR_PAD;
3285
3286         /* Initialize Tx and Rx profiles for Dynamic Interrupt Moderation */
3287         memcpy(vport->rx_itr_profile, rx_itr, IDPF_DIM_PROFILE_SLOTS);
3288         memcpy(vport->tx_itr_profile, tx_itr, IDPF_DIM_PROFILE_SLOTS);
3289
3290         idpf_vport_set_hsplit(vport, ETHTOOL_TCP_DATA_SPLIT_ENABLED);
3291
3292         idpf_vport_init_num_qs(vport, vport_msg);
3293         idpf_vport_calc_num_q_desc(vport);
3294         idpf_vport_calc_num_q_groups(vport);
3295         idpf_vport_alloc_vec_indexes(vport);
3296
3297         vport->crc_enable = adapter->crc_enable;
3298 }
3299
3300 /**
3301  * idpf_get_vec_ids - Initialize vector id from Mailbox parameters
3302  * @adapter: adapter structure to get the mailbox vector id
3303  * @vecids: Array of vector ids
3304  * @num_vecids: number of vector ids
3305  * @chunks: vector ids received over mailbox
3306  *
3307  * Will initialize the mailbox vector id which is received from the
3308  * get capabilities and data queue vector ids with ids received as
3309  * mailbox parameters.
3310  * Returns number of ids filled
3311  */
3312 int idpf_get_vec_ids(struct idpf_adapter *adapter,
3313                      u16 *vecids, int num_vecids,
3314                      struct virtchnl2_vector_chunks *chunks)
3315 {
3316         u16 num_chunks = le16_to_cpu(chunks->num_vchunks);
3317         int num_vecid_filled = 0;
3318         int i, j;
3319
3320         vecids[num_vecid_filled] = adapter->mb_vector.v_idx;
3321         num_vecid_filled++;
3322
3323         for (j = 0; j < num_chunks; j++) {
3324                 struct virtchnl2_vector_chunk *chunk;
3325                 u16 start_vecid, num_vec;
3326
3327                 chunk = &chunks->vchunks[j];
3328                 num_vec = le16_to_cpu(chunk->num_vectors);
3329                 start_vecid = le16_to_cpu(chunk->start_vector_id);
3330
3331                 for (i = 0; i < num_vec; i++) {
3332                         if ((num_vecid_filled + i) < num_vecids) {
3333                                 vecids[num_vecid_filled + i] = start_vecid;
3334                                 start_vecid++;
3335                         } else {
3336                                 break;
3337                         }
3338                 }
3339                 num_vecid_filled = num_vecid_filled + i;
3340         }
3341
3342         return num_vecid_filled;
3343 }
3344
3345 /**
3346  * idpf_vport_get_queue_ids - Initialize queue id from Mailbox parameters
3347  * @qids: Array of queue ids
3348  * @num_qids: number of queue ids
3349  * @q_type: queue model
3350  * @chunks: queue ids received over mailbox
3351  *
3352  * Will initialize all queue ids with ids received as mailbox parameters
3353  * Returns number of ids filled
3354  */
3355 static int idpf_vport_get_queue_ids(u32 *qids, int num_qids, u16 q_type,
3356                                     struct virtchnl2_queue_reg_chunks *chunks)
3357 {
3358         u16 num_chunks = le16_to_cpu(chunks->num_chunks);
3359         u32 num_q_id_filled = 0, i;
3360         u32 start_q_id, num_q;
3361
3362         while (num_chunks--) {
3363                 struct virtchnl2_queue_reg_chunk *chunk;
3364
3365                 chunk = &chunks->chunks[num_chunks];
3366                 if (le32_to_cpu(chunk->type) != q_type)
3367                         continue;
3368
3369                 num_q = le32_to_cpu(chunk->num_queues);
3370                 start_q_id = le32_to_cpu(chunk->start_queue_id);
3371
3372                 for (i = 0; i < num_q; i++) {
3373                         if ((num_q_id_filled + i) < num_qids) {
3374                                 qids[num_q_id_filled + i] = start_q_id;
3375                                 start_q_id++;
3376                         } else {
3377                                 break;
3378                         }
3379                 }
3380                 num_q_id_filled = num_q_id_filled + i;
3381         }
3382
3383         return num_q_id_filled;
3384 }
3385
3386 /**
3387  * __idpf_vport_queue_ids_init - Initialize queue ids from Mailbox parameters
3388  * @vport: virtual port for which the queues ids are initialized
3389  * @qids: queue ids
3390  * @num_qids: number of queue ids
3391  * @q_type: type of queue
3392  *
3393  * Will initialize all queue ids with ids received as mailbox
3394  * parameters. Returns number of queue ids initialized.
3395  */
3396 static int __idpf_vport_queue_ids_init(struct idpf_vport *vport,
3397                                        const u32 *qids,
3398                                        int num_qids,
3399                                        u32 q_type)
3400 {
3401         struct idpf_queue *q;
3402         int i, j, k = 0;
3403
3404         switch (q_type) {
3405         case VIRTCHNL2_QUEUE_TYPE_TX:
3406                 for (i = 0; i < vport->num_txq_grp; i++) {
3407                         struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
3408
3409                         for (j = 0; j < tx_qgrp->num_txq && k < num_qids; j++, k++) {
3410                                 tx_qgrp->txqs[j]->q_id = qids[k];
3411                                 tx_qgrp->txqs[j]->q_type =
3412                                         VIRTCHNL2_QUEUE_TYPE_TX;
3413                         }
3414                 }
3415                 break;
3416         case VIRTCHNL2_QUEUE_TYPE_RX:
3417                 for (i = 0; i < vport->num_rxq_grp; i++) {
3418                         struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
3419                         u16 num_rxq;
3420
3421                         if (idpf_is_queue_model_split(vport->rxq_model))
3422                                 num_rxq = rx_qgrp->splitq.num_rxq_sets;
3423                         else
3424                                 num_rxq = rx_qgrp->singleq.num_rxq;
3425
3426                         for (j = 0; j < num_rxq && k < num_qids; j++, k++) {
3427                                 if (idpf_is_queue_model_split(vport->rxq_model))
3428                                         q = &rx_qgrp->splitq.rxq_sets[j]->rxq;
3429                                 else
3430                                         q = rx_qgrp->singleq.rxqs[j];
3431                                 q->q_id = qids[k];
3432                                 q->q_type = VIRTCHNL2_QUEUE_TYPE_RX;
3433                         }
3434                 }
3435                 break;
3436         case VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION:
3437                 for (i = 0; i < vport->num_txq_grp && k < num_qids; i++, k++) {
3438                         struct idpf_txq_group *tx_qgrp = &vport->txq_grps[i];
3439
3440                         tx_qgrp->complq->q_id = qids[k];
3441                         tx_qgrp->complq->q_type =
3442                                 VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION;
3443                 }
3444                 break;
3445         case VIRTCHNL2_QUEUE_TYPE_RX_BUFFER:
3446                 for (i = 0; i < vport->num_rxq_grp; i++) {
3447                         struct idpf_rxq_group *rx_qgrp = &vport->rxq_grps[i];
3448                         u8 num_bufqs = vport->num_bufqs_per_qgrp;
3449
3450                         for (j = 0; j < num_bufqs && k < num_qids; j++, k++) {
3451                                 q = &rx_qgrp->splitq.bufq_sets[j].bufq;
3452                                 q->q_id = qids[k];
3453                                 q->q_type = VIRTCHNL2_QUEUE_TYPE_RX_BUFFER;
3454                         }
3455                 }
3456                 break;
3457         default:
3458                 break;
3459         }
3460
3461         return k;
3462 }
3463
3464 /**
3465  * idpf_vport_queue_ids_init - Initialize queue ids from Mailbox parameters
3466  * @vport: virtual port for which the queues ids are initialized
3467  *
3468  * Will initialize all queue ids with ids received as mailbox parameters.
3469  * Returns 0 on success, negative if all the queues are not initialized.
3470  */
3471 int idpf_vport_queue_ids_init(struct idpf_vport *vport)
3472 {
3473         struct virtchnl2_create_vport *vport_params;
3474         struct virtchnl2_queue_reg_chunks *chunks;
3475         struct idpf_vport_config *vport_config;
3476         u16 vport_idx = vport->idx;
3477         int num_ids, err = 0;
3478         u16 q_type;
3479         u32 *qids;
3480
3481         vport_config = vport->adapter->vport_config[vport_idx];
3482         if (vport_config->req_qs_chunks) {
3483                 struct virtchnl2_add_queues *vc_aq =
3484                         (struct virtchnl2_add_queues *)vport_config->req_qs_chunks;
3485                 chunks = &vc_aq->chunks;
3486         } else {
3487                 vport_params = vport->adapter->vport_params_recvd[vport_idx];
3488                 chunks = &vport_params->chunks;
3489         }
3490
3491         qids = kcalloc(IDPF_MAX_QIDS, sizeof(u32), GFP_KERNEL);
3492         if (!qids)
3493                 return -ENOMEM;
3494
3495         num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS,
3496                                            VIRTCHNL2_QUEUE_TYPE_TX,
3497                                            chunks);
3498         if (num_ids < vport->num_txq) {
3499                 err = -EINVAL;
3500                 goto mem_rel;
3501         }
3502         num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids,
3503                                               VIRTCHNL2_QUEUE_TYPE_TX);
3504         if (num_ids < vport->num_txq) {
3505                 err = -EINVAL;
3506                 goto mem_rel;
3507         }
3508
3509         num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS,
3510                                            VIRTCHNL2_QUEUE_TYPE_RX,
3511                                            chunks);
3512         if (num_ids < vport->num_rxq) {
3513                 err = -EINVAL;
3514                 goto mem_rel;
3515         }
3516         num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids,
3517                                               VIRTCHNL2_QUEUE_TYPE_RX);
3518         if (num_ids < vport->num_rxq) {
3519                 err = -EINVAL;
3520                 goto mem_rel;
3521         }
3522
3523         if (!idpf_is_queue_model_split(vport->txq_model))
3524                 goto check_rxq;
3525
3526         q_type = VIRTCHNL2_QUEUE_TYPE_TX_COMPLETION;
3527         num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, q_type, chunks);
3528         if (num_ids < vport->num_complq) {
3529                 err = -EINVAL;
3530                 goto mem_rel;
3531         }
3532         num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, q_type);
3533         if (num_ids < vport->num_complq) {
3534                 err = -EINVAL;
3535                 goto mem_rel;
3536         }
3537
3538 check_rxq:
3539         if (!idpf_is_queue_model_split(vport->rxq_model))
3540                 goto mem_rel;
3541
3542         q_type = VIRTCHNL2_QUEUE_TYPE_RX_BUFFER;
3543         num_ids = idpf_vport_get_queue_ids(qids, IDPF_MAX_QIDS, q_type, chunks);
3544         if (num_ids < vport->num_bufq) {
3545                 err = -EINVAL;
3546                 goto mem_rel;
3547         }
3548         num_ids = __idpf_vport_queue_ids_init(vport, qids, num_ids, q_type);
3549         if (num_ids < vport->num_bufq)
3550                 err = -EINVAL;
3551
3552 mem_rel:
3553         kfree(qids);
3554
3555         return err;
3556 }
3557
3558 /**
3559  * idpf_vport_adjust_qs - Adjust to new requested queues
3560  * @vport: virtual port data struct
3561  *
3562  * Renegotiate queues.  Returns 0 on success, negative on failure.
3563  */
3564 int idpf_vport_adjust_qs(struct idpf_vport *vport)
3565 {
3566         struct virtchnl2_create_vport vport_msg;
3567         int err;
3568
3569         vport_msg.txq_model = cpu_to_le16(vport->txq_model);
3570         vport_msg.rxq_model = cpu_to_le16(vport->rxq_model);
3571         err = idpf_vport_calc_total_qs(vport->adapter, vport->idx, &vport_msg,
3572                                        NULL);
3573         if (err)
3574                 return err;
3575
3576         idpf_vport_init_num_qs(vport, &vport_msg);
3577         idpf_vport_calc_num_q_groups(vport);
3578
3579         return 0;
3580 }
3581
3582 /**
3583  * idpf_is_capability_ena - Default implementation of capability checking
3584  * @adapter: Private data struct
3585  * @all: all or one flag
3586  * @field: caps field to check for flags
3587  * @flag: flag to check
3588  *
3589  * Return true if all capabilities are supported, false otherwise
3590  */
3591 bool idpf_is_capability_ena(struct idpf_adapter *adapter, bool all,
3592                             enum idpf_cap_field field, u64 flag)
3593 {
3594         u8 *caps = (u8 *)&adapter->caps;
3595         u32 *cap_field;
3596
3597         if (!caps)
3598                 return false;
3599
3600         if (field == IDPF_BASE_CAPS)
3601                 return false;
3602
3603         cap_field = (u32 *)(caps + field);
3604
3605         if (all)
3606                 return (*cap_field & flag) == flag;
3607         else
3608                 return !!(*cap_field & flag);
3609 }
3610
3611 /**
3612  * idpf_get_vport_id: Get vport id
3613  * @vport: virtual port structure
3614  *
3615  * Return vport id from the adapter persistent data
3616  */
3617 u32 idpf_get_vport_id(struct idpf_vport *vport)
3618 {
3619         struct virtchnl2_create_vport *vport_msg;
3620
3621         vport_msg = vport->adapter->vport_params_recvd[vport->idx];
3622
3623         return le32_to_cpu(vport_msg->vport_id);
3624 }
3625
3626 /**
3627  * idpf_add_del_mac_filters - Add/del mac filters
3628  * @vport: Virtual port data structure
3629  * @np: Netdev private structure
3630  * @add: Add or delete flag
3631  * @async: Don't wait for return message
3632  *
3633  * Returns 0 on success, error on failure.
3634  **/
3635 int idpf_add_del_mac_filters(struct idpf_vport *vport,
3636                              struct idpf_netdev_priv *np,
3637                              bool add, bool async)
3638 {
3639         struct virtchnl2_mac_addr_list *ma_list = NULL;
3640         struct idpf_adapter *adapter = np->adapter;
3641         struct idpf_vport_config *vport_config;
3642         enum idpf_vport_config_flags mac_flag;
3643         struct pci_dev *pdev = adapter->pdev;
3644         enum idpf_vport_vc_state vc, vc_err;
3645         struct virtchnl2_mac_addr *mac_addr;
3646         struct idpf_mac_filter *f, *tmp;
3647         u32 num_msgs, total_filters = 0;
3648         int i = 0, k, err = 0;
3649         u32 vop;
3650
3651         vport_config = adapter->vport_config[np->vport_idx];
3652         spin_lock_bh(&vport_config->mac_filter_list_lock);
3653
3654         /* Find the number of newly added filters */
3655         list_for_each_entry(f, &vport_config->user_config.mac_filter_list,
3656                             list) {
3657                 if (add && f->add)
3658                         total_filters++;
3659                 else if (!add && f->remove)
3660                         total_filters++;
3661         }
3662
3663         if (!total_filters) {
3664                 spin_unlock_bh(&vport_config->mac_filter_list_lock);
3665
3666                 return 0;
3667         }
3668
3669         /* Fill all the new filters into virtchannel message */
3670         mac_addr = kcalloc(total_filters, sizeof(struct virtchnl2_mac_addr),
3671                            GFP_ATOMIC);
3672         if (!mac_addr) {
3673                 err = -ENOMEM;
3674                 spin_unlock_bh(&vport_config->mac_filter_list_lock);
3675                 goto error;
3676         }
3677
3678         list_for_each_entry_safe(f, tmp, &vport_config->user_config.mac_filter_list,
3679                                  list) {
3680                 if (add && f->add) {
3681                         ether_addr_copy(mac_addr[i].addr, f->macaddr);
3682                         i++;
3683                         f->add = false;
3684                         if (i == total_filters)
3685                                 break;
3686                 }
3687                 if (!add && f->remove) {
3688                         ether_addr_copy(mac_addr[i].addr, f->macaddr);
3689                         i++;
3690                         f->remove = false;
3691                         if (i == total_filters)
3692                                 break;
3693                 }
3694         }
3695
3696         spin_unlock_bh(&vport_config->mac_filter_list_lock);
3697
3698         if (add) {
3699                 vop = VIRTCHNL2_OP_ADD_MAC_ADDR;
3700                 vc = IDPF_VC_ADD_MAC_ADDR;
3701                 vc_err = IDPF_VC_ADD_MAC_ADDR_ERR;
3702                 mac_flag = IDPF_VPORT_ADD_MAC_REQ;
3703         } else {
3704                 vop = VIRTCHNL2_OP_DEL_MAC_ADDR;
3705                 vc = IDPF_VC_DEL_MAC_ADDR;
3706                 vc_err = IDPF_VC_DEL_MAC_ADDR_ERR;
3707                 mac_flag = IDPF_VPORT_DEL_MAC_REQ;
3708         }
3709
3710         /* Chunk up the filters into multiple messages to avoid
3711          * sending a control queue message buffer that is too large
3712          */
3713         num_msgs = DIV_ROUND_UP(total_filters, IDPF_NUM_FILTERS_PER_MSG);
3714
3715         if (!async)
3716                 mutex_lock(&vport->vc_buf_lock);
3717
3718         for (i = 0, k = 0; i < num_msgs; i++) {
3719                 u32 entries_size, buf_size, num_entries;
3720
3721                 num_entries = min_t(u32, total_filters,
3722                                     IDPF_NUM_FILTERS_PER_MSG);
3723                 entries_size = sizeof(struct virtchnl2_mac_addr) * num_entries;
3724                 buf_size = struct_size(ma_list, mac_addr_list, num_entries);
3725
3726                 if (!ma_list || num_entries != IDPF_NUM_FILTERS_PER_MSG) {
3727                         kfree(ma_list);
3728                         ma_list = kzalloc(buf_size, GFP_ATOMIC);
3729                         if (!ma_list) {
3730                                 err = -ENOMEM;
3731                                 goto list_prep_error;
3732                         }
3733                 } else {
3734                         memset(ma_list, 0, buf_size);
3735                 }
3736
3737                 ma_list->vport_id = cpu_to_le32(np->vport_id);
3738                 ma_list->num_mac_addr = cpu_to_le16(num_entries);
3739                 memcpy(ma_list->mac_addr_list, &mac_addr[k], entries_size);
3740
3741                 if (async)
3742                         set_bit(mac_flag, vport_config->flags);
3743
3744                 err = idpf_send_mb_msg(adapter, vop, buf_size, (u8 *)ma_list);
3745                 if (err)
3746                         goto mbx_error;
3747
3748                 if (!async) {
3749                         err = idpf_wait_for_event(adapter, vport, vc, vc_err);
3750                         if (err)
3751                                 goto mbx_error;
3752                 }
3753
3754                 k += num_entries;
3755                 total_filters -= num_entries;
3756         }
3757
3758 mbx_error:
3759         if (!async)
3760                 mutex_unlock(&vport->vc_buf_lock);
3761         kfree(ma_list);
3762 list_prep_error:
3763         kfree(mac_addr);
3764 error:
3765         if (err)
3766                 dev_err(&pdev->dev, "Failed to add or del mac filters %d", err);
3767
3768         return err;
3769 }
3770
3771 /**
3772  * idpf_set_promiscuous - set promiscuous and send message to mailbox
3773  * @adapter: Driver specific private structure
3774  * @config_data: Vport specific config data
3775  * @vport_id: Vport identifier
3776  *
3777  * Request to enable promiscuous mode for the vport. Message is sent
3778  * asynchronously and won't wait for response.  Returns 0 on success, negative
3779  * on failure;
3780  */
3781 int idpf_set_promiscuous(struct idpf_adapter *adapter,
3782                          struct idpf_vport_user_config_data *config_data,
3783                          u32 vport_id)
3784 {
3785         struct virtchnl2_promisc_info vpi;
3786         u16 flags = 0;
3787         int err;
3788
3789         if (test_bit(__IDPF_PROMISC_UC, config_data->user_flags))
3790                 flags |= VIRTCHNL2_UNICAST_PROMISC;
3791         if (test_bit(__IDPF_PROMISC_MC, config_data->user_flags))
3792                 flags |= VIRTCHNL2_MULTICAST_PROMISC;
3793
3794         vpi.vport_id = cpu_to_le32(vport_id);
3795         vpi.flags = cpu_to_le16(flags);
3796
3797         err = idpf_send_mb_msg(adapter, VIRTCHNL2_OP_CONFIG_PROMISCUOUS_MODE,
3798                                sizeof(struct virtchnl2_promisc_info),
3799                                (u8 *)&vpi);
3800
3801         return err;
3802 }