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#include <linux/net/intel/i40e_client.h> 7 8#include "i40e.h" 9#include "i40e_prototype.h" 10 11static const char i40e_client_interface_version_str[] = I40E_CLIENT_VERSION_STR; 12static struct i40e_client *registered_client; 13static LIST_HEAD(i40e_devices); 14static DEFINE_MUTEX(i40e_device_mutex); 15 16static int i40e_client_virtchnl_send(struct i40e_info *ldev, 17 struct i40e_client *client, 18 u32 vf_id, u8 *msg, u16 len); 19 20static int i40e_client_setup_qvlist(struct i40e_info *ldev, 21 struct i40e_client *client, 22 struct i40e_qvlist_info *qvlist_info); 23 24static void i40e_client_request_reset(struct i40e_info *ldev, 25 struct i40e_client *client, 26 u32 reset_level); 27 28static int i40e_client_update_vsi_ctxt(struct i40e_info *ldev, 29 struct i40e_client *client, 30 bool is_vf, u32 vf_id, 31 u32 flag, u32 valid_flag); 32 33static struct i40e_ops i40e_lan_ops = { 34 .virtchnl_send = i40e_client_virtchnl_send, 35 .setup_qvlist = i40e_client_setup_qvlist, 36 .request_reset = i40e_client_request_reset, 37 .update_vsi_ctxt = i40e_client_update_vsi_ctxt, 38}; 39 40/** 41 * i40e_client_get_params - Get the params that can change at runtime 42 * @vsi: the VSI with the message 43 * @params: client param struct 44 * 45 **/ 46static 47int i40e_client_get_params(struct i40e_vsi *vsi, struct i40e_params *params) 48{ 49 struct i40e_dcbx_config *dcb_cfg = &vsi->back->hw.local_dcbx_config; 50 int i = 0; 51 52 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) { 53 u8 tc = dcb_cfg->etscfg.prioritytable[i]; 54 u16 qs_handle; 55 56 /* If TC is not enabled for VSI use TC0 for UP */ 57 if (!(vsi->tc_config.enabled_tc & BIT(tc))) 58 tc = 0; 59 60 qs_handle = le16_to_cpu(vsi->info.qs_handle[tc]); 61 params->qos.prio_qos[i].tc = tc; 62 params->qos.prio_qos[i].qs_handle = qs_handle; 63 if (qs_handle == I40E_AQ_VSI_QS_HANDLE_INVALID) { 64 dev_err(&vsi->back->pdev->dev, "Invalid queue set handle for TC = %d, vsi id = %d\n", 65 tc, vsi->id); 66 return -EINVAL; 67 } 68 } 69 70 params->mtu = vsi->netdev->mtu; 71 return 0; 72} 73 74/** 75 * i40e_notify_client_of_vf_msg - call the client vf message callback 76 * @vsi: the VSI with the message 77 * @vf_id: the absolute VF id that sent the message 78 * @msg: message buffer 79 * @len: length of the message 80 * 81 * If there is a client to this VSI, call the client 82 **/ 83void 84i40e_notify_client_of_vf_msg(struct i40e_vsi *vsi, u32 vf_id, u8 *msg, u16 len) 85{ 86 struct i40e_pf *pf = vsi->back; 87 struct i40e_client_instance *cdev = pf->cinst; 88 89 if (!cdev || !cdev->client) 90 return; 91 if (!cdev->client->ops || !cdev->client->ops->virtchnl_receive) { 92 dev_dbg(&pf->pdev->dev, 93 "Cannot locate client instance virtual channel receive routine\n"); 94 return; 95 } 96 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) { 97 dev_dbg(&pf->pdev->dev, "Client is not open, abort virtchnl_receive\n"); 98 return; 99 } 100 cdev->client->ops->virtchnl_receive(&cdev->lan_info, cdev->client, 101 vf_id, msg, len); 102} 103 104/** 105 * i40e_notify_client_of_l2_param_changes - call the client notify callback 106 * @vsi: the VSI with l2 param changes 107 * 108 * If there is a client to this VSI, call the client 109 **/ 110void i40e_notify_client_of_l2_param_changes(struct i40e_vsi *vsi) 111{ 112 struct i40e_pf *pf = vsi->back; 113 struct i40e_client_instance *cdev = pf->cinst; 114 struct i40e_params params; 115 116 if (!cdev || !cdev->client) 117 return; 118 if (!cdev->client->ops || !cdev->client->ops->l2_param_change) { 119 dev_dbg(&vsi->back->pdev->dev, 120 "Cannot locate client instance l2_param_change routine\n"); 121 return; 122 } 123 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) { 124 dev_dbg(&vsi->back->pdev->dev, "Client is not open, abort l2 param change\n"); 125 return; 126 } 127 memset(¶ms, 0, sizeof(params)); 128 i40e_client_get_params(vsi, ¶ms); 129 memcpy(&cdev->lan_info.params, ¶ms, sizeof(struct i40e_params)); 130 cdev->client->ops->l2_param_change(&cdev->lan_info, cdev->client, 131 ¶ms); 132} 133 134/** 135 * i40e_client_release_qvlist - release MSI-X vector mapping for client 136 * @ldev: pointer to L2 context. 137 * 138 **/ 139static void i40e_client_release_qvlist(struct i40e_info *ldev) 140{ 141 struct i40e_qvlist_info *qvlist_info = ldev->qvlist_info; 142 u32 i; 143 144 if (!ldev->qvlist_info) 145 return; 146 147 for (i = 0; i < qvlist_info->num_vectors; i++) { 148 struct i40e_pf *pf = ldev->pf; 149 struct i40e_qv_info *qv_info; 150 u32 reg_idx; 151 152 qv_info = &qvlist_info->qv_info[i]; 153 if (!qv_info) 154 continue; 155 reg_idx = I40E_PFINT_LNKLSTN(qv_info->v_idx - 1); 156 wr32(&pf->hw, reg_idx, I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK); 157 } 158 kfree(ldev->qvlist_info); 159 ldev->qvlist_info = NULL; 160} 161 162/** 163 * i40e_notify_client_of_netdev_close - call the client close callback 164 * @vsi: the VSI with netdev closed 165 * @reset: true when close called due to a reset pending 166 * 167 * If there is a client to this netdev, call the client with close 168 **/ 169void i40e_notify_client_of_netdev_close(struct i40e_vsi *vsi, bool reset) 170{ 171 struct i40e_pf *pf = vsi->back; 172 struct i40e_client_instance *cdev = pf->cinst; 173 174 if (!cdev || !cdev->client) 175 return; 176 if (!cdev->client->ops || !cdev->client->ops->close) { 177 dev_dbg(&vsi->back->pdev->dev, 178 "Cannot locate client instance close routine\n"); 179 return; 180 } 181 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) { 182 dev_dbg(&pf->pdev->dev, "Client is not open, abort close\n"); 183 return; 184 } 185 cdev->client->ops->close(&cdev->lan_info, cdev->client, reset); 186 clear_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state); 187 i40e_client_release_qvlist(&cdev->lan_info); 188} 189 190/** 191 * i40e_notify_client_of_vf_reset - call the client vf reset callback 192 * @pf: PF device pointer 193 * @vf_id: asolute id of VF being reset 194 * 195 * If there is a client attached to this PF, notify when a VF is reset 196 **/ 197void i40e_notify_client_of_vf_reset(struct i40e_pf *pf, u32 vf_id) 198{ 199 struct i40e_client_instance *cdev = pf->cinst; 200 201 if (!cdev || !cdev->client) 202 return; 203 if (!cdev->client->ops || !cdev->client->ops->vf_reset) { 204 dev_dbg(&pf->pdev->dev, 205 "Cannot locate client instance VF reset routine\n"); 206 return; 207 } 208 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) { 209 dev_dbg(&pf->pdev->dev, "Client is not open, abort vf-reset\n"); 210 return; 211 } 212 cdev->client->ops->vf_reset(&cdev->lan_info, cdev->client, vf_id); 213} 214 215/** 216 * i40e_notify_client_of_vf_enable - call the client vf notification callback 217 * @pf: PF device pointer 218 * @num_vfs: the number of VFs currently enabled, 0 for disable 219 * 220 * If there is a client attached to this PF, call its VF notification routine 221 **/ 222void i40e_notify_client_of_vf_enable(struct i40e_pf *pf, u32 num_vfs) 223{ 224 struct i40e_client_instance *cdev = pf->cinst; 225 226 if (!cdev || !cdev->client) 227 return; 228 if (!cdev->client->ops || !cdev->client->ops->vf_enable) { 229 dev_dbg(&pf->pdev->dev, 230 "Cannot locate client instance VF enable routine\n"); 231 return; 232 } 233 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, 234 &cdev->state)) { 235 dev_dbg(&pf->pdev->dev, "Client is not open, abort vf-enable\n"); 236 return; 237 } 238 cdev->client->ops->vf_enable(&cdev->lan_info, cdev->client, num_vfs); 239} 240 241/** 242 * i40e_vf_client_capable - ask the client if it likes the specified VF 243 * @pf: PF device pointer 244 * @vf_id: the VF in question 245 * 246 * If there is a client of the specified type attached to this PF, call 247 * its vf_capable routine 248 **/ 249int i40e_vf_client_capable(struct i40e_pf *pf, u32 vf_id) 250{ 251 struct i40e_client_instance *cdev = pf->cinst; 252 int capable = false; 253 254 if (!cdev || !cdev->client) 255 goto out; 256 if (!cdev->client->ops || !cdev->client->ops->vf_capable) { 257 dev_dbg(&pf->pdev->dev, 258 "Cannot locate client instance VF capability routine\n"); 259 goto out; 260 } 261 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) 262 goto out; 263 264 capable = cdev->client->ops->vf_capable(&cdev->lan_info, 265 cdev->client, 266 vf_id); 267out: 268 return capable; 269} 270 271void i40e_client_update_msix_info(struct i40e_pf *pf) 272{ 273 struct i40e_client_instance *cdev = pf->cinst; 274 275 if (!cdev || !cdev->client) 276 return; 277 278 cdev->lan_info.msix_count = pf->num_iwarp_msix; 279 cdev->lan_info.msix_entries = &pf->msix_entries[pf->iwarp_base_vector]; 280} 281 282/** 283 * i40e_client_add_instance - add a client instance struct to the instance list 284 * @pf: pointer to the board struct 285 * 286 **/ 287static void i40e_client_add_instance(struct i40e_pf *pf) 288{ 289 struct i40e_client_instance *cdev = NULL; 290 struct netdev_hw_addr *mac = NULL; 291 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi]; 292 293 if (!registered_client || pf->cinst) 294 return; 295 296 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL); 297 if (!cdev) 298 return; 299 300 cdev->lan_info.pf = (void *)pf; 301 cdev->lan_info.netdev = vsi->netdev; 302 cdev->lan_info.pcidev = pf->pdev; 303 cdev->lan_info.fid = pf->hw.pf_id; 304 cdev->lan_info.ftype = I40E_CLIENT_FTYPE_PF; 305 cdev->lan_info.hw_addr = pf->hw.hw_addr; 306 cdev->lan_info.ops = &i40e_lan_ops; 307 cdev->lan_info.version.major = I40E_CLIENT_VERSION_MAJOR; 308 cdev->lan_info.version.minor = I40E_CLIENT_VERSION_MINOR; 309 cdev->lan_info.version.build = I40E_CLIENT_VERSION_BUILD; 310 cdev->lan_info.fw_maj_ver = pf->hw.aq.fw_maj_ver; 311 cdev->lan_info.fw_min_ver = pf->hw.aq.fw_min_ver; 312 cdev->lan_info.fw_build = pf->hw.aq.fw_build; 313 set_bit(__I40E_CLIENT_INSTANCE_NONE, &cdev->state); 314 315 if (i40e_client_get_params(vsi, &cdev->lan_info.params)) { 316 kfree(cdev); 317 cdev = NULL; 318 return; 319 } 320 321 mac = list_first_entry(&cdev->lan_info.netdev->dev_addrs.list, 322 struct netdev_hw_addr, list); 323 if (mac) 324 ether_addr_copy(cdev->lan_info.lanmac, mac->addr); 325 else 326 dev_err(&pf->pdev->dev, "MAC address list is empty!\n"); 327 328 cdev->client = registered_client; 329 pf->cinst = cdev; 330 331 i40e_client_update_msix_info(pf); 332} 333 334/** 335 * i40e_client_del_instance - removes a client instance from the list 336 * @pf: pointer to the board struct 337 * 338 **/ 339static 340void i40e_client_del_instance(struct i40e_pf *pf) 341{ 342 kfree(pf->cinst); 343 pf->cinst = NULL; 344} 345 346/** 347 * i40e_client_subtask - client maintenance work 348 * @pf: board private structure 349 **/ 350void i40e_client_subtask(struct i40e_pf *pf) 351{ 352 struct i40e_client *client = registered_client; 353 struct i40e_client_instance *cdev; 354 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi]; 355 int ret = 0; 356 357 if (!test_and_clear_bit(__I40E_CLIENT_SERVICE_REQUESTED, pf->state)) 358 return; 359 cdev = pf->cinst; 360 361 /* If we're down or resetting, just bail */ 362 if (test_bit(__I40E_DOWN, pf->state) || 363 test_bit(__I40E_CONFIG_BUSY, pf->state)) 364 return; 365 366 if (!client || !cdev) 367 return; 368 369 /* Here we handle client opens. If the client is down, and 370 * the netdev is registered, then open the client. 371 */ 372 if (!test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) { 373 if (vsi->netdev_registered && 374 client->ops && client->ops->open) { 375 set_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state); 376 ret = client->ops->open(&cdev->lan_info, client); 377 if (ret) { 378 /* Remove failed client instance */ 379 clear_bit(__I40E_CLIENT_INSTANCE_OPENED, 380 &cdev->state); 381 return; 382 } 383 } 384 } 385 386 /* enable/disable PE TCP_ENA flag based on netdev down/up 387 */ 388 if (test_bit(__I40E_VSI_DOWN, vsi->state)) 389 i40e_client_update_vsi_ctxt(&cdev->lan_info, client, 390 0, 0, 0, 391 I40E_CLIENT_VSI_FLAG_TCP_ENABLE); 392 else 393 i40e_client_update_vsi_ctxt(&cdev->lan_info, client, 394 0, 0, 395 I40E_CLIENT_VSI_FLAG_TCP_ENABLE, 396 I40E_CLIENT_VSI_FLAG_TCP_ENABLE); 397} 398 399/** 400 * i40e_lan_add_device - add a lan device struct to the list of lan devices 401 * @pf: pointer to the board struct 402 * 403 * Returns 0 on success or none 0 on error 404 **/ 405int i40e_lan_add_device(struct i40e_pf *pf) 406{ 407 struct i40e_device *ldev; 408 int ret = 0; 409 410 mutex_lock(&i40e_device_mutex); 411 list_for_each_entry(ldev, &i40e_devices, list) { 412 if (ldev->pf == pf) { 413 ret = -EEXIST; 414 goto out; 415 } 416 } 417 ldev = kzalloc(sizeof(*ldev), GFP_KERNEL); 418 if (!ldev) { 419 ret = -ENOMEM; 420 goto out; 421 } 422 ldev->pf = pf; 423 INIT_LIST_HEAD(&ldev->list); 424 list_add(&ldev->list, &i40e_devices); 425 dev_info(&pf->pdev->dev, "Added LAN device PF%d bus=0x%02x dev=0x%02x func=0x%02x\n", 426 pf->hw.pf_id, pf->hw.bus.bus_id, 427 pf->hw.bus.device, pf->hw.bus.func); 428 429 /* If a client has already been registered, we need to add an instance 430 * of it to our new LAN device. 431 */ 432 if (registered_client) 433 i40e_client_add_instance(pf); 434 435 /* Since in some cases register may have happened before a device gets 436 * added, we can schedule a subtask to go initiate the clients if 437 * they can be launched at probe time. 438 */ 439 set_bit(__I40E_CLIENT_SERVICE_REQUESTED, pf->state); 440 i40e_service_event_schedule(pf); 441 442out: 443 mutex_unlock(&i40e_device_mutex); 444 return ret; 445} 446 447/** 448 * i40e_lan_del_device - removes a lan device from the device list 449 * @pf: pointer to the board struct 450 * 451 * Returns 0 on success or non-0 on error 452 **/ 453int i40e_lan_del_device(struct i40e_pf *pf) 454{ 455 struct i40e_device *ldev, *tmp; 456 int ret = -ENODEV; 457 458 /* First, remove any client instance. */ 459 i40e_client_del_instance(pf); 460 461 mutex_lock(&i40e_device_mutex); 462 list_for_each_entry_safe(ldev, tmp, &i40e_devices, list) { 463 if (ldev->pf == pf) { 464 dev_info(&pf->pdev->dev, "Deleted LAN device PF%d bus=0x%02x dev=0x%02x func=0x%02x\n", 465 pf->hw.pf_id, pf->hw.bus.bus_id, 466 pf->hw.bus.device, pf->hw.bus.func); 467 list_del(&ldev->list); 468 kfree(ldev); 469 ret = 0; 470 break; 471 } 472 } 473 mutex_unlock(&i40e_device_mutex); 474 return ret; 475} 476 477/** 478 * i40e_client_release - release client specific resources 479 * @client: pointer to the registered client 480 * 481 **/ 482static void i40e_client_release(struct i40e_client *client) 483{ 484 struct i40e_client_instance *cdev; 485 struct i40e_device *ldev; 486 struct i40e_pf *pf; 487 488 mutex_lock(&i40e_device_mutex); 489 list_for_each_entry(ldev, &i40e_devices, list) { 490 pf = ldev->pf; 491 cdev = pf->cinst; 492 if (!cdev) 493 continue; 494 495 while (test_and_set_bit(__I40E_SERVICE_SCHED, 496 pf->state)) 497 usleep_range(500, 1000); 498 499 if (test_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state)) { 500 if (client->ops && client->ops->close) 501 client->ops->close(&cdev->lan_info, client, 502 false); 503 i40e_client_release_qvlist(&cdev->lan_info); 504 clear_bit(__I40E_CLIENT_INSTANCE_OPENED, &cdev->state); 505 506 dev_warn(&pf->pdev->dev, 507 "Client %s instance for PF id %d closed\n", 508 client->name, pf->hw.pf_id); 509 } 510 /* delete the client instance */ 511 i40e_client_del_instance(pf); 512 dev_info(&pf->pdev->dev, "Deleted client instance of Client %s\n", 513 client->name); 514 clear_bit(__I40E_SERVICE_SCHED, pf->state); 515 } 516 mutex_unlock(&i40e_device_mutex); 517} 518 519/** 520 * i40e_client_prepare - prepare client specific resources 521 * @client: pointer to the registered client 522 * 523 **/ 524static void i40e_client_prepare(struct i40e_client *client) 525{ 526 struct i40e_device *ldev; 527 struct i40e_pf *pf; 528 529 mutex_lock(&i40e_device_mutex); 530 list_for_each_entry(ldev, &i40e_devices, list) { 531 pf = ldev->pf; 532 i40e_client_add_instance(pf); 533 /* Start the client subtask */ 534 set_bit(__I40E_CLIENT_SERVICE_REQUESTED, pf->state); 535 i40e_service_event_schedule(pf); 536 } 537 mutex_unlock(&i40e_device_mutex); 538} 539 540/** 541 * i40e_client_virtchnl_send - TBD 542 * @ldev: pointer to L2 context 543 * @client: Client pointer 544 * @vf_id: absolute VF identifier 545 * @msg: message buffer 546 * @len: length of message buffer 547 * 548 * Return 0 on success or < 0 on error 549 **/ 550static int i40e_client_virtchnl_send(struct i40e_info *ldev, 551 struct i40e_client *client, 552 u32 vf_id, u8 *msg, u16 len) 553{ 554 struct i40e_pf *pf = ldev->pf; 555 struct i40e_hw *hw = &pf->hw; 556 i40e_status err; 557 558 err = i40e_aq_send_msg_to_vf(hw, vf_id, VIRTCHNL_OP_IWARP, 559 0, msg, len, NULL); 560 if (err) 561 dev_err(&pf->pdev->dev, "Unable to send iWarp message to VF, error %d, aq status %d\n", 562 err, hw->aq.asq_last_status); 563 564 return err; 565} 566 567/** 568 * i40e_client_setup_qvlist 569 * @ldev: pointer to L2 context. 570 * @client: Client pointer. 571 * @qvlist_info: queue and vector list 572 * 573 * Return 0 on success or < 0 on error 574 **/ 575static int i40e_client_setup_qvlist(struct i40e_info *ldev, 576 struct i40e_client *client, 577 struct i40e_qvlist_info *qvlist_info) 578{ 579 struct i40e_pf *pf = ldev->pf; 580 struct i40e_hw *hw = &pf->hw; 581 struct i40e_qv_info *qv_info; 582 u32 v_idx, i, reg_idx, reg; 583 584 ldev->qvlist_info = kzalloc(struct_size(ldev->qvlist_info, qv_info, 585 qvlist_info->num_vectors - 1), GFP_KERNEL); 586 if (!ldev->qvlist_info) 587 return -ENOMEM; 588 ldev->qvlist_info->num_vectors = qvlist_info->num_vectors; 589 590 for (i = 0; i < qvlist_info->num_vectors; i++) { 591 qv_info = &qvlist_info->qv_info[i]; 592 if (!qv_info) 593 continue; 594 v_idx = qv_info->v_idx; 595 596 /* Validate vector id belongs to this client */ 597 if ((v_idx >= (pf->iwarp_base_vector + pf->num_iwarp_msix)) || 598 (v_idx < pf->iwarp_base_vector)) 599 goto err; 600 601 ldev->qvlist_info->qv_info[i] = *qv_info; 602 reg_idx = I40E_PFINT_LNKLSTN(v_idx - 1); 603 604 if (qv_info->ceq_idx == I40E_QUEUE_INVALID_IDX) { 605 /* Special case - No CEQ mapped on this vector */ 606 wr32(hw, reg_idx, I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK); 607 } else { 608 reg = (qv_info->ceq_idx & 609 I40E_PFINT_LNKLSTN_FIRSTQ_INDX_MASK) | 610 (I40E_QUEUE_TYPE_PE_CEQ << 611 I40E_PFINT_LNKLSTN_FIRSTQ_TYPE_SHIFT); 612 wr32(hw, reg_idx, reg); 613 614 reg = (I40E_PFINT_CEQCTL_CAUSE_ENA_MASK | 615 (v_idx << I40E_PFINT_CEQCTL_MSIX_INDX_SHIFT) | 616 (qv_info->itr_idx << 617 I40E_PFINT_CEQCTL_ITR_INDX_SHIFT) | 618 (I40E_QUEUE_END_OF_LIST << 619 I40E_PFINT_CEQCTL_NEXTQ_INDX_SHIFT)); 620 wr32(hw, I40E_PFINT_CEQCTL(qv_info->ceq_idx), reg); 621 } 622 if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) { 623 reg = (I40E_PFINT_AEQCTL_CAUSE_ENA_MASK | 624 (v_idx << I40E_PFINT_AEQCTL_MSIX_INDX_SHIFT) | 625 (qv_info->itr_idx << 626 I40E_PFINT_AEQCTL_ITR_INDX_SHIFT)); 627 628 wr32(hw, I40E_PFINT_AEQCTL, reg); 629 } 630 } 631 /* Mitigate sync problems with iwarp VF driver */ 632 i40e_flush(hw); 633 return 0; 634err: 635 kfree(ldev->qvlist_info); 636 ldev->qvlist_info = NULL; 637 return -EINVAL; 638} 639 640/** 641 * i40e_client_request_reset 642 * @ldev: pointer to L2 context. 643 * @client: Client pointer. 644 * @reset_level: reset level 645 **/ 646static void i40e_client_request_reset(struct i40e_info *ldev, 647 struct i40e_client *client, 648 u32 reset_level) 649{ 650 struct i40e_pf *pf = ldev->pf; 651 652 switch (reset_level) { 653 case I40E_CLIENT_RESET_LEVEL_PF: 654 set_bit(__I40E_PF_RESET_REQUESTED, pf->state); 655 break; 656 case I40E_CLIENT_RESET_LEVEL_CORE: 657 set_bit(__I40E_PF_RESET_REQUESTED, pf->state); 658 break; 659 default: 660 dev_warn(&pf->pdev->dev, 661 "Client for PF id %d requested an unsupported reset: %d.\n", 662 pf->hw.pf_id, reset_level); 663 break; 664 } 665 666 i40e_service_event_schedule(pf); 667} 668 669/** 670 * i40e_client_update_vsi_ctxt 671 * @ldev: pointer to L2 context. 672 * @client: Client pointer. 673 * @is_vf: if this for the VF 674 * @vf_id: if is_vf true this carries the vf_id 675 * @flag: Any device level setting that needs to be done for PE 676 * @valid_flag: Bits in this match up and enable changing of flag bits 677 * 678 * Return 0 on success or < 0 on error 679 **/ 680static int i40e_client_update_vsi_ctxt(struct i40e_info *ldev, 681 struct i40e_client *client, 682 bool is_vf, u32 vf_id, 683 u32 flag, u32 valid_flag) 684{ 685 struct i40e_pf *pf = ldev->pf; 686 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi]; 687 struct i40e_vsi_context ctxt; 688 bool update = true; 689 i40e_status err; 690 691 /* TODO: for now do not allow setting VF's VSI setting */ 692 if (is_vf) 693 return -EINVAL; 694 695 ctxt.seid = pf->main_vsi_seid; 696 ctxt.pf_num = pf->hw.pf_id; 697 err = i40e_aq_get_vsi_params(&pf->hw, &ctxt, NULL); 698 ctxt.flags = I40E_AQ_VSI_TYPE_PF; 699 if (err) { 700 dev_info(&pf->pdev->dev, 701 "couldn't get PF vsi config, err %s aq_err %s\n", 702 i40e_stat_str(&pf->hw, err), 703 i40e_aq_str(&pf->hw, 704 pf->hw.aq.asq_last_status)); 705 return -ENOENT; 706 } 707 708 if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_ENABLE) && 709 (flag & I40E_CLIENT_VSI_FLAG_TCP_ENABLE)) { 710 ctxt.info.valid_sections = 711 cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID); 712 ctxt.info.queueing_opt_flags |= I40E_AQ_VSI_QUE_OPT_TCP_ENA; 713 } else if ((valid_flag & I40E_CLIENT_VSI_FLAG_TCP_ENABLE) && 714 !(flag & I40E_CLIENT_VSI_FLAG_TCP_ENABLE)) { 715 ctxt.info.valid_sections = 716 cpu_to_le16(I40E_AQ_VSI_PROP_QUEUE_OPT_VALID); 717 ctxt.info.queueing_opt_flags &= ~I40E_AQ_VSI_QUE_OPT_TCP_ENA; 718 } else { 719 update = false; 720 dev_warn(&pf->pdev->dev, 721 "Client for PF id %d request an unsupported Config: %x.\n", 722 pf->hw.pf_id, flag); 723 } 724 725 if (update) { 726 err = i40e_aq_update_vsi_params(&vsi->back->hw, &ctxt, NULL); 727 if (err) { 728 dev_info(&pf->pdev->dev, 729 "update VSI ctxt for PE failed, err %s aq_err %s\n", 730 i40e_stat_str(&pf->hw, err), 731 i40e_aq_str(&pf->hw, 732 pf->hw.aq.asq_last_status)); 733 } 734 } 735 return err; 736} 737 738/** 739 * i40e_register_client - Register a i40e client driver with the L2 driver 740 * @client: pointer to the i40e_client struct 741 * 742 * Returns 0 on success or non-0 on error 743 **/ 744int i40e_register_client(struct i40e_client *client) 745{ 746 int ret = 0; 747 748 if (!client) { 749 ret = -EIO; 750 goto out; 751 } 752 753 if (strlen(client->name) == 0) { 754 pr_info("i40e: Failed to register client with no name\n"); 755 ret = -EIO; 756 goto out; 757 } 758 759 if (registered_client) { 760 pr_info("i40e: Client %s has already been registered!\n", 761 client->name); 762 ret = -EEXIST; 763 goto out; 764 } 765 766 if ((client->version.major != I40E_CLIENT_VERSION_MAJOR) || 767 (client->version.minor != I40E_CLIENT_VERSION_MINOR)) { 768 pr_info("i40e: Failed to register client %s due to mismatched client interface version\n", 769 client->name); 770 pr_info("Client is using version: %02d.%02d.%02d while LAN driver supports %s\n", 771 client->version.major, client->version.minor, 772 client->version.build, 773 i40e_client_interface_version_str); 774 ret = -EIO; 775 goto out; 776 } 777 778 registered_client = client; 779 780 i40e_client_prepare(client); 781 782 pr_info("i40e: Registered client %s\n", client->name); 783out: 784 return ret; 785} 786EXPORT_SYMBOL(i40e_register_client); 787 788/** 789 * i40e_unregister_client - Unregister a i40e client driver with the L2 driver 790 * @client: pointer to the i40e_client struct 791 * 792 * Returns 0 on success or non-0 on error 793 **/ 794int i40e_unregister_client(struct i40e_client *client) 795{ 796 int ret = 0; 797 798 if (registered_client != client) { 799 pr_info("i40e: Client %s has not been registered\n", 800 client->name); 801 ret = -ENODEV; 802 goto out; 803 } 804 registered_client = NULL; 805 /* When a unregister request comes through we would have to send 806 * a close for each of the client instances that were opened. 807 * client_release function is called to handle this. 808 */ 809 i40e_client_release(client); 810 811 pr_info("i40e: Unregistered client %s\n", client->name); 812out: 813 return ret; 814} 815EXPORT_SYMBOL(i40e_unregister_client); 816