root/drivers/net/ethernet/intel/iavf/iavf_client.c

DEFINITIONS

1. iavf_client_get_params
2. iavf_notify_client_message
3. iavf_notify_client_l2_params
4. iavf_notify_client_open
5. iavf_client_release_qvlist
6. iavf_notify_client_close
7. iavf_client_add_instance
8. iavf_client_del_instance
9. iavf_client_subtask
10. iavf_lan_add_device
11. iavf_lan_del_device
12. iavf_client_release
13. iavf_client_prepare
14. iavf_client_virtchnl_send
15. iavf_client_setup_qvlist
16. iavf_register_client
17. iavf_unregister_client

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
   3 
   4 #include <linux/list.h>
   5 #include <linux/errno.h>
   6 
   7 #include "iavf.h"
   8 #include "iavf_prototype.h"
   9 #include "iavf_client.h"
  10 
  11 static
  12 const char iavf_client_interface_version_str[] = IAVF_CLIENT_VERSION_STR;
  13 static struct iavf_client *vf_registered_client;
  14 static LIST_HEAD(iavf_devices);
  15 static DEFINE_MUTEX(iavf_device_mutex);
  16 
  17 static u32 iavf_client_virtchnl_send(struct iavf_info *ldev,
  18                                      struct iavf_client *client,
  19                                      u8 *msg, u16 len);
  20 
  21 static int iavf_client_setup_qvlist(struct iavf_info *ldev,
  22                                     struct iavf_client *client,
  23                                     struct iavf_qvlist_info *qvlist_info);
  24 
  25 static struct iavf_ops iavf_lan_ops = {
  26         .virtchnl_send = iavf_client_virtchnl_send,
  27         .setup_qvlist = iavf_client_setup_qvlist,
  28 };
  29 
  30 /**
  31  * iavf_client_get_params - retrieve relevant client parameters
  32  * @vsi: VSI with parameters
  33  * @params: client param struct
  34  **/
  35 static
  36 void iavf_client_get_params(struct iavf_vsi *vsi, struct iavf_params *params)
  37 {
  38         int i;
  39 
  40         memset(params, 0, sizeof(struct iavf_params));
  41         params->mtu = vsi->netdev->mtu;
  42         params->link_up = vsi->back->link_up;
  43 
  44         for (i = 0; i < IAVF_MAX_USER_PRIORITY; i++) {
  45                 params->qos.prio_qos[i].tc = 0;
  46                 params->qos.prio_qos[i].qs_handle = vsi->qs_handle;
  47         }
  48 }
  49 
  50 /**
  51  * iavf_notify_client_message - call the client message receive callback
  52  * @vsi: the VSI associated with this client
  53  * @msg: message buffer
  54  * @len: length of message
  55  *
  56  * If there is a client to this VSI, call the client
  57  **/
  58 void iavf_notify_client_message(struct iavf_vsi *vsi, u8 *msg, u16 len)
  59 {
  60         struct iavf_client_instance *cinst;
  61 
  62         if (!vsi)
  63                 return;
  64 
  65         cinst = vsi->back->cinst;
  66         if (!cinst || !cinst->client || !cinst->client->ops ||
  67             !cinst->client->ops->virtchnl_receive) {
  68                 dev_dbg(&vsi->back->pdev->dev,
  69                         "Cannot locate client instance virtchnl_receive function\n");
  70                 return;
  71         }
  72         cinst->client->ops->virtchnl_receive(&cinst->lan_info,  cinst->client,
  73                                              msg, len);
  74 }
  75 
  76 /**
  77  * iavf_notify_client_l2_params - call the client notify callback
  78  * @vsi: the VSI with l2 param changes
  79  *
  80  * If there is a client to this VSI, call the client
  81  **/
  82 void iavf_notify_client_l2_params(struct iavf_vsi *vsi)
  83 {
  84         struct iavf_client_instance *cinst;
  85         struct iavf_params params;
  86 
  87         if (!vsi)
  88                 return;
  89 
  90         cinst = vsi->back->cinst;
  91 
  92         if (!cinst || !cinst->client || !cinst->client->ops ||
  93             !cinst->client->ops->l2_param_change) {
  94                 dev_dbg(&vsi->back->pdev->dev,
  95                         "Cannot locate client instance l2_param_change function\n");
  96                 return;
  97         }
  98         iavf_client_get_params(vsi, &params);
  99         cinst->lan_info.params = params;
 100         cinst->client->ops->l2_param_change(&cinst->lan_info, cinst->client,
 101                                             &params);
 102 }
 103 
 104 /**
 105  * iavf_notify_client_open - call the client open callback
 106  * @vsi: the VSI with netdev opened
 107  *
 108  * If there is a client to this netdev, call the client with open
 109  **/
 110 void iavf_notify_client_open(struct iavf_vsi *vsi)
 111 {
 112         struct iavf_adapter *adapter = vsi->back;
 113         struct iavf_client_instance *cinst = adapter->cinst;
 114         int ret;
 115 
 116         if (!cinst || !cinst->client || !cinst->client->ops ||
 117             !cinst->client->ops->open) {
 118                 dev_dbg(&vsi->back->pdev->dev,
 119                         "Cannot locate client instance open function\n");
 120                 return;
 121         }
 122         if (!(test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state))) {
 123                 ret = cinst->client->ops->open(&cinst->lan_info, cinst->client);
 124                 if (!ret)
 125                         set_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state);
 126         }
 127 }
 128 
 129 /**
 130  * iavf_client_release_qvlist - send a message to the PF to release iwarp qv map
 131  * @ldev: pointer to L2 context.
 132  *
 133  * Return 0 on success or < 0 on error
 134  **/
 135 static int iavf_client_release_qvlist(struct iavf_info *ldev)
 136 {
 137         struct iavf_adapter *adapter = ldev->vf;
 138         enum iavf_status err;
 139 
 140         if (adapter->aq_required)
 141                 return -EAGAIN;
 142 
 143         err = iavf_aq_send_msg_to_pf(&adapter->hw,
 144                                      VIRTCHNL_OP_RELEASE_IWARP_IRQ_MAP,
 145                                      IAVF_SUCCESS, NULL, 0, NULL);
 146 
 147         if (err)
 148                 dev_err(&adapter->pdev->dev,
 149                         "Unable to send iWarp vector release message to PF, error %d, aq status %d\n",
 150                         err, adapter->hw.aq.asq_last_status);
 151 
 152         return err;
 153 }
 154 
 155 /**
 156  * iavf_notify_client_close - call the client close callback
 157  * @vsi: the VSI with netdev closed
 158  * @reset: true when close called due to reset pending
 159  *
 160  * If there is a client to this netdev, call the client with close
 161  **/
 162 void iavf_notify_client_close(struct iavf_vsi *vsi, bool reset)
 163 {
 164         struct iavf_adapter *adapter = vsi->back;
 165         struct iavf_client_instance *cinst = adapter->cinst;
 166 
 167         if (!cinst || !cinst->client || !cinst->client->ops ||
 168             !cinst->client->ops->close) {
 169                 dev_dbg(&vsi->back->pdev->dev,
 170                         "Cannot locate client instance close function\n");
 171                 return;
 172         }
 173         cinst->client->ops->close(&cinst->lan_info, cinst->client, reset);
 174         iavf_client_release_qvlist(&cinst->lan_info);
 175         clear_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state);
 176 }
 177 
 178 /**
 179  * iavf_client_add_instance - add a client instance to the instance list
 180  * @adapter: pointer to the board struct
 181  *
 182  * Returns cinst ptr on success, NULL on failure
 183  **/
 184 static struct iavf_client_instance *
 185 iavf_client_add_instance(struct iavf_adapter *adapter)
 186 {
 187         struct iavf_client_instance *cinst = NULL;
 188         struct iavf_vsi *vsi = &adapter->vsi;
 189         struct netdev_hw_addr *mac = NULL;
 190         struct iavf_params params;
 191 
 192         if (!vf_registered_client)
 193                 goto out;
 194 
 195         if (adapter->cinst) {
 196                 cinst = adapter->cinst;
 197                 goto out;
 198         }
 199 
 200         cinst = kzalloc(sizeof(*cinst), GFP_KERNEL);
 201         if (!cinst)
 202                 goto out;
 203 
 204         cinst->lan_info.vf = (void *)adapter;
 205         cinst->lan_info.netdev = vsi->netdev;
 206         cinst->lan_info.pcidev = adapter->pdev;
 207         cinst->lan_info.fid = 0;
 208         cinst->lan_info.ftype = IAVF_CLIENT_FTYPE_VF;
 209         cinst->lan_info.hw_addr = adapter->hw.hw_addr;
 210         cinst->lan_info.ops = &iavf_lan_ops;
 211         cinst->lan_info.version.major = IAVF_CLIENT_VERSION_MAJOR;
 212         cinst->lan_info.version.minor = IAVF_CLIENT_VERSION_MINOR;
 213         cinst->lan_info.version.build = IAVF_CLIENT_VERSION_BUILD;
 214         iavf_client_get_params(vsi, &params);
 215         cinst->lan_info.params = params;
 216         set_bit(__IAVF_CLIENT_INSTANCE_NONE, &cinst->state);
 217 
 218         cinst->lan_info.msix_count = adapter->num_iwarp_msix;
 219         cinst->lan_info.msix_entries =
 220                         &adapter->msix_entries[adapter->iwarp_base_vector];
 221 
 222         mac = list_first_entry(&cinst->lan_info.netdev->dev_addrs.list,
 223                                struct netdev_hw_addr, list);
 224         if (mac)
 225                 ether_addr_copy(cinst->lan_info.lanmac, mac->addr);
 226         else
 227                 dev_err(&adapter->pdev->dev, "MAC address list is empty!\n");
 228 
 229         cinst->client = vf_registered_client;
 230         adapter->cinst = cinst;
 231 out:
 232         return cinst;
 233 }
 234 
 235 /**
 236  * iavf_client_del_instance - removes a client instance from the list
 237  * @adapter: pointer to the board struct
 238  *
 239  **/
 240 static
 241 void iavf_client_del_instance(struct iavf_adapter *adapter)
 242 {
 243         kfree(adapter->cinst);
 244         adapter->cinst = NULL;
 245 }
 246 
 247 /**
 248  * iavf_client_subtask - client maintenance work
 249  * @adapter: board private structure
 250  **/
 251 void iavf_client_subtask(struct iavf_adapter *adapter)
 252 {
 253         struct iavf_client *client = vf_registered_client;
 254         struct iavf_client_instance *cinst;
 255         int ret = 0;
 256 
 257         if (adapter->state < __IAVF_DOWN)
 258                 return;
 259 
 260         /* first check client is registered */
 261         if (!client)
 262                 return;
 263 
 264         /* Add the client instance to the instance list */
 265         cinst = iavf_client_add_instance(adapter);
 266         if (!cinst)
 267                 return;
 268 
 269         dev_info(&adapter->pdev->dev, "Added instance of Client %s\n",
 270                  client->name);
 271 
 272         if (!test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state)) {
 273                 /* Send an Open request to the client */
 274 
 275                 if (client->ops && client->ops->open)
 276                         ret = client->ops->open(&cinst->lan_info, client);
 277                 if (!ret)
 278                         set_bit(__IAVF_CLIENT_INSTANCE_OPENED,
 279                                 &cinst->state);
 280                 else
 281                         /* remove client instance */
 282                         iavf_client_del_instance(adapter);
 283         }
 284 }
 285 
 286 /**
 287  * iavf_lan_add_device - add a lan device struct to the list of lan devices
 288  * @adapter: pointer to the board struct
 289  *
 290  * Returns 0 on success or none 0 on error
 291  **/
 292 int iavf_lan_add_device(struct iavf_adapter *adapter)
 293 {
 294         struct iavf_device *ldev;
 295         int ret = 0;
 296 
 297         mutex_lock(&iavf_device_mutex);
 298         list_for_each_entry(ldev, &iavf_devices, list) {
 299                 if (ldev->vf == adapter) {
 300                         ret = -EEXIST;
 301                         goto out;
 302                 }
 303         }
 304         ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
 305         if (!ldev) {
 306                 ret = -ENOMEM;
 307                 goto out;
 308         }
 309         ldev->vf = adapter;
 310         INIT_LIST_HEAD(&ldev->list);
 311         list_add(&ldev->list, &iavf_devices);
 312         dev_info(&adapter->pdev->dev, "Added LAN device bus=0x%02x dev=0x%02x func=0x%02x\n",
 313                  adapter->hw.bus.bus_id, adapter->hw.bus.device,
 314                  adapter->hw.bus.func);
 315 
 316         /* Since in some cases register may have happened before a device gets
 317          * added, we can schedule a subtask to go initiate the clients.
 318          */
 319         adapter->flags |= IAVF_FLAG_SERVICE_CLIENT_REQUESTED;
 320 
 321 out:
 322         mutex_unlock(&iavf_device_mutex);
 323         return ret;
 324 }
 325 
 326 /**
 327  * iavf_lan_del_device - removes a lan device from the device list
 328  * @adapter: pointer to the board struct
 329  *
 330  * Returns 0 on success or non-0 on error
 331  **/
 332 int iavf_lan_del_device(struct iavf_adapter *adapter)
 333 {
 334         struct iavf_device *ldev, *tmp;
 335         int ret = -ENODEV;
 336 
 337         mutex_lock(&iavf_device_mutex);
 338         list_for_each_entry_safe(ldev, tmp, &iavf_devices, list) {
 339                 if (ldev->vf == adapter) {
 340                         dev_info(&adapter->pdev->dev,
 341                                  "Deleted LAN device bus=0x%02x dev=0x%02x func=0x%02x\n",
 342                                  adapter->hw.bus.bus_id, adapter->hw.bus.device,
 343                                  adapter->hw.bus.func);
 344                         list_del(&ldev->list);
 345                         kfree(ldev);
 346                         ret = 0;
 347                         break;
 348                 }
 349         }
 350 
 351         mutex_unlock(&iavf_device_mutex);
 352         return ret;
 353 }
 354 
 355 /**
 356  * iavf_client_release - release client specific resources
 357  * @client: pointer to the registered client
 358  *
 359  **/
 360 static void iavf_client_release(struct iavf_client *client)
 361 {
 362         struct iavf_client_instance *cinst;
 363         struct iavf_device *ldev;
 364         struct iavf_adapter *adapter;
 365 
 366         mutex_lock(&iavf_device_mutex);
 367         list_for_each_entry(ldev, &iavf_devices, list) {
 368                 adapter = ldev->vf;
 369                 cinst = adapter->cinst;
 370                 if (!cinst)
 371                         continue;
 372                 if (test_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state)) {
 373                         if (client->ops && client->ops->close)
 374                                 client->ops->close(&cinst->lan_info, client,
 375                                                    false);
 376                         iavf_client_release_qvlist(&cinst->lan_info);
 377                         clear_bit(__IAVF_CLIENT_INSTANCE_OPENED, &cinst->state);
 378 
 379                         dev_warn(&adapter->pdev->dev,
 380                                  "Client %s instance closed\n", client->name);
 381                 }
 382                 /* delete the client instance */
 383                 iavf_client_del_instance(adapter);
 384                 dev_info(&adapter->pdev->dev, "Deleted client instance of Client %s\n",
 385                          client->name);
 386         }
 387         mutex_unlock(&iavf_device_mutex);
 388 }
 389 
 390 /**
 391  * iavf_client_prepare - prepare client specific resources
 392  * @client: pointer to the registered client
 393  *
 394  **/
 395 static void iavf_client_prepare(struct iavf_client *client)
 396 {
 397         struct iavf_device *ldev;
 398         struct iavf_adapter *adapter;
 399 
 400         mutex_lock(&iavf_device_mutex);
 401         list_for_each_entry(ldev, &iavf_devices, list) {
 402                 adapter = ldev->vf;
 403                 /* Signal the watchdog to service the client */
 404                 adapter->flags |= IAVF_FLAG_SERVICE_CLIENT_REQUESTED;
 405         }
 406         mutex_unlock(&iavf_device_mutex);
 407 }
 408 
 409 /**
 410  * iavf_client_virtchnl_send - send a message to the PF instance
 411  * @ldev: pointer to L2 context.
 412  * @client: Client pointer.
 413  * @msg: pointer to message buffer
 414  * @len: message length
 415  *
 416  * Return 0 on success or < 0 on error
 417  **/
 418 static u32 iavf_client_virtchnl_send(struct iavf_info *ldev,
 419                                      struct iavf_client *client,
 420                                      u8 *msg, u16 len)
 421 {
 422         struct iavf_adapter *adapter = ldev->vf;
 423         enum iavf_status err;
 424 
 425         if (adapter->aq_required)
 426                 return -EAGAIN;
 427 
 428         err = iavf_aq_send_msg_to_pf(&adapter->hw, VIRTCHNL_OP_IWARP,
 429                                      IAVF_SUCCESS, msg, len, NULL);
 430         if (err)
 431                 dev_err(&adapter->pdev->dev, "Unable to send iWarp message to PF, error %d, aq status %d\n",
 432                         err, adapter->hw.aq.asq_last_status);
 433 
 434         return err;
 435 }
 436 
 437 /**
 438  * iavf_client_setup_qvlist - send a message to the PF to setup iwarp qv map
 439  * @ldev: pointer to L2 context.
 440  * @client: Client pointer.
 441  * @qvlist_info: queue and vector list
 442  *
 443  * Return 0 on success or < 0 on error
 444  **/
 445 static int iavf_client_setup_qvlist(struct iavf_info *ldev,
 446                                     struct iavf_client *client,
 447                                     struct iavf_qvlist_info *qvlist_info)
 448 {
 449         struct virtchnl_iwarp_qvlist_info *v_qvlist_info;
 450         struct iavf_adapter *adapter = ldev->vf;
 451         struct iavf_qv_info *qv_info;
 452         enum iavf_status err;
 453         u32 v_idx, i;
 454         size_t msg_size;
 455 
 456         if (adapter->aq_required)
 457                 return -EAGAIN;
 458 
 459         /* A quick check on whether the vectors belong to the client */
 460         for (i = 0; i < qvlist_info->num_vectors; i++) {
 461                 qv_info = &qvlist_info->qv_info[i];
 462                 if (!qv_info)
 463                         continue;
 464                 v_idx = qv_info->v_idx;
 465                 if ((v_idx >=
 466                     (adapter->iwarp_base_vector + adapter->num_iwarp_msix)) ||
 467                     (v_idx < adapter->iwarp_base_vector))
 468                         return -EINVAL;
 469         }
 470 
 471         v_qvlist_info = (struct virtchnl_iwarp_qvlist_info *)qvlist_info;
 472         msg_size = struct_size(v_qvlist_info, qv_info,
 473                                v_qvlist_info->num_vectors - 1);
 474 
 475         adapter->client_pending |= BIT(VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP);
 476         err = iavf_aq_send_msg_to_pf(&adapter->hw,
 477                                 VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP, IAVF_SUCCESS,
 478                                 (u8 *)v_qvlist_info, msg_size, NULL);
 479 
 480         if (err) {
 481                 dev_err(&adapter->pdev->dev,
 482                         "Unable to send iWarp vector config message to PF, error %d, aq status %d\n",
 483                         err, adapter->hw.aq.asq_last_status);
 484                 goto out;
 485         }
 486 
 487         err = -EBUSY;
 488         for (i = 0; i < 5; i++) {
 489                 msleep(100);
 490                 if (!(adapter->client_pending &
 491                       BIT(VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP))) {
 492                         err = 0;
 493                         break;
 494                 }
 495         }
 496 out:
 497         return err;
 498 }
 499 
 500 /**
 501  * iavf_register_client - Register a iavf client driver with the L2 driver
 502  * @client: pointer to the iavf_client struct
 503  *
 504  * Returns 0 on success or non-0 on error
 505  **/
 506 int iavf_register_client(struct iavf_client *client)
 507 {
 508         int ret = 0;
 509 
 510         if (!client) {
 511                 ret = -EIO;
 512                 goto out;
 513         }
 514 
 515         if (strlen(client->name) == 0) {
 516                 pr_info("iavf: Failed to register client with no name\n");
 517                 ret = -EIO;
 518                 goto out;
 519         }
 520 
 521         if (vf_registered_client) {
 522                 pr_info("iavf: Client %s has already been registered!\n",
 523                         client->name);
 524                 ret = -EEXIST;
 525                 goto out;
 526         }
 527 
 528         if ((client->version.major != IAVF_CLIENT_VERSION_MAJOR) ||
 529             (client->version.minor != IAVF_CLIENT_VERSION_MINOR)) {
 530                 pr_info("iavf: Failed to register client %s due to mismatched client interface version\n",
 531                         client->name);
 532                 pr_info("Client is using version: %02d.%02d.%02d while LAN driver supports %s\n",
 533                         client->version.major, client->version.minor,
 534                         client->version.build,
 535                         iavf_client_interface_version_str);
 536                 ret = -EIO;
 537                 goto out;
 538         }
 539 
 540         vf_registered_client = client;
 541 
 542         iavf_client_prepare(client);
 543 
 544         pr_info("iavf: Registered client %s with return code %d\n",
 545                 client->name, ret);
 546 out:
 547         return ret;
 548 }
 549 EXPORT_SYMBOL(iavf_register_client);
 550 
 551 /**
 552  * iavf_unregister_client - Unregister a iavf client driver with the L2 driver
 553  * @client: pointer to the iavf_client struct
 554  *
 555  * Returns 0 on success or non-0 on error
 556  **/
 557 int iavf_unregister_client(struct iavf_client *client)
 558 {
 559         int ret = 0;
 560 
 561         /* When a unregister request comes through we would have to send
 562          * a close for each of the client instances that were opened.
 563          * client_release function is called to handle this.
 564          */
 565         iavf_client_release(client);
 566 
 567         if (vf_registered_client != client) {
 568                 pr_info("iavf: Client %s has not been registered\n",
 569                         client->name);
 570                 ret = -ENODEV;
 571                 goto out;
 572         }
 573         vf_registered_client = NULL;
 574         pr_info("iavf: Unregistered client %s\n", client->name);
 575 out:
 576         return ret;
 577 }
 578 EXPORT_SYMBOL(iavf_unregister_client);