1// SPDX-License-Identifier: GPL-2.0 2/* Copyright(c) 2013 - 2018 Intel Corporation. */ 3 4#include "iavf.h" 5#include "iavf_prototype.h" 6 7/** 8 * iavf_send_pf_msg 9 * @adapter: adapter structure 10 * @op: virtual channel opcode 11 * @msg: pointer to message buffer 12 * @len: message length 13 * 14 * Send message to PF and print status if failure. 15 **/ 16static int iavf_send_pf_msg(struct iavf_adapter *adapter, 17 enum virtchnl_ops op, u8 *msg, u16 len) 18{ 19 struct iavf_hw *hw = &adapter->hw; 20 enum iavf_status status; 21 22 if (adapter->flags & IAVF_FLAG_PF_COMMS_FAILED) 23 return 0; /* nothing to see here, move along */ 24 25 status = iavf_aq_send_msg_to_pf(hw, op, 0, msg, len, NULL); 26 if (status) 27 dev_dbg(&adapter->pdev->dev, "Unable to send opcode %d to PF, status %s, aq_err %s\n", 28 op, iavf_stat_str(hw, status), 29 iavf_aq_str(hw, hw->aq.asq_last_status)); 30 return iavf_status_to_errno(status); 31} 32 33/** 34 * iavf_send_api_ver 35 * @adapter: adapter structure 36 * 37 * Send API version admin queue message to the PF. The reply is not checked 38 * in this function. Returns 0 if the message was successfully 39 * sent, or one of the IAVF_ADMIN_QUEUE_ERROR_ statuses if not. 40 **/ 41int iavf_send_api_ver(struct iavf_adapter *adapter) 42{ 43 struct virtchnl_version_info vvi; 44 45 vvi.major = VIRTCHNL_VERSION_MAJOR; 46 vvi.minor = VIRTCHNL_VERSION_MINOR; 47 48 return iavf_send_pf_msg(adapter, VIRTCHNL_OP_VERSION, (u8 *)&vvi, 49 sizeof(vvi)); 50} 51 52/** 53 * iavf_poll_virtchnl_msg 54 * @hw: HW configuration structure 55 * @event: event to populate on success 56 * @op_to_poll: requested virtchnl op to poll for 57 * 58 * Initialize poll for virtchnl msg matching the requested_op. Returns 0 59 * if a message of the correct opcode is in the queue or an error code 60 * if no message matching the op code is waiting and other failures. 61 */ 62static int 63iavf_poll_virtchnl_msg(struct iavf_hw *hw, struct iavf_arq_event_info *event, 64 enum virtchnl_ops op_to_poll) 65{ 66 enum virtchnl_ops received_op; 67 enum iavf_status status; 68 u32 v_retval; 69 70 while (1) { 71 /* When the AQ is empty, iavf_clean_arq_element will return 72 * nonzero and this loop will terminate. 73 */ 74 status = iavf_clean_arq_element(hw, event, NULL); 75 if (status != IAVF_SUCCESS) 76 return iavf_status_to_errno(status); 77 received_op = 78 (enum virtchnl_ops)le32_to_cpu(event->desc.cookie_high); 79 if (op_to_poll == received_op) 80 break; 81 } 82 83 v_retval = le32_to_cpu(event->desc.cookie_low); 84 return virtchnl_status_to_errno((enum virtchnl_status_code)v_retval); 85} 86 87/** 88 * iavf_verify_api_ver 89 * @adapter: adapter structure 90 * 91 * Compare API versions with the PF. Must be called after admin queue is 92 * initialized. Returns 0 if API versions match, -EIO if they do not, 93 * IAVF_ERR_ADMIN_QUEUE_NO_WORK if the admin queue is empty, and any errors 94 * from the firmware are propagated. 95 **/ 96int iavf_verify_api_ver(struct iavf_adapter *adapter) 97{ 98 struct iavf_arq_event_info event; 99 int err; 100 101 event.buf_len = IAVF_MAX_AQ_BUF_SIZE; 102 event.msg_buf = kzalloc(IAVF_MAX_AQ_BUF_SIZE, GFP_KERNEL); 103 if (!event.msg_buf) 104 return -ENOMEM; 105 106 err = iavf_poll_virtchnl_msg(&adapter->hw, &event, VIRTCHNL_OP_VERSION); 107 if (!err) { 108 struct virtchnl_version_info *pf_vvi = 109 (struct virtchnl_version_info *)event.msg_buf; 110 adapter->pf_version = *pf_vvi; 111 112 if (pf_vvi->major > VIRTCHNL_VERSION_MAJOR || 113 (pf_vvi->major == VIRTCHNL_VERSION_MAJOR && 114 pf_vvi->minor > VIRTCHNL_VERSION_MINOR)) 115 err = -EIO; 116 } 117 118 kfree(event.msg_buf); 119 120 return err; 121} 122 123/** 124 * iavf_send_vf_config_msg 125 * @adapter: adapter structure 126 * 127 * Send VF configuration request admin queue message to the PF. The reply 128 * is not checked in this function. Returns 0 if the message was 129 * successfully sent, or one of the IAVF_ADMIN_QUEUE_ERROR_ statuses if not. 130 **/ 131int iavf_send_vf_config_msg(struct iavf_adapter *adapter) 132{ 133 u32 caps; 134 135 caps = VIRTCHNL_VF_OFFLOAD_L2 | 136 VIRTCHNL_VF_OFFLOAD_RSS_PF | 137 VIRTCHNL_VF_OFFLOAD_RSS_AQ | 138 VIRTCHNL_VF_OFFLOAD_RSS_REG | 139 VIRTCHNL_VF_OFFLOAD_VLAN | 140 VIRTCHNL_VF_OFFLOAD_WB_ON_ITR | 141 VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 | 142 VIRTCHNL_VF_OFFLOAD_ENCAP | 143 VIRTCHNL_VF_OFFLOAD_VLAN_V2 | 144 VIRTCHNL_VF_OFFLOAD_CRC | 145 VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM | 146 VIRTCHNL_VF_OFFLOAD_REQ_QUEUES | 147 VIRTCHNL_VF_OFFLOAD_ADQ | 148 VIRTCHNL_VF_OFFLOAD_USO | 149 VIRTCHNL_VF_OFFLOAD_FDIR_PF | 150 VIRTCHNL_VF_OFFLOAD_ADV_RSS_PF | 151 VIRTCHNL_VF_CAP_ADV_LINK_SPEED; 152 153 adapter->current_op = VIRTCHNL_OP_GET_VF_RESOURCES; 154 adapter->aq_required &= ~IAVF_FLAG_AQ_GET_CONFIG; 155 if (PF_IS_V11(adapter)) 156 return iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_VF_RESOURCES, 157 (u8 *)&caps, sizeof(caps)); 158 else 159 return iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_VF_RESOURCES, 160 NULL, 0); 161} 162 163int iavf_send_vf_offload_vlan_v2_msg(struct iavf_adapter *adapter) 164{ 165 adapter->aq_required &= ~IAVF_FLAG_AQ_GET_OFFLOAD_VLAN_V2_CAPS; 166 167 if (!VLAN_V2_ALLOWED(adapter)) 168 return -EOPNOTSUPP; 169 170 adapter->current_op = VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS; 171 172 return iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS, 173 NULL, 0); 174} 175 176/** 177 * iavf_validate_num_queues 178 * @adapter: adapter structure 179 * 180 * Validate that the number of queues the PF has sent in 181 * VIRTCHNL_OP_GET_VF_RESOURCES is not larger than the VF can handle. 182 **/ 183static void iavf_validate_num_queues(struct iavf_adapter *adapter) 184{ 185 if (adapter->vf_res->num_queue_pairs > IAVF_MAX_REQ_QUEUES) { 186 struct virtchnl_vsi_resource *vsi_res; 187 int i; 188 189 dev_info(&adapter->pdev->dev, "Received %d queues, but can only have a max of %d\n", 190 adapter->vf_res->num_queue_pairs, 191 IAVF_MAX_REQ_QUEUES); 192 dev_info(&adapter->pdev->dev, "Fixing by reducing queues to %d\n", 193 IAVF_MAX_REQ_QUEUES); 194 adapter->vf_res->num_queue_pairs = IAVF_MAX_REQ_QUEUES; 195 for (i = 0; i < adapter->vf_res->num_vsis; i++) { 196 vsi_res = &adapter->vf_res->vsi_res[i]; 197 vsi_res->num_queue_pairs = IAVF_MAX_REQ_QUEUES; 198 } 199 } 200} 201 202/** 203 * iavf_get_vf_config 204 * @adapter: private adapter structure 205 * 206 * Get VF configuration from PF and populate hw structure. Must be called after 207 * admin queue is initialized. Busy waits until response is received from PF, 208 * with maximum timeout. Response from PF is returned in the buffer for further 209 * processing by the caller. 210 **/ 211int iavf_get_vf_config(struct iavf_adapter *adapter) 212{ 213 struct iavf_hw *hw = &adapter->hw; 214 struct iavf_arq_event_info event; 215 u16 len; 216 int err; 217 218 len = IAVF_VIRTCHNL_VF_RESOURCE_SIZE; 219 event.buf_len = len; 220 event.msg_buf = kzalloc(len, GFP_KERNEL); 221 if (!event.msg_buf) 222 return -ENOMEM; 223 224 err = iavf_poll_virtchnl_msg(hw, &event, VIRTCHNL_OP_GET_VF_RESOURCES); 225 memcpy(adapter->vf_res, event.msg_buf, min(event.msg_len, len)); 226 227 /* some PFs send more queues than we should have so validate that 228 * we aren't getting too many queues 229 */ 230 if (!err) 231 iavf_validate_num_queues(adapter); 232 iavf_vf_parse_hw_config(hw, adapter->vf_res); 233 234 kfree(event.msg_buf); 235 236 return err; 237} 238 239int iavf_get_vf_vlan_v2_caps(struct iavf_adapter *adapter) 240{ 241 struct iavf_arq_event_info event; 242 int err; 243 u16 len; 244 245 len = sizeof(struct virtchnl_vlan_caps); 246 event.buf_len = len; 247 event.msg_buf = kzalloc(len, GFP_KERNEL); 248 if (!event.msg_buf) 249 return -ENOMEM; 250 251 err = iavf_poll_virtchnl_msg(&adapter->hw, &event, 252 VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS); 253 if (!err) 254 memcpy(&adapter->vlan_v2_caps, event.msg_buf, 255 min(event.msg_len, len)); 256 257 kfree(event.msg_buf); 258 259 return err; 260} 261 262/** 263 * iavf_configure_queues 264 * @adapter: adapter structure 265 * 266 * Request that the PF set up our (previously allocated) queues. 267 **/ 268void iavf_configure_queues(struct iavf_adapter *adapter) 269{ 270 struct virtchnl_vsi_queue_config_info *vqci; 271 int i, max_frame = adapter->vf_res->max_mtu; 272 int pairs = adapter->num_active_queues; 273 struct virtchnl_queue_pair_info *vqpi; 274 size_t len; 275 276 if (max_frame > IAVF_MAX_RXBUFFER || !max_frame) 277 max_frame = IAVF_MAX_RXBUFFER; 278 279 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 280 /* bail because we already have a command pending */ 281 dev_err(&adapter->pdev->dev, "Cannot configure queues, command %d pending\n", 282 adapter->current_op); 283 return; 284 } 285 adapter->current_op = VIRTCHNL_OP_CONFIG_VSI_QUEUES; 286 len = virtchnl_struct_size(vqci, qpair, pairs); 287 vqci = kzalloc(len, GFP_KERNEL); 288 if (!vqci) 289 return; 290 291 /* Limit maximum frame size when jumbo frames is not enabled */ 292 if (!(adapter->flags & IAVF_FLAG_LEGACY_RX) && 293 (adapter->netdev->mtu <= ETH_DATA_LEN)) 294 max_frame = IAVF_RXBUFFER_1536 - NET_IP_ALIGN; 295 296 vqci->vsi_id = adapter->vsi_res->vsi_id; 297 vqci->num_queue_pairs = pairs; 298 vqpi = vqci->qpair; 299 /* Size check is not needed here - HW max is 16 queue pairs, and we 300 * can fit info for 31 of them into the AQ buffer before it overflows. 301 */ 302 for (i = 0; i < pairs; i++) { 303 vqpi->txq.vsi_id = vqci->vsi_id; 304 vqpi->txq.queue_id = i; 305 vqpi->txq.ring_len = adapter->tx_rings[i].count; 306 vqpi->txq.dma_ring_addr = adapter->tx_rings[i].dma; 307 vqpi->rxq.vsi_id = vqci->vsi_id; 308 vqpi->rxq.queue_id = i; 309 vqpi->rxq.ring_len = adapter->rx_rings[i].count; 310 vqpi->rxq.dma_ring_addr = adapter->rx_rings[i].dma; 311 vqpi->rxq.max_pkt_size = max_frame; 312 vqpi->rxq.databuffer_size = 313 ALIGN(adapter->rx_rings[i].rx_buf_len, 314 BIT_ULL(IAVF_RXQ_CTX_DBUFF_SHIFT)); 315 if (CRC_OFFLOAD_ALLOWED(adapter)) 316 vqpi->rxq.crc_disable = !!(adapter->netdev->features & 317 NETIF_F_RXFCS); 318 vqpi++; 319 } 320 321 adapter->aq_required &= ~IAVF_FLAG_AQ_CONFIGURE_QUEUES; 322 iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_VSI_QUEUES, 323 (u8 *)vqci, len); 324 kfree(vqci); 325} 326 327/** 328 * iavf_enable_queues 329 * @adapter: adapter structure 330 * 331 * Request that the PF enable all of our queues. 332 **/ 333void iavf_enable_queues(struct iavf_adapter *adapter) 334{ 335 struct virtchnl_queue_select vqs; 336 337 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 338 /* bail because we already have a command pending */ 339 dev_err(&adapter->pdev->dev, "Cannot enable queues, command %d pending\n", 340 adapter->current_op); 341 return; 342 } 343 adapter->current_op = VIRTCHNL_OP_ENABLE_QUEUES; 344 vqs.vsi_id = adapter->vsi_res->vsi_id; 345 vqs.tx_queues = BIT(adapter->num_active_queues) - 1; 346 vqs.rx_queues = vqs.tx_queues; 347 adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_QUEUES; 348 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_QUEUES, 349 (u8 *)&vqs, sizeof(vqs)); 350} 351 352/** 353 * iavf_disable_queues 354 * @adapter: adapter structure 355 * 356 * Request that the PF disable all of our queues. 357 **/ 358void iavf_disable_queues(struct iavf_adapter *adapter) 359{ 360 struct virtchnl_queue_select vqs; 361 362 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 363 /* bail because we already have a command pending */ 364 dev_err(&adapter->pdev->dev, "Cannot disable queues, command %d pending\n", 365 adapter->current_op); 366 return; 367 } 368 adapter->current_op = VIRTCHNL_OP_DISABLE_QUEUES; 369 vqs.vsi_id = adapter->vsi_res->vsi_id; 370 vqs.tx_queues = BIT(adapter->num_active_queues) - 1; 371 vqs.rx_queues = vqs.tx_queues; 372 adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_QUEUES; 373 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_QUEUES, 374 (u8 *)&vqs, sizeof(vqs)); 375} 376 377/** 378 * iavf_map_queues 379 * @adapter: adapter structure 380 * 381 * Request that the PF map queues to interrupt vectors. Misc causes, including 382 * admin queue, are always mapped to vector 0. 383 **/ 384void iavf_map_queues(struct iavf_adapter *adapter) 385{ 386 struct virtchnl_irq_map_info *vimi; 387 struct virtchnl_vector_map *vecmap; 388 struct iavf_q_vector *q_vector; 389 int v_idx, q_vectors; 390 size_t len; 391 392 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 393 /* bail because we already have a command pending */ 394 dev_err(&adapter->pdev->dev, "Cannot map queues to vectors, command %d pending\n", 395 adapter->current_op); 396 return; 397 } 398 adapter->current_op = VIRTCHNL_OP_CONFIG_IRQ_MAP; 399 400 q_vectors = adapter->num_msix_vectors - NONQ_VECS; 401 402 len = virtchnl_struct_size(vimi, vecmap, adapter->num_msix_vectors); 403 vimi = kzalloc(len, GFP_KERNEL); 404 if (!vimi) 405 return; 406 407 vimi->num_vectors = adapter->num_msix_vectors; 408 /* Queue vectors first */ 409 for (v_idx = 0; v_idx < q_vectors; v_idx++) { 410 q_vector = &adapter->q_vectors[v_idx]; 411 vecmap = &vimi->vecmap[v_idx]; 412 413 vecmap->vsi_id = adapter->vsi_res->vsi_id; 414 vecmap->vector_id = v_idx + NONQ_VECS; 415 vecmap->txq_map = q_vector->ring_mask; 416 vecmap->rxq_map = q_vector->ring_mask; 417 vecmap->rxitr_idx = IAVF_RX_ITR; 418 vecmap->txitr_idx = IAVF_TX_ITR; 419 } 420 /* Misc vector last - this is only for AdminQ messages */ 421 vecmap = &vimi->vecmap[v_idx]; 422 vecmap->vsi_id = adapter->vsi_res->vsi_id; 423 vecmap->vector_id = 0; 424 vecmap->txq_map = 0; 425 vecmap->rxq_map = 0; 426 427 adapter->aq_required &= ~IAVF_FLAG_AQ_MAP_VECTORS; 428 iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_IRQ_MAP, 429 (u8 *)vimi, len); 430 kfree(vimi); 431} 432 433/** 434 * iavf_set_mac_addr_type - Set the correct request type from the filter type 435 * @virtchnl_ether_addr: pointer to requested list element 436 * @filter: pointer to requested filter 437 **/ 438static void 439iavf_set_mac_addr_type(struct virtchnl_ether_addr *virtchnl_ether_addr, 440 const struct iavf_mac_filter *filter) 441{ 442 virtchnl_ether_addr->type = filter->is_primary ? 443 VIRTCHNL_ETHER_ADDR_PRIMARY : 444 VIRTCHNL_ETHER_ADDR_EXTRA; 445} 446 447/** 448 * iavf_add_ether_addrs 449 * @adapter: adapter structure 450 * 451 * Request that the PF add one or more addresses to our filters. 452 **/ 453void iavf_add_ether_addrs(struct iavf_adapter *adapter) 454{ 455 struct virtchnl_ether_addr_list *veal; 456 struct iavf_mac_filter *f; 457 int i = 0, count = 0; 458 bool more = false; 459 size_t len; 460 461 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 462 /* bail because we already have a command pending */ 463 dev_err(&adapter->pdev->dev, "Cannot add filters, command %d pending\n", 464 adapter->current_op); 465 return; 466 } 467 468 spin_lock_bh(&adapter->mac_vlan_list_lock); 469 470 list_for_each_entry(f, &adapter->mac_filter_list, list) { 471 if (f->add) 472 count++; 473 } 474 if (!count) { 475 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_MAC_FILTER; 476 spin_unlock_bh(&adapter->mac_vlan_list_lock); 477 return; 478 } 479 adapter->current_op = VIRTCHNL_OP_ADD_ETH_ADDR; 480 481 len = virtchnl_struct_size(veal, list, count); 482 if (len > IAVF_MAX_AQ_BUF_SIZE) { 483 dev_warn(&adapter->pdev->dev, "Too many add MAC changes in one request\n"); 484 while (len > IAVF_MAX_AQ_BUF_SIZE) 485 len = virtchnl_struct_size(veal, list, --count); 486 more = true; 487 } 488 489 veal = kzalloc(len, GFP_ATOMIC); 490 if (!veal) { 491 spin_unlock_bh(&adapter->mac_vlan_list_lock); 492 return; 493 } 494 495 veal->vsi_id = adapter->vsi_res->vsi_id; 496 veal->num_elements = count; 497 list_for_each_entry(f, &adapter->mac_filter_list, list) { 498 if (f->add) { 499 ether_addr_copy(veal->list[i].addr, f->macaddr); 500 iavf_set_mac_addr_type(&veal->list[i], f); 501 i++; 502 f->add = false; 503 if (i == count) 504 break; 505 } 506 } 507 if (!more) 508 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_MAC_FILTER; 509 510 spin_unlock_bh(&adapter->mac_vlan_list_lock); 511 512 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_ETH_ADDR, (u8 *)veal, len); 513 kfree(veal); 514} 515 516/** 517 * iavf_del_ether_addrs 518 * @adapter: adapter structure 519 * 520 * Request that the PF remove one or more addresses from our filters. 521 **/ 522void iavf_del_ether_addrs(struct iavf_adapter *adapter) 523{ 524 struct virtchnl_ether_addr_list *veal; 525 struct iavf_mac_filter *f, *ftmp; 526 int i = 0, count = 0; 527 bool more = false; 528 size_t len; 529 530 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 531 /* bail because we already have a command pending */ 532 dev_err(&adapter->pdev->dev, "Cannot remove filters, command %d pending\n", 533 adapter->current_op); 534 return; 535 } 536 537 spin_lock_bh(&adapter->mac_vlan_list_lock); 538 539 list_for_each_entry(f, &adapter->mac_filter_list, list) { 540 if (f->remove) 541 count++; 542 } 543 if (!count) { 544 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_MAC_FILTER; 545 spin_unlock_bh(&adapter->mac_vlan_list_lock); 546 return; 547 } 548 adapter->current_op = VIRTCHNL_OP_DEL_ETH_ADDR; 549 550 len = virtchnl_struct_size(veal, list, count); 551 if (len > IAVF_MAX_AQ_BUF_SIZE) { 552 dev_warn(&adapter->pdev->dev, "Too many delete MAC changes in one request\n"); 553 while (len > IAVF_MAX_AQ_BUF_SIZE) 554 len = virtchnl_struct_size(veal, list, --count); 555 more = true; 556 } 557 veal = kzalloc(len, GFP_ATOMIC); 558 if (!veal) { 559 spin_unlock_bh(&adapter->mac_vlan_list_lock); 560 return; 561 } 562 563 veal->vsi_id = adapter->vsi_res->vsi_id; 564 veal->num_elements = count; 565 list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) { 566 if (f->remove) { 567 ether_addr_copy(veal->list[i].addr, f->macaddr); 568 iavf_set_mac_addr_type(&veal->list[i], f); 569 i++; 570 list_del(&f->list); 571 kfree(f); 572 if (i == count) 573 break; 574 } 575 } 576 if (!more) 577 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_MAC_FILTER; 578 579 spin_unlock_bh(&adapter->mac_vlan_list_lock); 580 581 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_ETH_ADDR, (u8 *)veal, len); 582 kfree(veal); 583} 584 585/** 586 * iavf_mac_add_ok 587 * @adapter: adapter structure 588 * 589 * Submit list of filters based on PF response. 590 **/ 591static void iavf_mac_add_ok(struct iavf_adapter *adapter) 592{ 593 struct iavf_mac_filter *f, *ftmp; 594 595 spin_lock_bh(&adapter->mac_vlan_list_lock); 596 list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) { 597 f->is_new_mac = false; 598 if (!f->add && !f->add_handled) 599 f->add_handled = true; 600 } 601 spin_unlock_bh(&adapter->mac_vlan_list_lock); 602} 603 604/** 605 * iavf_mac_add_reject 606 * @adapter: adapter structure 607 * 608 * Remove filters from list based on PF response. 609 **/ 610static void iavf_mac_add_reject(struct iavf_adapter *adapter) 611{ 612 struct net_device *netdev = adapter->netdev; 613 struct iavf_mac_filter *f, *ftmp; 614 615 spin_lock_bh(&adapter->mac_vlan_list_lock); 616 list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) { 617 if (f->remove && ether_addr_equal(f->macaddr, netdev->dev_addr)) 618 f->remove = false; 619 620 if (!f->add && !f->add_handled) 621 f->add_handled = true; 622 623 if (f->is_new_mac) { 624 list_del(&f->list); 625 kfree(f); 626 } 627 } 628 spin_unlock_bh(&adapter->mac_vlan_list_lock); 629} 630 631/** 632 * iavf_vlan_add_reject 633 * @adapter: adapter structure 634 * 635 * Remove VLAN filters from list based on PF response. 636 **/ 637static void iavf_vlan_add_reject(struct iavf_adapter *adapter) 638{ 639 struct iavf_vlan_filter *f, *ftmp; 640 641 spin_lock_bh(&adapter->mac_vlan_list_lock); 642 list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) { 643 if (f->state == IAVF_VLAN_IS_NEW) { 644 list_del(&f->list); 645 kfree(f); 646 adapter->num_vlan_filters--; 647 } 648 } 649 spin_unlock_bh(&adapter->mac_vlan_list_lock); 650} 651 652/** 653 * iavf_add_vlans 654 * @adapter: adapter structure 655 * 656 * Request that the PF add one or more VLAN filters to our VSI. 657 **/ 658void iavf_add_vlans(struct iavf_adapter *adapter) 659{ 660 int len, i = 0, count = 0; 661 struct iavf_vlan_filter *f; 662 bool more = false; 663 664 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 665 /* bail because we already have a command pending */ 666 dev_err(&adapter->pdev->dev, "Cannot add VLANs, command %d pending\n", 667 adapter->current_op); 668 return; 669 } 670 671 spin_lock_bh(&adapter->mac_vlan_list_lock); 672 673 list_for_each_entry(f, &adapter->vlan_filter_list, list) { 674 if (f->state == IAVF_VLAN_ADD) 675 count++; 676 } 677 if (!count || !VLAN_FILTERING_ALLOWED(adapter)) { 678 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_VLAN_FILTER; 679 spin_unlock_bh(&adapter->mac_vlan_list_lock); 680 return; 681 } 682 683 if (VLAN_ALLOWED(adapter)) { 684 struct virtchnl_vlan_filter_list *vvfl; 685 686 adapter->current_op = VIRTCHNL_OP_ADD_VLAN; 687 688 len = virtchnl_struct_size(vvfl, vlan_id, count); 689 if (len > IAVF_MAX_AQ_BUF_SIZE) { 690 dev_warn(&adapter->pdev->dev, "Too many add VLAN changes in one request\n"); 691 while (len > IAVF_MAX_AQ_BUF_SIZE) 692 len = virtchnl_struct_size(vvfl, vlan_id, 693 --count); 694 more = true; 695 } 696 vvfl = kzalloc(len, GFP_ATOMIC); 697 if (!vvfl) { 698 spin_unlock_bh(&adapter->mac_vlan_list_lock); 699 return; 700 } 701 702 vvfl->vsi_id = adapter->vsi_res->vsi_id; 703 vvfl->num_elements = count; 704 list_for_each_entry(f, &adapter->vlan_filter_list, list) { 705 if (f->state == IAVF_VLAN_ADD) { 706 vvfl->vlan_id[i] = f->vlan.vid; 707 i++; 708 f->state = IAVF_VLAN_IS_NEW; 709 if (i == count) 710 break; 711 } 712 } 713 if (!more) 714 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_VLAN_FILTER; 715 716 spin_unlock_bh(&adapter->mac_vlan_list_lock); 717 718 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_VLAN, (u8 *)vvfl, len); 719 kfree(vvfl); 720 } else { 721 u16 max_vlans = adapter->vlan_v2_caps.filtering.max_filters; 722 u16 current_vlans = iavf_get_num_vlans_added(adapter); 723 struct virtchnl_vlan_filter_list_v2 *vvfl_v2; 724 725 adapter->current_op = VIRTCHNL_OP_ADD_VLAN_V2; 726 727 if ((count + current_vlans) > max_vlans && 728 current_vlans < max_vlans) { 729 count = max_vlans - iavf_get_num_vlans_added(adapter); 730 more = true; 731 } 732 733 len = virtchnl_struct_size(vvfl_v2, filters, count); 734 if (len > IAVF_MAX_AQ_BUF_SIZE) { 735 dev_warn(&adapter->pdev->dev, "Too many add VLAN changes in one request\n"); 736 while (len > IAVF_MAX_AQ_BUF_SIZE) 737 len = virtchnl_struct_size(vvfl_v2, filters, 738 --count); 739 more = true; 740 } 741 742 vvfl_v2 = kzalloc(len, GFP_ATOMIC); 743 if (!vvfl_v2) { 744 spin_unlock_bh(&adapter->mac_vlan_list_lock); 745 return; 746 } 747 748 vvfl_v2->vport_id = adapter->vsi_res->vsi_id; 749 vvfl_v2->num_elements = count; 750 list_for_each_entry(f, &adapter->vlan_filter_list, list) { 751 if (f->state == IAVF_VLAN_ADD) { 752 struct virtchnl_vlan_supported_caps *filtering_support = 753 &adapter->vlan_v2_caps.filtering.filtering_support; 754 struct virtchnl_vlan *vlan; 755 756 if (i == count) 757 break; 758 759 /* give priority over outer if it's enabled */ 760 if (filtering_support->outer) 761 vlan = &vvfl_v2->filters[i].outer; 762 else 763 vlan = &vvfl_v2->filters[i].inner; 764 765 vlan->tci = f->vlan.vid; 766 vlan->tpid = f->vlan.tpid; 767 768 i++; 769 f->state = IAVF_VLAN_IS_NEW; 770 } 771 } 772 773 if (!more) 774 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_VLAN_FILTER; 775 776 spin_unlock_bh(&adapter->mac_vlan_list_lock); 777 778 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_VLAN_V2, 779 (u8 *)vvfl_v2, len); 780 kfree(vvfl_v2); 781 } 782} 783 784/** 785 * iavf_del_vlans 786 * @adapter: adapter structure 787 * 788 * Request that the PF remove one or more VLAN filters from our VSI. 789 **/ 790void iavf_del_vlans(struct iavf_adapter *adapter) 791{ 792 struct iavf_vlan_filter *f, *ftmp; 793 int len, i = 0, count = 0; 794 bool more = false; 795 796 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 797 /* bail because we already have a command pending */ 798 dev_err(&adapter->pdev->dev, "Cannot remove VLANs, command %d pending\n", 799 adapter->current_op); 800 return; 801 } 802 803 spin_lock_bh(&adapter->mac_vlan_list_lock); 804 805 list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) { 806 /* since VLAN capabilities are not allowed, we dont want to send 807 * a VLAN delete request because it will most likely fail and 808 * create unnecessary errors/noise, so just free the VLAN 809 * filters marked for removal to enable bailing out before 810 * sending a virtchnl message 811 */ 812 if (f->state == IAVF_VLAN_REMOVE && 813 !VLAN_FILTERING_ALLOWED(adapter)) { 814 list_del(&f->list); 815 kfree(f); 816 adapter->num_vlan_filters--; 817 } else if (f->state == IAVF_VLAN_DISABLE && 818 !VLAN_FILTERING_ALLOWED(adapter)) { 819 f->state = IAVF_VLAN_INACTIVE; 820 } else if (f->state == IAVF_VLAN_REMOVE || 821 f->state == IAVF_VLAN_DISABLE) { 822 count++; 823 } 824 } 825 if (!count || !VLAN_FILTERING_ALLOWED(adapter)) { 826 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_VLAN_FILTER; 827 spin_unlock_bh(&adapter->mac_vlan_list_lock); 828 return; 829 } 830 831 if (VLAN_ALLOWED(adapter)) { 832 struct virtchnl_vlan_filter_list *vvfl; 833 834 adapter->current_op = VIRTCHNL_OP_DEL_VLAN; 835 836 len = virtchnl_struct_size(vvfl, vlan_id, count); 837 if (len > IAVF_MAX_AQ_BUF_SIZE) { 838 dev_warn(&adapter->pdev->dev, "Too many delete VLAN changes in one request\n"); 839 while (len > IAVF_MAX_AQ_BUF_SIZE) 840 len = virtchnl_struct_size(vvfl, vlan_id, 841 --count); 842 more = true; 843 } 844 vvfl = kzalloc(len, GFP_ATOMIC); 845 if (!vvfl) { 846 spin_unlock_bh(&adapter->mac_vlan_list_lock); 847 return; 848 } 849 850 vvfl->vsi_id = adapter->vsi_res->vsi_id; 851 vvfl->num_elements = count; 852 list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) { 853 if (f->state == IAVF_VLAN_DISABLE) { 854 vvfl->vlan_id[i] = f->vlan.vid; 855 f->state = IAVF_VLAN_INACTIVE; 856 i++; 857 if (i == count) 858 break; 859 } else if (f->state == IAVF_VLAN_REMOVE) { 860 vvfl->vlan_id[i] = f->vlan.vid; 861 list_del(&f->list); 862 kfree(f); 863 adapter->num_vlan_filters--; 864 i++; 865 if (i == count) 866 break; 867 } 868 } 869 870 if (!more) 871 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_VLAN_FILTER; 872 873 spin_unlock_bh(&adapter->mac_vlan_list_lock); 874 875 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_VLAN, (u8 *)vvfl, len); 876 kfree(vvfl); 877 } else { 878 struct virtchnl_vlan_filter_list_v2 *vvfl_v2; 879 880 adapter->current_op = VIRTCHNL_OP_DEL_VLAN_V2; 881 882 len = virtchnl_struct_size(vvfl_v2, filters, count); 883 if (len > IAVF_MAX_AQ_BUF_SIZE) { 884 dev_warn(&adapter->pdev->dev, "Too many add VLAN changes in one request\n"); 885 while (len > IAVF_MAX_AQ_BUF_SIZE) 886 len = virtchnl_struct_size(vvfl_v2, filters, 887 --count); 888 more = true; 889 } 890 891 vvfl_v2 = kzalloc(len, GFP_ATOMIC); 892 if (!vvfl_v2) { 893 spin_unlock_bh(&adapter->mac_vlan_list_lock); 894 return; 895 } 896 897 vvfl_v2->vport_id = adapter->vsi_res->vsi_id; 898 vvfl_v2->num_elements = count; 899 list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) { 900 if (f->state == IAVF_VLAN_DISABLE || 901 f->state == IAVF_VLAN_REMOVE) { 902 struct virtchnl_vlan_supported_caps *filtering_support = 903 &adapter->vlan_v2_caps.filtering.filtering_support; 904 struct virtchnl_vlan *vlan; 905 906 /* give priority over outer if it's enabled */ 907 if (filtering_support->outer) 908 vlan = &vvfl_v2->filters[i].outer; 909 else 910 vlan = &vvfl_v2->filters[i].inner; 911 912 vlan->tci = f->vlan.vid; 913 vlan->tpid = f->vlan.tpid; 914 915 if (f->state == IAVF_VLAN_DISABLE) { 916 f->state = IAVF_VLAN_INACTIVE; 917 } else { 918 list_del(&f->list); 919 kfree(f); 920 adapter->num_vlan_filters--; 921 } 922 i++; 923 if (i == count) 924 break; 925 } 926 } 927 928 if (!more) 929 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_VLAN_FILTER; 930 931 spin_unlock_bh(&adapter->mac_vlan_list_lock); 932 933 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_VLAN_V2, 934 (u8 *)vvfl_v2, len); 935 kfree(vvfl_v2); 936 } 937} 938 939/** 940 * iavf_set_promiscuous 941 * @adapter: adapter structure 942 * 943 * Request that the PF enable promiscuous mode for our VSI. 944 **/ 945void iavf_set_promiscuous(struct iavf_adapter *adapter) 946{ 947 struct net_device *netdev = adapter->netdev; 948 struct virtchnl_promisc_info vpi; 949 unsigned int flags; 950 951 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 952 /* bail because we already have a command pending */ 953 dev_err(&adapter->pdev->dev, "Cannot set promiscuous mode, command %d pending\n", 954 adapter->current_op); 955 return; 956 } 957 958 /* prevent changes to promiscuous flags */ 959 spin_lock_bh(&adapter->current_netdev_promisc_flags_lock); 960 961 /* sanity check to prevent duplicate AQ calls */ 962 if (!iavf_promiscuous_mode_changed(adapter)) { 963 adapter->aq_required &= ~IAVF_FLAG_AQ_CONFIGURE_PROMISC_MODE; 964 dev_dbg(&adapter->pdev->dev, "No change in promiscuous mode\n"); 965 /* allow changes to promiscuous flags */ 966 spin_unlock_bh(&adapter->current_netdev_promisc_flags_lock); 967 return; 968 } 969 970 /* there are 2 bits, but only 3 states */ 971 if (!(netdev->flags & IFF_PROMISC) && 972 netdev->flags & IFF_ALLMULTI) { 973 /* State 1 - only multicast promiscuous mode enabled 974 * - !IFF_PROMISC && IFF_ALLMULTI 975 */ 976 flags = FLAG_VF_MULTICAST_PROMISC; 977 adapter->current_netdev_promisc_flags |= IFF_ALLMULTI; 978 adapter->current_netdev_promisc_flags &= ~IFF_PROMISC; 979 dev_info(&adapter->pdev->dev, "Entering multicast promiscuous mode\n"); 980 } else if (!(netdev->flags & IFF_PROMISC) && 981 !(netdev->flags & IFF_ALLMULTI)) { 982 /* State 2 - unicast/multicast promiscuous mode disabled 983 * - !IFF_PROMISC && !IFF_ALLMULTI 984 */ 985 flags = 0; 986 adapter->current_netdev_promisc_flags &= 987 ~(IFF_PROMISC | IFF_ALLMULTI); 988 dev_info(&adapter->pdev->dev, "Leaving promiscuous mode\n"); 989 } else { 990 /* State 3 - unicast/multicast promiscuous mode enabled 991 * - IFF_PROMISC && IFF_ALLMULTI 992 * - IFF_PROMISC && !IFF_ALLMULTI 993 */ 994 flags = FLAG_VF_UNICAST_PROMISC | FLAG_VF_MULTICAST_PROMISC; 995 adapter->current_netdev_promisc_flags |= IFF_PROMISC; 996 if (netdev->flags & IFF_ALLMULTI) 997 adapter->current_netdev_promisc_flags |= IFF_ALLMULTI; 998 else 999 adapter->current_netdev_promisc_flags &= ~IFF_ALLMULTI; 1000 1001 dev_info(&adapter->pdev->dev, "Entering promiscuous mode\n"); 1002 } 1003 1004 adapter->aq_required &= ~IAVF_FLAG_AQ_CONFIGURE_PROMISC_MODE; 1005 1006 /* allow changes to promiscuous flags */ 1007 spin_unlock_bh(&adapter->current_netdev_promisc_flags_lock); 1008 1009 adapter->current_op = VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE; 1010 vpi.vsi_id = adapter->vsi_res->vsi_id; 1011 vpi.flags = flags; 1012 iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE, 1013 (u8 *)&vpi, sizeof(vpi)); 1014} 1015 1016/** 1017 * iavf_request_stats 1018 * @adapter: adapter structure 1019 * 1020 * Request VSI statistics from PF. 1021 **/ 1022void iavf_request_stats(struct iavf_adapter *adapter) 1023{ 1024 struct virtchnl_queue_select vqs; 1025 1026 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1027 /* no error message, this isn't crucial */ 1028 return; 1029 } 1030 1031 adapter->aq_required &= ~IAVF_FLAG_AQ_REQUEST_STATS; 1032 adapter->current_op = VIRTCHNL_OP_GET_STATS; 1033 vqs.vsi_id = adapter->vsi_res->vsi_id; 1034 /* queue maps are ignored for this message - only the vsi is used */ 1035 if (iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_STATS, (u8 *)&vqs, 1036 sizeof(vqs))) 1037 /* if the request failed, don't lock out others */ 1038 adapter->current_op = VIRTCHNL_OP_UNKNOWN; 1039} 1040 1041/** 1042 * iavf_get_hena 1043 * @adapter: adapter structure 1044 * 1045 * Request hash enable capabilities from PF 1046 **/ 1047void iavf_get_hena(struct iavf_adapter *adapter) 1048{ 1049 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1050 /* bail because we already have a command pending */ 1051 dev_err(&adapter->pdev->dev, "Cannot get RSS hash capabilities, command %d pending\n", 1052 adapter->current_op); 1053 return; 1054 } 1055 adapter->current_op = VIRTCHNL_OP_GET_RSS_HENA_CAPS; 1056 adapter->aq_required &= ~IAVF_FLAG_AQ_GET_HENA; 1057 iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_RSS_HENA_CAPS, NULL, 0); 1058} 1059 1060/** 1061 * iavf_set_hena 1062 * @adapter: adapter structure 1063 * 1064 * Request the PF to set our RSS hash capabilities 1065 **/ 1066void iavf_set_hena(struct iavf_adapter *adapter) 1067{ 1068 struct virtchnl_rss_hena vrh; 1069 1070 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1071 /* bail because we already have a command pending */ 1072 dev_err(&adapter->pdev->dev, "Cannot set RSS hash enable, command %d pending\n", 1073 adapter->current_op); 1074 return; 1075 } 1076 vrh.hena = adapter->hena; 1077 adapter->current_op = VIRTCHNL_OP_SET_RSS_HENA; 1078 adapter->aq_required &= ~IAVF_FLAG_AQ_SET_HENA; 1079 iavf_send_pf_msg(adapter, VIRTCHNL_OP_SET_RSS_HENA, (u8 *)&vrh, 1080 sizeof(vrh)); 1081} 1082 1083/** 1084 * iavf_set_rss_key 1085 * @adapter: adapter structure 1086 * 1087 * Request the PF to set our RSS hash key 1088 **/ 1089void iavf_set_rss_key(struct iavf_adapter *adapter) 1090{ 1091 struct virtchnl_rss_key *vrk; 1092 int len; 1093 1094 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1095 /* bail because we already have a command pending */ 1096 dev_err(&adapter->pdev->dev, "Cannot set RSS key, command %d pending\n", 1097 adapter->current_op); 1098 return; 1099 } 1100 len = virtchnl_struct_size(vrk, key, adapter->rss_key_size); 1101 vrk = kzalloc(len, GFP_KERNEL); 1102 if (!vrk) 1103 return; 1104 vrk->vsi_id = adapter->vsi.id; 1105 vrk->key_len = adapter->rss_key_size; 1106 memcpy(vrk->key, adapter->rss_key, adapter->rss_key_size); 1107 1108 adapter->current_op = VIRTCHNL_OP_CONFIG_RSS_KEY; 1109 adapter->aq_required &= ~IAVF_FLAG_AQ_SET_RSS_KEY; 1110 iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_RSS_KEY, (u8 *)vrk, len); 1111 kfree(vrk); 1112} 1113 1114/** 1115 * iavf_set_rss_lut 1116 * @adapter: adapter structure 1117 * 1118 * Request the PF to set our RSS lookup table 1119 **/ 1120void iavf_set_rss_lut(struct iavf_adapter *adapter) 1121{ 1122 struct virtchnl_rss_lut *vrl; 1123 int len; 1124 1125 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1126 /* bail because we already have a command pending */ 1127 dev_err(&adapter->pdev->dev, "Cannot set RSS LUT, command %d pending\n", 1128 adapter->current_op); 1129 return; 1130 } 1131 len = virtchnl_struct_size(vrl, lut, adapter->rss_lut_size); 1132 vrl = kzalloc(len, GFP_KERNEL); 1133 if (!vrl) 1134 return; 1135 vrl->vsi_id = adapter->vsi.id; 1136 vrl->lut_entries = adapter->rss_lut_size; 1137 memcpy(vrl->lut, adapter->rss_lut, adapter->rss_lut_size); 1138 adapter->current_op = VIRTCHNL_OP_CONFIG_RSS_LUT; 1139 adapter->aq_required &= ~IAVF_FLAG_AQ_SET_RSS_LUT; 1140 iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_RSS_LUT, (u8 *)vrl, len); 1141 kfree(vrl); 1142} 1143 1144/** 1145 * iavf_set_rss_hfunc 1146 * @adapter: adapter structure 1147 * 1148 * Request the PF to set our RSS Hash function 1149 **/ 1150void iavf_set_rss_hfunc(struct iavf_adapter *adapter) 1151{ 1152 struct virtchnl_rss_hfunc *vrh; 1153 int len = sizeof(*vrh); 1154 1155 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1156 /* bail because we already have a command pending */ 1157 dev_err(&adapter->pdev->dev, "Cannot set RSS Hash function, command %d pending\n", 1158 adapter->current_op); 1159 return; 1160 } 1161 vrh = kzalloc(len, GFP_KERNEL); 1162 if (!vrh) 1163 return; 1164 vrh->vsi_id = adapter->vsi.id; 1165 vrh->rss_algorithm = adapter->hfunc; 1166 adapter->current_op = VIRTCHNL_OP_CONFIG_RSS_HFUNC; 1167 adapter->aq_required &= ~IAVF_FLAG_AQ_SET_RSS_HFUNC; 1168 iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_RSS_HFUNC, (u8 *)vrh, len); 1169 kfree(vrh); 1170} 1171 1172/** 1173 * iavf_enable_vlan_stripping 1174 * @adapter: adapter structure 1175 * 1176 * Request VLAN header stripping to be enabled 1177 **/ 1178void iavf_enable_vlan_stripping(struct iavf_adapter *adapter) 1179{ 1180 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1181 /* bail because we already have a command pending */ 1182 dev_err(&adapter->pdev->dev, "Cannot enable stripping, command %d pending\n", 1183 adapter->current_op); 1184 return; 1185 } 1186 adapter->current_op = VIRTCHNL_OP_ENABLE_VLAN_STRIPPING; 1187 adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_VLAN_STRIPPING; 1188 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING, NULL, 0); 1189} 1190 1191/** 1192 * iavf_disable_vlan_stripping 1193 * @adapter: adapter structure 1194 * 1195 * Request VLAN header stripping to be disabled 1196 **/ 1197void iavf_disable_vlan_stripping(struct iavf_adapter *adapter) 1198{ 1199 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1200 /* bail because we already have a command pending */ 1201 dev_err(&adapter->pdev->dev, "Cannot disable stripping, command %d pending\n", 1202 adapter->current_op); 1203 return; 1204 } 1205 adapter->current_op = VIRTCHNL_OP_DISABLE_VLAN_STRIPPING; 1206 adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_VLAN_STRIPPING; 1207 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING, NULL, 0); 1208} 1209 1210/** 1211 * iavf_tpid_to_vc_ethertype - transform from VLAN TPID to virtchnl ethertype 1212 * @tpid: VLAN TPID (i.e. 0x8100, 0x88a8, etc.) 1213 */ 1214static u32 iavf_tpid_to_vc_ethertype(u16 tpid) 1215{ 1216 switch (tpid) { 1217 case ETH_P_8021Q: 1218 return VIRTCHNL_VLAN_ETHERTYPE_8100; 1219 case ETH_P_8021AD: 1220 return VIRTCHNL_VLAN_ETHERTYPE_88A8; 1221 } 1222 1223 return 0; 1224} 1225 1226/** 1227 * iavf_set_vc_offload_ethertype - set virtchnl ethertype for offload message 1228 * @adapter: adapter structure 1229 * @msg: message structure used for updating offloads over virtchnl to update 1230 * @tpid: VLAN TPID (i.e. 0x8100, 0x88a8, etc.) 1231 * @offload_op: opcode used to determine which support structure to check 1232 */ 1233static int 1234iavf_set_vc_offload_ethertype(struct iavf_adapter *adapter, 1235 struct virtchnl_vlan_setting *msg, u16 tpid, 1236 enum virtchnl_ops offload_op) 1237{ 1238 struct virtchnl_vlan_supported_caps *offload_support; 1239 u16 vc_ethertype = iavf_tpid_to_vc_ethertype(tpid); 1240 1241 /* reference the correct offload support structure */ 1242 switch (offload_op) { 1243 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2: 1244 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2: 1245 offload_support = 1246 &adapter->vlan_v2_caps.offloads.stripping_support; 1247 break; 1248 case VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2: 1249 case VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2: 1250 offload_support = 1251 &adapter->vlan_v2_caps.offloads.insertion_support; 1252 break; 1253 default: 1254 dev_err(&adapter->pdev->dev, "Invalid opcode %d for setting virtchnl ethertype to enable/disable VLAN offloads\n", 1255 offload_op); 1256 return -EINVAL; 1257 } 1258 1259 /* make sure ethertype is supported */ 1260 if (offload_support->outer & vc_ethertype && 1261 offload_support->outer & VIRTCHNL_VLAN_TOGGLE) { 1262 msg->outer_ethertype_setting = vc_ethertype; 1263 } else if (offload_support->inner & vc_ethertype && 1264 offload_support->inner & VIRTCHNL_VLAN_TOGGLE) { 1265 msg->inner_ethertype_setting = vc_ethertype; 1266 } else { 1267 dev_dbg(&adapter->pdev->dev, "opcode %d unsupported for VLAN TPID 0x%04x\n", 1268 offload_op, tpid); 1269 return -EINVAL; 1270 } 1271 1272 return 0; 1273} 1274 1275/** 1276 * iavf_clear_offload_v2_aq_required - clear AQ required bit for offload request 1277 * @adapter: adapter structure 1278 * @tpid: VLAN TPID 1279 * @offload_op: opcode used to determine which AQ required bit to clear 1280 */ 1281static void 1282iavf_clear_offload_v2_aq_required(struct iavf_adapter *adapter, u16 tpid, 1283 enum virtchnl_ops offload_op) 1284{ 1285 switch (offload_op) { 1286 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2: 1287 if (tpid == ETH_P_8021Q) 1288 adapter->aq_required &= 1289 ~IAVF_FLAG_AQ_ENABLE_CTAG_VLAN_STRIPPING; 1290 else if (tpid == ETH_P_8021AD) 1291 adapter->aq_required &= 1292 ~IAVF_FLAG_AQ_ENABLE_STAG_VLAN_STRIPPING; 1293 break; 1294 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2: 1295 if (tpid == ETH_P_8021Q) 1296 adapter->aq_required &= 1297 ~IAVF_FLAG_AQ_DISABLE_CTAG_VLAN_STRIPPING; 1298 else if (tpid == ETH_P_8021AD) 1299 adapter->aq_required &= 1300 ~IAVF_FLAG_AQ_DISABLE_STAG_VLAN_STRIPPING; 1301 break; 1302 case VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2: 1303 if (tpid == ETH_P_8021Q) 1304 adapter->aq_required &= 1305 ~IAVF_FLAG_AQ_ENABLE_CTAG_VLAN_INSERTION; 1306 else if (tpid == ETH_P_8021AD) 1307 adapter->aq_required &= 1308 ~IAVF_FLAG_AQ_ENABLE_STAG_VLAN_INSERTION; 1309 break; 1310 case VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2: 1311 if (tpid == ETH_P_8021Q) 1312 adapter->aq_required &= 1313 ~IAVF_FLAG_AQ_DISABLE_CTAG_VLAN_INSERTION; 1314 else if (tpid == ETH_P_8021AD) 1315 adapter->aq_required &= 1316 ~IAVF_FLAG_AQ_DISABLE_STAG_VLAN_INSERTION; 1317 break; 1318 default: 1319 dev_err(&adapter->pdev->dev, "Unsupported opcode %d specified for clearing aq_required bits for VIRTCHNL_VF_OFFLOAD_VLAN_V2 offload request\n", 1320 offload_op); 1321 } 1322} 1323 1324/** 1325 * iavf_send_vlan_offload_v2 - send offload enable/disable over virtchnl 1326 * @adapter: adapter structure 1327 * @tpid: VLAN TPID used for the command (i.e. 0x8100 or 0x88a8) 1328 * @offload_op: offload_op used to make the request over virtchnl 1329 */ 1330static void 1331iavf_send_vlan_offload_v2(struct iavf_adapter *adapter, u16 tpid, 1332 enum virtchnl_ops offload_op) 1333{ 1334 struct virtchnl_vlan_setting *msg; 1335 int len = sizeof(*msg); 1336 1337 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1338 /* bail because we already have a command pending */ 1339 dev_err(&adapter->pdev->dev, "Cannot send %d, command %d pending\n", 1340 offload_op, adapter->current_op); 1341 return; 1342 } 1343 1344 adapter->current_op = offload_op; 1345 1346 msg = kzalloc(len, GFP_KERNEL); 1347 if (!msg) 1348 return; 1349 1350 msg->vport_id = adapter->vsi_res->vsi_id; 1351 1352 /* always clear to prevent unsupported and endless requests */ 1353 iavf_clear_offload_v2_aq_required(adapter, tpid, offload_op); 1354 1355 /* only send valid offload requests */ 1356 if (!iavf_set_vc_offload_ethertype(adapter, msg, tpid, offload_op)) 1357 iavf_send_pf_msg(adapter, offload_op, (u8 *)msg, len); 1358 else 1359 adapter->current_op = VIRTCHNL_OP_UNKNOWN; 1360 1361 kfree(msg); 1362} 1363 1364/** 1365 * iavf_enable_vlan_stripping_v2 - enable VLAN stripping 1366 * @adapter: adapter structure 1367 * @tpid: VLAN TPID used to enable VLAN stripping 1368 */ 1369void iavf_enable_vlan_stripping_v2(struct iavf_adapter *adapter, u16 tpid) 1370{ 1371 iavf_send_vlan_offload_v2(adapter, tpid, 1372 VIRTCHNL_OP_ENABLE_VLAN_STRIPPING_V2); 1373} 1374 1375/** 1376 * iavf_disable_vlan_stripping_v2 - disable VLAN stripping 1377 * @adapter: adapter structure 1378 * @tpid: VLAN TPID used to disable VLAN stripping 1379 */ 1380void iavf_disable_vlan_stripping_v2(struct iavf_adapter *adapter, u16 tpid) 1381{ 1382 iavf_send_vlan_offload_v2(adapter, tpid, 1383 VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2); 1384} 1385 1386/** 1387 * iavf_enable_vlan_insertion_v2 - enable VLAN insertion 1388 * @adapter: adapter structure 1389 * @tpid: VLAN TPID used to enable VLAN insertion 1390 */ 1391void iavf_enable_vlan_insertion_v2(struct iavf_adapter *adapter, u16 tpid) 1392{ 1393 iavf_send_vlan_offload_v2(adapter, tpid, 1394 VIRTCHNL_OP_ENABLE_VLAN_INSERTION_V2); 1395} 1396 1397/** 1398 * iavf_disable_vlan_insertion_v2 - disable VLAN insertion 1399 * @adapter: adapter structure 1400 * @tpid: VLAN TPID used to disable VLAN insertion 1401 */ 1402void iavf_disable_vlan_insertion_v2(struct iavf_adapter *adapter, u16 tpid) 1403{ 1404 iavf_send_vlan_offload_v2(adapter, tpid, 1405 VIRTCHNL_OP_DISABLE_VLAN_INSERTION_V2); 1406} 1407 1408/** 1409 * iavf_print_link_message - print link up or down 1410 * @adapter: adapter structure 1411 * 1412 * Log a message telling the world of our wonderous link status 1413 */ 1414static void iavf_print_link_message(struct iavf_adapter *adapter) 1415{ 1416 struct net_device *netdev = adapter->netdev; 1417 int link_speed_mbps; 1418 char *speed; 1419 1420 if (!adapter->link_up) { 1421 netdev_info(netdev, "NIC Link is Down\n"); 1422 return; 1423 } 1424 1425 if (ADV_LINK_SUPPORT(adapter)) { 1426 link_speed_mbps = adapter->link_speed_mbps; 1427 goto print_link_msg; 1428 } 1429 1430 switch (adapter->link_speed) { 1431 case VIRTCHNL_LINK_SPEED_40GB: 1432 link_speed_mbps = SPEED_40000; 1433 break; 1434 case VIRTCHNL_LINK_SPEED_25GB: 1435 link_speed_mbps = SPEED_25000; 1436 break; 1437 case VIRTCHNL_LINK_SPEED_20GB: 1438 link_speed_mbps = SPEED_20000; 1439 break; 1440 case VIRTCHNL_LINK_SPEED_10GB: 1441 link_speed_mbps = SPEED_10000; 1442 break; 1443 case VIRTCHNL_LINK_SPEED_5GB: 1444 link_speed_mbps = SPEED_5000; 1445 break; 1446 case VIRTCHNL_LINK_SPEED_2_5GB: 1447 link_speed_mbps = SPEED_2500; 1448 break; 1449 case VIRTCHNL_LINK_SPEED_1GB: 1450 link_speed_mbps = SPEED_1000; 1451 break; 1452 case VIRTCHNL_LINK_SPEED_100MB: 1453 link_speed_mbps = SPEED_100; 1454 break; 1455 default: 1456 link_speed_mbps = SPEED_UNKNOWN; 1457 break; 1458 } 1459 1460print_link_msg: 1461 if (link_speed_mbps > SPEED_1000) { 1462 if (link_speed_mbps == SPEED_2500) { 1463 speed = kasprintf(GFP_KERNEL, "%s", "2.5 Gbps"); 1464 } else { 1465 /* convert to Gbps inline */ 1466 speed = kasprintf(GFP_KERNEL, "%d Gbps", 1467 link_speed_mbps / 1000); 1468 } 1469 } else if (link_speed_mbps == SPEED_UNKNOWN) { 1470 speed = kasprintf(GFP_KERNEL, "%s", "Unknown Mbps"); 1471 } else { 1472 speed = kasprintf(GFP_KERNEL, "%d Mbps", link_speed_mbps); 1473 } 1474 1475 netdev_info(netdev, "NIC Link is Up Speed is %s Full Duplex\n", speed); 1476 kfree(speed); 1477} 1478 1479/** 1480 * iavf_get_vpe_link_status 1481 * @adapter: adapter structure 1482 * @vpe: virtchnl_pf_event structure 1483 * 1484 * Helper function for determining the link status 1485 **/ 1486static bool 1487iavf_get_vpe_link_status(struct iavf_adapter *adapter, 1488 struct virtchnl_pf_event *vpe) 1489{ 1490 if (ADV_LINK_SUPPORT(adapter)) 1491 return vpe->event_data.link_event_adv.link_status; 1492 else 1493 return vpe->event_data.link_event.link_status; 1494} 1495 1496/** 1497 * iavf_set_adapter_link_speed_from_vpe 1498 * @adapter: adapter structure for which we are setting the link speed 1499 * @vpe: virtchnl_pf_event structure that contains the link speed we are setting 1500 * 1501 * Helper function for setting iavf_adapter link speed 1502 **/ 1503static void 1504iavf_set_adapter_link_speed_from_vpe(struct iavf_adapter *adapter, 1505 struct virtchnl_pf_event *vpe) 1506{ 1507 if (ADV_LINK_SUPPORT(adapter)) 1508 adapter->link_speed_mbps = 1509 vpe->event_data.link_event_adv.link_speed; 1510 else 1511 adapter->link_speed = vpe->event_data.link_event.link_speed; 1512} 1513 1514/** 1515 * iavf_enable_channels 1516 * @adapter: adapter structure 1517 * 1518 * Request that the PF enable channels as specified by 1519 * the user via tc tool. 1520 **/ 1521void iavf_enable_channels(struct iavf_adapter *adapter) 1522{ 1523 struct virtchnl_tc_info *vti = NULL; 1524 size_t len; 1525 int i; 1526 1527 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1528 /* bail because we already have a command pending */ 1529 dev_err(&adapter->pdev->dev, "Cannot configure mqprio, command %d pending\n", 1530 adapter->current_op); 1531 return; 1532 } 1533 1534 len = virtchnl_struct_size(vti, list, adapter->num_tc); 1535 vti = kzalloc(len, GFP_KERNEL); 1536 if (!vti) 1537 return; 1538 vti->num_tc = adapter->num_tc; 1539 for (i = 0; i < vti->num_tc; i++) { 1540 vti->list[i].count = adapter->ch_config.ch_info[i].count; 1541 vti->list[i].offset = adapter->ch_config.ch_info[i].offset; 1542 vti->list[i].pad = 0; 1543 vti->list[i].max_tx_rate = 1544 adapter->ch_config.ch_info[i].max_tx_rate; 1545 } 1546 1547 adapter->ch_config.state = __IAVF_TC_RUNNING; 1548 adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED; 1549 adapter->current_op = VIRTCHNL_OP_ENABLE_CHANNELS; 1550 adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_CHANNELS; 1551 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_CHANNELS, (u8 *)vti, len); 1552 kfree(vti); 1553} 1554 1555/** 1556 * iavf_disable_channels 1557 * @adapter: adapter structure 1558 * 1559 * Request that the PF disable channels that are configured 1560 **/ 1561void iavf_disable_channels(struct iavf_adapter *adapter) 1562{ 1563 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1564 /* bail because we already have a command pending */ 1565 dev_err(&adapter->pdev->dev, "Cannot configure mqprio, command %d pending\n", 1566 adapter->current_op); 1567 return; 1568 } 1569 1570 adapter->ch_config.state = __IAVF_TC_INVALID; 1571 adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED; 1572 adapter->current_op = VIRTCHNL_OP_DISABLE_CHANNELS; 1573 adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_CHANNELS; 1574 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_CHANNELS, NULL, 0); 1575} 1576 1577/** 1578 * iavf_print_cloud_filter 1579 * @adapter: adapter structure 1580 * @f: cloud filter to print 1581 * 1582 * Print the cloud filter 1583 **/ 1584static void iavf_print_cloud_filter(struct iavf_adapter *adapter, 1585 struct virtchnl_filter *f) 1586{ 1587 switch (f->flow_type) { 1588 case VIRTCHNL_TCP_V4_FLOW: 1589 dev_info(&adapter->pdev->dev, "dst_mac: %pM src_mac: %pM vlan_id: %hu dst_ip: %pI4 src_ip %pI4 dst_port %hu src_port %hu\n", 1590 &f->data.tcp_spec.dst_mac, 1591 &f->data.tcp_spec.src_mac, 1592 ntohs(f->data.tcp_spec.vlan_id), 1593 &f->data.tcp_spec.dst_ip[0], 1594 &f->data.tcp_spec.src_ip[0], 1595 ntohs(f->data.tcp_spec.dst_port), 1596 ntohs(f->data.tcp_spec.src_port)); 1597 break; 1598 case VIRTCHNL_TCP_V6_FLOW: 1599 dev_info(&adapter->pdev->dev, "dst_mac: %pM src_mac: %pM vlan_id: %hu dst_ip: %pI6 src_ip %pI6 dst_port %hu src_port %hu\n", 1600 &f->data.tcp_spec.dst_mac, 1601 &f->data.tcp_spec.src_mac, 1602 ntohs(f->data.tcp_spec.vlan_id), 1603 &f->data.tcp_spec.dst_ip, 1604 &f->data.tcp_spec.src_ip, 1605 ntohs(f->data.tcp_spec.dst_port), 1606 ntohs(f->data.tcp_spec.src_port)); 1607 break; 1608 } 1609} 1610 1611/** 1612 * iavf_add_cloud_filter 1613 * @adapter: adapter structure 1614 * 1615 * Request that the PF add cloud filters as specified 1616 * by the user via tc tool. 1617 **/ 1618void iavf_add_cloud_filter(struct iavf_adapter *adapter) 1619{ 1620 struct iavf_cloud_filter *cf; 1621 struct virtchnl_filter *f; 1622 int len = 0, count = 0; 1623 1624 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1625 /* bail because we already have a command pending */ 1626 dev_err(&adapter->pdev->dev, "Cannot add cloud filter, command %d pending\n", 1627 adapter->current_op); 1628 return; 1629 } 1630 list_for_each_entry(cf, &adapter->cloud_filter_list, list) { 1631 if (cf->add) { 1632 count++; 1633 break; 1634 } 1635 } 1636 if (!count) { 1637 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_CLOUD_FILTER; 1638 return; 1639 } 1640 adapter->current_op = VIRTCHNL_OP_ADD_CLOUD_FILTER; 1641 1642 len = sizeof(struct virtchnl_filter); 1643 f = kzalloc(len, GFP_KERNEL); 1644 if (!f) 1645 return; 1646 1647 list_for_each_entry(cf, &adapter->cloud_filter_list, list) { 1648 if (cf->add) { 1649 memcpy(f, &cf->f, sizeof(struct virtchnl_filter)); 1650 cf->add = false; 1651 cf->state = __IAVF_CF_ADD_PENDING; 1652 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_CLOUD_FILTER, 1653 (u8 *)f, len); 1654 } 1655 } 1656 kfree(f); 1657} 1658 1659/** 1660 * iavf_del_cloud_filter 1661 * @adapter: adapter structure 1662 * 1663 * Request that the PF delete cloud filters as specified 1664 * by the user via tc tool. 1665 **/ 1666void iavf_del_cloud_filter(struct iavf_adapter *adapter) 1667{ 1668 struct iavf_cloud_filter *cf, *cftmp; 1669 struct virtchnl_filter *f; 1670 int len = 0, count = 0; 1671 1672 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1673 /* bail because we already have a command pending */ 1674 dev_err(&adapter->pdev->dev, "Cannot remove cloud filter, command %d pending\n", 1675 adapter->current_op); 1676 return; 1677 } 1678 list_for_each_entry(cf, &adapter->cloud_filter_list, list) { 1679 if (cf->del) { 1680 count++; 1681 break; 1682 } 1683 } 1684 if (!count) { 1685 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_CLOUD_FILTER; 1686 return; 1687 } 1688 adapter->current_op = VIRTCHNL_OP_DEL_CLOUD_FILTER; 1689 1690 len = sizeof(struct virtchnl_filter); 1691 f = kzalloc(len, GFP_KERNEL); 1692 if (!f) 1693 return; 1694 1695 list_for_each_entry_safe(cf, cftmp, &adapter->cloud_filter_list, list) { 1696 if (cf->del) { 1697 memcpy(f, &cf->f, sizeof(struct virtchnl_filter)); 1698 cf->del = false; 1699 cf->state = __IAVF_CF_DEL_PENDING; 1700 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_CLOUD_FILTER, 1701 (u8 *)f, len); 1702 } 1703 } 1704 kfree(f); 1705} 1706 1707/** 1708 * iavf_add_fdir_filter 1709 * @adapter: the VF adapter structure 1710 * 1711 * Request that the PF add Flow Director filters as specified 1712 * by the user via ethtool. 1713 **/ 1714void iavf_add_fdir_filter(struct iavf_adapter *adapter) 1715{ 1716 struct iavf_fdir_fltr *fdir; 1717 struct virtchnl_fdir_add *f; 1718 bool process_fltr = false; 1719 int len; 1720 1721 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1722 /* bail because we already have a command pending */ 1723 dev_err(&adapter->pdev->dev, "Cannot add Flow Director filter, command %d pending\n", 1724 adapter->current_op); 1725 return; 1726 } 1727 1728 len = sizeof(struct virtchnl_fdir_add); 1729 f = kzalloc(len, GFP_KERNEL); 1730 if (!f) 1731 return; 1732 1733 spin_lock_bh(&adapter->fdir_fltr_lock); 1734 list_for_each_entry(fdir, &adapter->fdir_list_head, list) { 1735 if (fdir->state == IAVF_FDIR_FLTR_ADD_REQUEST) { 1736 process_fltr = true; 1737 fdir->state = IAVF_FDIR_FLTR_ADD_PENDING; 1738 memcpy(f, &fdir->vc_add_msg, len); 1739 break; 1740 } 1741 } 1742 spin_unlock_bh(&adapter->fdir_fltr_lock); 1743 1744 if (!process_fltr) { 1745 /* prevent iavf_add_fdir_filter() from being called when there 1746 * are no filters to add 1747 */ 1748 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_FDIR_FILTER; 1749 kfree(f); 1750 return; 1751 } 1752 adapter->current_op = VIRTCHNL_OP_ADD_FDIR_FILTER; 1753 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_FDIR_FILTER, (u8 *)f, len); 1754 kfree(f); 1755} 1756 1757/** 1758 * iavf_del_fdir_filter 1759 * @adapter: the VF adapter structure 1760 * 1761 * Request that the PF delete Flow Director filters as specified 1762 * by the user via ethtool. 1763 **/ 1764void iavf_del_fdir_filter(struct iavf_adapter *adapter) 1765{ 1766 struct virtchnl_fdir_del f = {}; 1767 struct iavf_fdir_fltr *fdir; 1768 bool process_fltr = false; 1769 int len; 1770 1771 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1772 /* bail because we already have a command pending */ 1773 dev_err(&adapter->pdev->dev, "Cannot remove Flow Director filter, command %d pending\n", 1774 adapter->current_op); 1775 return; 1776 } 1777 1778 len = sizeof(struct virtchnl_fdir_del); 1779 1780 spin_lock_bh(&adapter->fdir_fltr_lock); 1781 list_for_each_entry(fdir, &adapter->fdir_list_head, list) { 1782 if (fdir->state == IAVF_FDIR_FLTR_DEL_REQUEST) { 1783 process_fltr = true; 1784 f.vsi_id = fdir->vc_add_msg.vsi_id; 1785 f.flow_id = fdir->flow_id; 1786 fdir->state = IAVF_FDIR_FLTR_DEL_PENDING; 1787 break; 1788 } else if (fdir->state == IAVF_FDIR_FLTR_DIS_REQUEST) { 1789 process_fltr = true; 1790 f.vsi_id = fdir->vc_add_msg.vsi_id; 1791 f.flow_id = fdir->flow_id; 1792 fdir->state = IAVF_FDIR_FLTR_DIS_PENDING; 1793 break; 1794 } 1795 } 1796 spin_unlock_bh(&adapter->fdir_fltr_lock); 1797 1798 if (!process_fltr) { 1799 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_FDIR_FILTER; 1800 return; 1801 } 1802 1803 adapter->current_op = VIRTCHNL_OP_DEL_FDIR_FILTER; 1804 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_FDIR_FILTER, (u8 *)&f, len); 1805} 1806 1807/** 1808 * iavf_add_adv_rss_cfg 1809 * @adapter: the VF adapter structure 1810 * 1811 * Request that the PF add RSS configuration as specified 1812 * by the user via ethtool. 1813 **/ 1814void iavf_add_adv_rss_cfg(struct iavf_adapter *adapter) 1815{ 1816 struct virtchnl_rss_cfg *rss_cfg; 1817 struct iavf_adv_rss *rss; 1818 bool process_rss = false; 1819 int len; 1820 1821 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1822 /* bail because we already have a command pending */ 1823 dev_err(&adapter->pdev->dev, "Cannot add RSS configuration, command %d pending\n", 1824 adapter->current_op); 1825 return; 1826 } 1827 1828 len = sizeof(struct virtchnl_rss_cfg); 1829 rss_cfg = kzalloc(len, GFP_KERNEL); 1830 if (!rss_cfg) 1831 return; 1832 1833 spin_lock_bh(&adapter->adv_rss_lock); 1834 list_for_each_entry(rss, &adapter->adv_rss_list_head, list) { 1835 if (rss->state == IAVF_ADV_RSS_ADD_REQUEST) { 1836 process_rss = true; 1837 rss->state = IAVF_ADV_RSS_ADD_PENDING; 1838 memcpy(rss_cfg, &rss->cfg_msg, len); 1839 iavf_print_adv_rss_cfg(adapter, rss, 1840 "Input set change for", 1841 "is pending"); 1842 break; 1843 } 1844 } 1845 spin_unlock_bh(&adapter->adv_rss_lock); 1846 1847 if (process_rss) { 1848 adapter->current_op = VIRTCHNL_OP_ADD_RSS_CFG; 1849 iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_RSS_CFG, 1850 (u8 *)rss_cfg, len); 1851 } else { 1852 adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_ADV_RSS_CFG; 1853 } 1854 1855 kfree(rss_cfg); 1856} 1857 1858/** 1859 * iavf_del_adv_rss_cfg 1860 * @adapter: the VF adapter structure 1861 * 1862 * Request that the PF delete RSS configuration as specified 1863 * by the user via ethtool. 1864 **/ 1865void iavf_del_adv_rss_cfg(struct iavf_adapter *adapter) 1866{ 1867 struct virtchnl_rss_cfg *rss_cfg; 1868 struct iavf_adv_rss *rss; 1869 bool process_rss = false; 1870 int len; 1871 1872 if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) { 1873 /* bail because we already have a command pending */ 1874 dev_err(&adapter->pdev->dev, "Cannot remove RSS configuration, command %d pending\n", 1875 adapter->current_op); 1876 return; 1877 } 1878 1879 len = sizeof(struct virtchnl_rss_cfg); 1880 rss_cfg = kzalloc(len, GFP_KERNEL); 1881 if (!rss_cfg) 1882 return; 1883 1884 spin_lock_bh(&adapter->adv_rss_lock); 1885 list_for_each_entry(rss, &adapter->adv_rss_list_head, list) { 1886 if (rss->state == IAVF_ADV_RSS_DEL_REQUEST) { 1887 process_rss = true; 1888 rss->state = IAVF_ADV_RSS_DEL_PENDING; 1889 memcpy(rss_cfg, &rss->cfg_msg, len); 1890 break; 1891 } 1892 } 1893 spin_unlock_bh(&adapter->adv_rss_lock); 1894 1895 if (process_rss) { 1896 adapter->current_op = VIRTCHNL_OP_DEL_RSS_CFG; 1897 iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_RSS_CFG, 1898 (u8 *)rss_cfg, len); 1899 } else { 1900 adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_ADV_RSS_CFG; 1901 } 1902 1903 kfree(rss_cfg); 1904} 1905 1906/** 1907 * iavf_request_reset 1908 * @adapter: adapter structure 1909 * 1910 * Request that the PF reset this VF. No response is expected. 1911 **/ 1912int iavf_request_reset(struct iavf_adapter *adapter) 1913{ 1914 int err; 1915 /* Don't check CURRENT_OP - this is always higher priority */ 1916 err = iavf_send_pf_msg(adapter, VIRTCHNL_OP_RESET_VF, NULL, 0); 1917 adapter->current_op = VIRTCHNL_OP_UNKNOWN; 1918 return err; 1919} 1920 1921/** 1922 * iavf_netdev_features_vlan_strip_set - update vlan strip status 1923 * @netdev: ptr to netdev being adjusted 1924 * @enable: enable or disable vlan strip 1925 * 1926 * Helper function to change vlan strip status in netdev->features. 1927 */ 1928static void iavf_netdev_features_vlan_strip_set(struct net_device *netdev, 1929 const bool enable) 1930{ 1931 if (enable) 1932 netdev->features |= NETIF_F_HW_VLAN_CTAG_RX; 1933 else 1934 netdev->features &= ~NETIF_F_HW_VLAN_CTAG_RX; 1935} 1936 1937/** 1938 * iavf_activate_fdir_filters - Reactivate all FDIR filters after a reset 1939 * @adapter: private adapter structure 1940 * 1941 * Called after a reset to re-add all FDIR filters and delete some of them 1942 * if they were pending to be deleted. 1943 */ 1944static void iavf_activate_fdir_filters(struct iavf_adapter *adapter) 1945{ 1946 struct iavf_fdir_fltr *f, *ftmp; 1947 bool add_filters = false; 1948 1949 spin_lock_bh(&adapter->fdir_fltr_lock); 1950 list_for_each_entry_safe(f, ftmp, &adapter->fdir_list_head, list) { 1951 if (f->state == IAVF_FDIR_FLTR_ADD_REQUEST || 1952 f->state == IAVF_FDIR_FLTR_ADD_PENDING || 1953 f->state == IAVF_FDIR_FLTR_ACTIVE) { 1954 /* All filters and requests have been removed in PF, 1955 * restore them 1956 */ 1957 f->state = IAVF_FDIR_FLTR_ADD_REQUEST; 1958 add_filters = true; 1959 } else if (f->state == IAVF_FDIR_FLTR_DIS_REQUEST || 1960 f->state == IAVF_FDIR_FLTR_DIS_PENDING) { 1961 /* Link down state, leave filters as inactive */ 1962 f->state = IAVF_FDIR_FLTR_INACTIVE; 1963 } else if (f->state == IAVF_FDIR_FLTR_DEL_REQUEST || 1964 f->state == IAVF_FDIR_FLTR_DEL_PENDING) { 1965 /* Delete filters that were pending to be deleted, the 1966 * list on PF is already cleared after a reset 1967 */ 1968 list_del(&f->list); 1969 kfree(f); 1970 adapter->fdir_active_fltr--; 1971 } 1972 } 1973 spin_unlock_bh(&adapter->fdir_fltr_lock); 1974 1975 if (add_filters) 1976 adapter->aq_required |= IAVF_FLAG_AQ_ADD_FDIR_FILTER; 1977} 1978 1979/** 1980 * iavf_virtchnl_completion 1981 * @adapter: adapter structure 1982 * @v_opcode: opcode sent by PF 1983 * @v_retval: retval sent by PF 1984 * @msg: message sent by PF 1985 * @msglen: message length 1986 * 1987 * Asynchronous completion function for admin queue messages. Rather than busy 1988 * wait, we fire off our requests and assume that no errors will be returned. 1989 * This function handles the reply messages. 1990 **/ 1991void iavf_virtchnl_completion(struct iavf_adapter *adapter, 1992 enum virtchnl_ops v_opcode, 1993 enum iavf_status v_retval, u8 *msg, u16 msglen) 1994{ 1995 struct net_device *netdev = adapter->netdev; 1996 1997 if (v_opcode == VIRTCHNL_OP_EVENT) { 1998 struct virtchnl_pf_event *vpe = 1999 (struct virtchnl_pf_event *)msg; 2000 bool link_up = iavf_get_vpe_link_status(adapter, vpe); 2001 2002 switch (vpe->event) { 2003 case VIRTCHNL_EVENT_LINK_CHANGE: 2004 iavf_set_adapter_link_speed_from_vpe(adapter, vpe); 2005 2006 /* we've already got the right link status, bail */ 2007 if (adapter->link_up == link_up) 2008 break; 2009 2010 if (link_up) { 2011 /* If we get link up message and start queues 2012 * before our queues are configured it will 2013 * trigger a TX hang. In that case, just ignore 2014 * the link status message,we'll get another one 2015 * after we enable queues and actually prepared 2016 * to send traffic. 2017 */ 2018 if (adapter->state != __IAVF_RUNNING) 2019 break; 2020 2021 /* For ADq enabled VF, we reconfigure VSIs and 2022 * re-allocate queues. Hence wait till all 2023 * queues are enabled. 2024 */ 2025 if (adapter->flags & 2026 IAVF_FLAG_QUEUES_DISABLED) 2027 break; 2028 } 2029 2030 adapter->link_up = link_up; 2031 if (link_up) { 2032 netif_tx_start_all_queues(netdev); 2033 netif_carrier_on(netdev); 2034 } else { 2035 netif_tx_stop_all_queues(netdev); 2036 netif_carrier_off(netdev); 2037 } 2038 iavf_print_link_message(adapter); 2039 break; 2040 case VIRTCHNL_EVENT_RESET_IMPENDING: 2041 dev_info(&adapter->pdev->dev, "Reset indication received from the PF\n"); 2042 if (!(adapter->flags & IAVF_FLAG_RESET_PENDING)) { 2043 dev_info(&adapter->pdev->dev, "Scheduling reset task\n"); 2044 iavf_schedule_reset(adapter, IAVF_FLAG_RESET_PENDING); 2045 } 2046 break; 2047 default: 2048 dev_err(&adapter->pdev->dev, "Unknown event %d from PF\n", 2049 vpe->event); 2050 break; 2051 } 2052 return; 2053 } 2054 if (v_retval) { 2055 switch (v_opcode) { 2056 case VIRTCHNL_OP_ADD_VLAN: 2057 dev_err(&adapter->pdev->dev, "Failed to add VLAN filter, error %s\n", 2058 iavf_stat_str(&adapter->hw, v_retval)); 2059 break; 2060 case VIRTCHNL_OP_ADD_ETH_ADDR: 2061 dev_err(&adapter->pdev->dev, "Failed to add MAC filter, error %s\n", 2062 iavf_stat_str(&adapter->hw, v_retval)); 2063 iavf_mac_add_reject(adapter); 2064 /* restore administratively set MAC address */ 2065 ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr); 2066 wake_up(&adapter->vc_waitqueue); 2067 break; 2068 case VIRTCHNL_OP_DEL_VLAN: 2069 dev_err(&adapter->pdev->dev, "Failed to delete VLAN filter, error %s\n", 2070 iavf_stat_str(&adapter->hw, v_retval)); 2071 break; 2072 case VIRTCHNL_OP_DEL_ETH_ADDR: 2073 dev_err(&adapter->pdev->dev, "Failed to delete MAC filter, error %s\n", 2074 iavf_stat_str(&adapter->hw, v_retval)); 2075 break; 2076 case VIRTCHNL_OP_ENABLE_CHANNELS: 2077 dev_err(&adapter->pdev->dev, "Failed to configure queue channels, error %s\n", 2078 iavf_stat_str(&adapter->hw, v_retval)); 2079 adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED; 2080 adapter->ch_config.state = __IAVF_TC_INVALID; 2081 netdev_reset_tc(netdev); 2082 netif_tx_start_all_queues(netdev); 2083 break; 2084 case VIRTCHNL_OP_DISABLE_CHANNELS: 2085 dev_err(&adapter->pdev->dev, "Failed to disable queue channels, error %s\n", 2086 iavf_stat_str(&adapter->hw, v_retval)); 2087 adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED; 2088 adapter->ch_config.state = __IAVF_TC_RUNNING; 2089 netif_tx_start_all_queues(netdev); 2090 break; 2091 case VIRTCHNL_OP_ADD_CLOUD_FILTER: { 2092 struct iavf_cloud_filter *cf, *cftmp; 2093 2094 list_for_each_entry_safe(cf, cftmp, 2095 &adapter->cloud_filter_list, 2096 list) { 2097 if (cf->state == __IAVF_CF_ADD_PENDING) { 2098 cf->state = __IAVF_CF_INVALID; 2099 dev_info(&adapter->pdev->dev, "Failed to add cloud filter, error %s\n", 2100 iavf_stat_str(&adapter->hw, 2101 v_retval)); 2102 iavf_print_cloud_filter(adapter, 2103 &cf->f); 2104 list_del(&cf->list); 2105 kfree(cf); 2106 adapter->num_cloud_filters--; 2107 } 2108 } 2109 } 2110 break; 2111 case VIRTCHNL_OP_DEL_CLOUD_FILTER: { 2112 struct iavf_cloud_filter *cf; 2113 2114 list_for_each_entry(cf, &adapter->cloud_filter_list, 2115 list) { 2116 if (cf->state == __IAVF_CF_DEL_PENDING) { 2117 cf->state = __IAVF_CF_ACTIVE; 2118 dev_info(&adapter->pdev->dev, "Failed to del cloud filter, error %s\n", 2119 iavf_stat_str(&adapter->hw, 2120 v_retval)); 2121 iavf_print_cloud_filter(adapter, 2122 &cf->f); 2123 } 2124 } 2125 } 2126 break; 2127 case VIRTCHNL_OP_ADD_FDIR_FILTER: { 2128 struct iavf_fdir_fltr *fdir, *fdir_tmp; 2129 2130 spin_lock_bh(&adapter->fdir_fltr_lock); 2131 list_for_each_entry_safe(fdir, fdir_tmp, 2132 &adapter->fdir_list_head, 2133 list) { 2134 if (fdir->state == IAVF_FDIR_FLTR_ADD_PENDING) { 2135 dev_info(&adapter->pdev->dev, "Failed to add Flow Director filter, error %s\n", 2136 iavf_stat_str(&adapter->hw, 2137 v_retval)); 2138 iavf_print_fdir_fltr(adapter, fdir); 2139 if (msglen) 2140 dev_err(&adapter->pdev->dev, 2141 "%s\n", msg); 2142 list_del(&fdir->list); 2143 kfree(fdir); 2144 adapter->fdir_active_fltr--; 2145 } 2146 } 2147 spin_unlock_bh(&adapter->fdir_fltr_lock); 2148 } 2149 break; 2150 case VIRTCHNL_OP_DEL_FDIR_FILTER: { 2151 struct iavf_fdir_fltr *fdir; 2152 2153 spin_lock_bh(&adapter->fdir_fltr_lock); 2154 list_for_each_entry(fdir, &adapter->fdir_list_head, 2155 list) { 2156 if (fdir->state == IAVF_FDIR_FLTR_DEL_PENDING || 2157 fdir->state == IAVF_FDIR_FLTR_DIS_PENDING) { 2158 fdir->state = IAVF_FDIR_FLTR_ACTIVE; 2159 dev_info(&adapter->pdev->dev, "Failed to del Flow Director filter, error %s\n", 2160 iavf_stat_str(&adapter->hw, 2161 v_retval)); 2162 iavf_print_fdir_fltr(adapter, fdir); 2163 } 2164 } 2165 spin_unlock_bh(&adapter->fdir_fltr_lock); 2166 } 2167 break; 2168 case VIRTCHNL_OP_ADD_RSS_CFG: { 2169 struct iavf_adv_rss *rss, *rss_tmp; 2170 2171 spin_lock_bh(&adapter->adv_rss_lock); 2172 list_for_each_entry_safe(rss, rss_tmp, 2173 &adapter->adv_rss_list_head, 2174 list) { 2175 if (rss->state == IAVF_ADV_RSS_ADD_PENDING) { 2176 iavf_print_adv_rss_cfg(adapter, rss, 2177 "Failed to change the input set for", 2178 NULL); 2179 list_del(&rss->list); 2180 kfree(rss); 2181 } 2182 } 2183 spin_unlock_bh(&adapter->adv_rss_lock); 2184 } 2185 break; 2186 case VIRTCHNL_OP_DEL_RSS_CFG: { 2187 struct iavf_adv_rss *rss; 2188 2189 spin_lock_bh(&adapter->adv_rss_lock); 2190 list_for_each_entry(rss, &adapter->adv_rss_list_head, 2191 list) { 2192 if (rss->state == IAVF_ADV_RSS_DEL_PENDING) { 2193 rss->state = IAVF_ADV_RSS_ACTIVE; 2194 dev_err(&adapter->pdev->dev, "Failed to delete RSS configuration, error %s\n", 2195 iavf_stat_str(&adapter->hw, 2196 v_retval)); 2197 } 2198 } 2199 spin_unlock_bh(&adapter->adv_rss_lock); 2200 } 2201 break; 2202 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING: 2203 dev_warn(&adapter->pdev->dev, "Changing VLAN Stripping is not allowed when Port VLAN is configured\n"); 2204 /* Vlan stripping could not be enabled by ethtool. 2205 * Disable it in netdev->features. 2206 */ 2207 iavf_netdev_features_vlan_strip_set(netdev, false); 2208 break; 2209 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING: 2210 dev_warn(&adapter->pdev->dev, "Changing VLAN Stripping is not allowed when Port VLAN is configured\n"); 2211 /* Vlan stripping could not be disabled by ethtool. 2212 * Enable it in netdev->features. 2213 */ 2214 iavf_netdev_features_vlan_strip_set(netdev, true); 2215 break; 2216 case VIRTCHNL_OP_ADD_VLAN_V2: 2217 iavf_vlan_add_reject(adapter); 2218 dev_warn(&adapter->pdev->dev, "Failed to add VLAN filter, error %s\n", 2219 iavf_stat_str(&adapter->hw, v_retval)); 2220 break; 2221 case VIRTCHNL_OP_CONFIG_RSS_HFUNC: 2222 dev_warn(&adapter->pdev->dev, "Failed to configure hash function, error %s\n", 2223 iavf_stat_str(&adapter->hw, v_retval)); 2224 2225 if (adapter->hfunc == 2226 VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC) 2227 adapter->hfunc = 2228 VIRTCHNL_RSS_ALG_TOEPLITZ_ASYMMETRIC; 2229 else 2230 adapter->hfunc = 2231 VIRTCHNL_RSS_ALG_TOEPLITZ_SYMMETRIC; 2232 2233 break; 2234 default: 2235 dev_err(&adapter->pdev->dev, "PF returned error %d (%s) to our request %d\n", 2236 v_retval, iavf_stat_str(&adapter->hw, v_retval), 2237 v_opcode); 2238 } 2239 } 2240 switch (v_opcode) { 2241 case VIRTCHNL_OP_ADD_ETH_ADDR: 2242 if (!v_retval) 2243 iavf_mac_add_ok(adapter); 2244 if (!ether_addr_equal(netdev->dev_addr, adapter->hw.mac.addr)) 2245 if (!ether_addr_equal(netdev->dev_addr, 2246 adapter->hw.mac.addr)) { 2247 netif_addr_lock_bh(netdev); 2248 eth_hw_addr_set(netdev, adapter->hw.mac.addr); 2249 netif_addr_unlock_bh(netdev); 2250 } 2251 wake_up(&adapter->vc_waitqueue); 2252 break; 2253 case VIRTCHNL_OP_GET_STATS: { 2254 struct iavf_eth_stats *stats = 2255 (struct iavf_eth_stats *)msg; 2256 netdev->stats.rx_packets = stats->rx_unicast + 2257 stats->rx_multicast + 2258 stats->rx_broadcast; 2259 netdev->stats.tx_packets = stats->tx_unicast + 2260 stats->tx_multicast + 2261 stats->tx_broadcast; 2262 netdev->stats.rx_bytes = stats->rx_bytes; 2263 netdev->stats.tx_bytes = stats->tx_bytes; 2264 netdev->stats.tx_errors = stats->tx_errors; 2265 netdev->stats.rx_dropped = stats->rx_discards; 2266 netdev->stats.tx_dropped = stats->tx_discards; 2267 adapter->current_stats = *stats; 2268 } 2269 break; 2270 case VIRTCHNL_OP_GET_VF_RESOURCES: { 2271 u16 len = IAVF_VIRTCHNL_VF_RESOURCE_SIZE; 2272 2273 memcpy(adapter->vf_res, msg, min(msglen, len)); 2274 iavf_validate_num_queues(adapter); 2275 iavf_vf_parse_hw_config(&adapter->hw, adapter->vf_res); 2276 if (is_zero_ether_addr(adapter->hw.mac.addr)) { 2277 /* restore current mac address */ 2278 ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr); 2279 } else { 2280 netif_addr_lock_bh(netdev); 2281 /* refresh current mac address if changed */ 2282 ether_addr_copy(netdev->perm_addr, 2283 adapter->hw.mac.addr); 2284 netif_addr_unlock_bh(netdev); 2285 } 2286 spin_lock_bh(&adapter->mac_vlan_list_lock); 2287 iavf_add_filter(adapter, adapter->hw.mac.addr); 2288 2289 if (VLAN_ALLOWED(adapter)) { 2290 if (!list_empty(&adapter->vlan_filter_list)) { 2291 struct iavf_vlan_filter *vlf; 2292 2293 /* re-add all VLAN filters over virtchnl */ 2294 list_for_each_entry(vlf, 2295 &adapter->vlan_filter_list, 2296 list) 2297 vlf->state = IAVF_VLAN_ADD; 2298 2299 adapter->aq_required |= 2300 IAVF_FLAG_AQ_ADD_VLAN_FILTER; 2301 } 2302 } 2303 2304 spin_unlock_bh(&adapter->mac_vlan_list_lock); 2305 2306 iavf_activate_fdir_filters(adapter); 2307 2308 iavf_parse_vf_resource_msg(adapter); 2309 2310 /* negotiated VIRTCHNL_VF_OFFLOAD_VLAN_V2, so wait for the 2311 * response to VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS to finish 2312 * configuration 2313 */ 2314 if (VLAN_V2_ALLOWED(adapter)) 2315 break; 2316 /* fallthrough and finish config if VIRTCHNL_VF_OFFLOAD_VLAN_V2 2317 * wasn't successfully negotiated with the PF 2318 */ 2319 } 2320 fallthrough; 2321 case VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS: { 2322 struct iavf_mac_filter *f; 2323 bool was_mac_changed; 2324 u64 aq_required = 0; 2325 2326 if (v_opcode == VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS) 2327 memcpy(&adapter->vlan_v2_caps, msg, 2328 min_t(u16, msglen, 2329 sizeof(adapter->vlan_v2_caps))); 2330 2331 iavf_process_config(adapter); 2332 adapter->flags |= IAVF_FLAG_SETUP_NETDEV_FEATURES; 2333 iavf_schedule_finish_config(adapter); 2334 2335 iavf_set_queue_vlan_tag_loc(adapter); 2336 2337 was_mac_changed = !ether_addr_equal(netdev->dev_addr, 2338 adapter->hw.mac.addr); 2339 2340 spin_lock_bh(&adapter->mac_vlan_list_lock); 2341 2342 /* re-add all MAC filters */ 2343 list_for_each_entry(f, &adapter->mac_filter_list, list) { 2344 if (was_mac_changed && 2345 ether_addr_equal(netdev->dev_addr, f->macaddr)) 2346 ether_addr_copy(f->macaddr, 2347 adapter->hw.mac.addr); 2348 2349 f->is_new_mac = true; 2350 f->add = true; 2351 f->add_handled = false; 2352 f->remove = false; 2353 } 2354 2355 /* re-add all VLAN filters */ 2356 if (VLAN_FILTERING_ALLOWED(adapter)) { 2357 struct iavf_vlan_filter *vlf; 2358 2359 if (!list_empty(&adapter->vlan_filter_list)) { 2360 list_for_each_entry(vlf, 2361 &adapter->vlan_filter_list, 2362 list) 2363 vlf->state = IAVF_VLAN_ADD; 2364 2365 aq_required |= IAVF_FLAG_AQ_ADD_VLAN_FILTER; 2366 } 2367 } 2368 2369 spin_unlock_bh(&adapter->mac_vlan_list_lock); 2370 2371 netif_addr_lock_bh(netdev); 2372 eth_hw_addr_set(netdev, adapter->hw.mac.addr); 2373 netif_addr_unlock_bh(netdev); 2374 2375 adapter->aq_required |= IAVF_FLAG_AQ_ADD_MAC_FILTER | 2376 aq_required; 2377 } 2378 break; 2379 case VIRTCHNL_OP_ENABLE_QUEUES: 2380 /* enable transmits */ 2381 iavf_irq_enable(adapter, true); 2382 wake_up(&adapter->reset_waitqueue); 2383 adapter->flags &= ~IAVF_FLAG_QUEUES_DISABLED; 2384 break; 2385 case VIRTCHNL_OP_DISABLE_QUEUES: 2386 iavf_free_all_tx_resources(adapter); 2387 iavf_free_all_rx_resources(adapter); 2388 if (adapter->state == __IAVF_DOWN_PENDING) { 2389 iavf_change_state(adapter, __IAVF_DOWN); 2390 wake_up(&adapter->down_waitqueue); 2391 } 2392 break; 2393 case VIRTCHNL_OP_VERSION: 2394 case VIRTCHNL_OP_CONFIG_IRQ_MAP: 2395 /* Don't display an error if we get these out of sequence. 2396 * If the firmware needed to get kicked, we'll get these and 2397 * it's no problem. 2398 */ 2399 if (v_opcode != adapter->current_op) 2400 return; 2401 break; 2402 case VIRTCHNL_OP_GET_RSS_HENA_CAPS: { 2403 struct virtchnl_rss_hena *vrh = (struct virtchnl_rss_hena *)msg; 2404 2405 if (msglen == sizeof(*vrh)) 2406 adapter->hena = vrh->hena; 2407 else 2408 dev_warn(&adapter->pdev->dev, 2409 "Invalid message %d from PF\n", v_opcode); 2410 } 2411 break; 2412 case VIRTCHNL_OP_REQUEST_QUEUES: { 2413 struct virtchnl_vf_res_request *vfres = 2414 (struct virtchnl_vf_res_request *)msg; 2415 2416 if (vfres->num_queue_pairs != adapter->num_req_queues) { 2417 dev_info(&adapter->pdev->dev, 2418 "Requested %d queues, PF can support %d\n", 2419 adapter->num_req_queues, 2420 vfres->num_queue_pairs); 2421 adapter->num_req_queues = 0; 2422 adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED; 2423 } 2424 } 2425 break; 2426 case VIRTCHNL_OP_ADD_CLOUD_FILTER: { 2427 struct iavf_cloud_filter *cf; 2428 2429 list_for_each_entry(cf, &adapter->cloud_filter_list, list) { 2430 if (cf->state == __IAVF_CF_ADD_PENDING) 2431 cf->state = __IAVF_CF_ACTIVE; 2432 } 2433 } 2434 break; 2435 case VIRTCHNL_OP_DEL_CLOUD_FILTER: { 2436 struct iavf_cloud_filter *cf, *cftmp; 2437 2438 list_for_each_entry_safe(cf, cftmp, &adapter->cloud_filter_list, 2439 list) { 2440 if (cf->state == __IAVF_CF_DEL_PENDING) { 2441 cf->state = __IAVF_CF_INVALID; 2442 list_del(&cf->list); 2443 kfree(cf); 2444 adapter->num_cloud_filters--; 2445 } 2446 } 2447 } 2448 break; 2449 case VIRTCHNL_OP_ADD_FDIR_FILTER: { 2450 struct virtchnl_fdir_add *add_fltr = (struct virtchnl_fdir_add *)msg; 2451 struct iavf_fdir_fltr *fdir, *fdir_tmp; 2452 2453 spin_lock_bh(&adapter->fdir_fltr_lock); 2454 list_for_each_entry_safe(fdir, fdir_tmp, 2455 &adapter->fdir_list_head, 2456 list) { 2457 if (fdir->state == IAVF_FDIR_FLTR_ADD_PENDING) { 2458 if (add_fltr->status == VIRTCHNL_FDIR_SUCCESS) { 2459 dev_info(&adapter->pdev->dev, "Flow Director filter with location %u is added\n", 2460 fdir->loc); 2461 fdir->state = IAVF_FDIR_FLTR_ACTIVE; 2462 fdir->flow_id = add_fltr->flow_id; 2463 } else { 2464 dev_info(&adapter->pdev->dev, "Failed to add Flow Director filter with status: %d\n", 2465 add_fltr->status); 2466 iavf_print_fdir_fltr(adapter, fdir); 2467 list_del(&fdir->list); 2468 kfree(fdir); 2469 adapter->fdir_active_fltr--; 2470 } 2471 } 2472 } 2473 spin_unlock_bh(&adapter->fdir_fltr_lock); 2474 } 2475 break; 2476 case VIRTCHNL_OP_DEL_FDIR_FILTER: { 2477 struct virtchnl_fdir_del *del_fltr = (struct virtchnl_fdir_del *)msg; 2478 struct iavf_fdir_fltr *fdir, *fdir_tmp; 2479 2480 spin_lock_bh(&adapter->fdir_fltr_lock); 2481 list_for_each_entry_safe(fdir, fdir_tmp, &adapter->fdir_list_head, 2482 list) { 2483 if (fdir->state == IAVF_FDIR_FLTR_DEL_PENDING) { 2484 if (del_fltr->status == VIRTCHNL_FDIR_SUCCESS || 2485 del_fltr->status == 2486 VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST) { 2487 dev_info(&adapter->pdev->dev, "Flow Director filter with location %u is deleted\n", 2488 fdir->loc); 2489 list_del(&fdir->list); 2490 kfree(fdir); 2491 adapter->fdir_active_fltr--; 2492 } else { 2493 fdir->state = IAVF_FDIR_FLTR_ACTIVE; 2494 dev_info(&adapter->pdev->dev, "Failed to delete Flow Director filter with status: %d\n", 2495 del_fltr->status); 2496 iavf_print_fdir_fltr(adapter, fdir); 2497 } 2498 } else if (fdir->state == IAVF_FDIR_FLTR_DIS_PENDING) { 2499 if (del_fltr->status == VIRTCHNL_FDIR_SUCCESS || 2500 del_fltr->status == 2501 VIRTCHNL_FDIR_FAILURE_RULE_NONEXIST) { 2502 fdir->state = IAVF_FDIR_FLTR_INACTIVE; 2503 } else { 2504 fdir->state = IAVF_FDIR_FLTR_ACTIVE; 2505 dev_info(&adapter->pdev->dev, "Failed to disable Flow Director filter with status: %d\n", 2506 del_fltr->status); 2507 iavf_print_fdir_fltr(adapter, fdir); 2508 } 2509 } 2510 } 2511 spin_unlock_bh(&adapter->fdir_fltr_lock); 2512 } 2513 break; 2514 case VIRTCHNL_OP_ADD_RSS_CFG: { 2515 struct iavf_adv_rss *rss; 2516 2517 spin_lock_bh(&adapter->adv_rss_lock); 2518 list_for_each_entry(rss, &adapter->adv_rss_list_head, list) { 2519 if (rss->state == IAVF_ADV_RSS_ADD_PENDING) { 2520 iavf_print_adv_rss_cfg(adapter, rss, 2521 "Input set change for", 2522 "successful"); 2523 rss->state = IAVF_ADV_RSS_ACTIVE; 2524 } 2525 } 2526 spin_unlock_bh(&adapter->adv_rss_lock); 2527 } 2528 break; 2529 case VIRTCHNL_OP_DEL_RSS_CFG: { 2530 struct iavf_adv_rss *rss, *rss_tmp; 2531 2532 spin_lock_bh(&adapter->adv_rss_lock); 2533 list_for_each_entry_safe(rss, rss_tmp, 2534 &adapter->adv_rss_list_head, list) { 2535 if (rss->state == IAVF_ADV_RSS_DEL_PENDING) { 2536 list_del(&rss->list); 2537 kfree(rss); 2538 } 2539 } 2540 spin_unlock_bh(&adapter->adv_rss_lock); 2541 } 2542 break; 2543 case VIRTCHNL_OP_ADD_VLAN_V2: { 2544 struct iavf_vlan_filter *f; 2545 2546 spin_lock_bh(&adapter->mac_vlan_list_lock); 2547 list_for_each_entry(f, &adapter->vlan_filter_list, list) { 2548 if (f->state == IAVF_VLAN_IS_NEW) 2549 f->state = IAVF_VLAN_ACTIVE; 2550 } 2551 spin_unlock_bh(&adapter->mac_vlan_list_lock); 2552 } 2553 break; 2554 case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING: 2555 /* PF enabled vlan strip on this VF. 2556 * Update netdev->features if needed to be in sync with ethtool. 2557 */ 2558 if (!v_retval) 2559 iavf_netdev_features_vlan_strip_set(netdev, true); 2560 break; 2561 case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING: 2562 /* PF disabled vlan strip on this VF. 2563 * Update netdev->features if needed to be in sync with ethtool. 2564 */ 2565 if (!v_retval) 2566 iavf_netdev_features_vlan_strip_set(netdev, false); 2567 break; 2568 default: 2569 if (adapter->current_op && (v_opcode != adapter->current_op)) 2570 dev_warn(&adapter->pdev->dev, "Expected response %d from PF, received %d\n", 2571 adapter->current_op, v_opcode); 2572 break; 2573 } /* switch v_opcode */ 2574 adapter->current_op = VIRTCHNL_OP_UNKNOWN; 2575} 2576