1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 1999 - 2018 Intel Corporation. */ 3 4 #include "vf.h" 5 #include "ixgbevf.h" 6 7 /* On Hyper-V, to reset, we need to read from this offset 8 * from the PCI config space. This is the mechanism used on 9 * Hyper-V to support PF/VF communication. 10 */ 11 #define IXGBE_HV_RESET_OFFSET 0x201 12 13 static inline s32 ixgbevf_write_msg_read_ack(struct ixgbe_hw *hw, u32 *msg, 14 u32 *retmsg, u16 size) 15 { 16 struct ixgbe_mbx_info *mbx = &hw->mbx; 17 s32 retval = mbx->ops.write_posted(hw, msg, size); 18 19 if (retval) 20 return retval; 21 22 return mbx->ops.read_posted(hw, retmsg, size); 23 } 24 25 /** 26 * ixgbevf_start_hw_vf - Prepare hardware for Tx/Rx 27 * @hw: pointer to hardware structure 28 * 29 * Starts the hardware by filling the bus info structure and media type, clears 30 * all on chip counters, initializes receive address registers, multicast 31 * table, VLAN filter table, calls routine to set up link and flow control 32 * settings, and leaves transmit and receive units disabled and uninitialized 33 **/ 34 static s32 ixgbevf_start_hw_vf(struct ixgbe_hw *hw) 35 { 36 /* Clear adapter stopped flag */ 37 hw->adapter_stopped = false; 38 39 return 0; 40 } 41 42 /** 43 * ixgbevf_init_hw_vf - virtual function hardware initialization 44 * @hw: pointer to hardware structure 45 * 46 * Initialize the hardware by resetting the hardware and then starting 47 * the hardware 48 **/ 49 static s32 ixgbevf_init_hw_vf(struct ixgbe_hw *hw) 50 { 51 s32 status = hw->mac.ops.start_hw(hw); 52 53 hw->mac.ops.get_mac_addr(hw, hw->mac.addr); 54 55 return status; 56 } 57 58 /** 59 * ixgbevf_reset_hw_vf - Performs hardware reset 60 * @hw: pointer to hardware structure 61 * 62 * Resets the hardware by resetting the transmit and receive units, masks and 63 * clears all interrupts. 64 **/ 65 static s32 ixgbevf_reset_hw_vf(struct ixgbe_hw *hw) 66 { 67 struct ixgbe_mbx_info *mbx = &hw->mbx; 68 u32 timeout = IXGBE_VF_INIT_TIMEOUT; 69 u32 msgbuf[IXGBE_VF_PERMADDR_MSG_LEN]; 70 u8 *addr = (u8 *)(&msgbuf[1]); 71 s32 ret_val; 72 73 /* Call adapter stop to disable tx/rx and clear interrupts */ 74 hw->mac.ops.stop_adapter(hw); 75 76 /* reset the api version */ 77 hw->api_version = ixgbe_mbox_api_10; 78 79 IXGBE_WRITE_REG(hw, IXGBE_VFCTRL, IXGBE_CTRL_RST); 80 IXGBE_WRITE_FLUSH(hw); 81 82 /* we cannot reset while the RSTI / RSTD bits are asserted */ 83 while (!mbx->ops.check_for_rst(hw) && timeout) { 84 timeout--; 85 udelay(5); 86 } 87 88 if (!timeout) 89 return IXGBE_ERR_RESET_FAILED; 90 91 /* mailbox timeout can now become active */ 92 mbx->timeout = IXGBE_VF_MBX_INIT_TIMEOUT; 93 94 msgbuf[0] = IXGBE_VF_RESET; 95 mbx->ops.write_posted(hw, msgbuf, 1); 96 97 mdelay(10); 98 99 /* set our "perm_addr" based on info provided by PF 100 * also set up the mc_filter_type which is piggy backed 101 * on the mac address in word 3 102 */ 103 ret_val = mbx->ops.read_posted(hw, msgbuf, IXGBE_VF_PERMADDR_MSG_LEN); 104 if (ret_val) 105 return ret_val; 106 107 /* New versions of the PF may NACK the reset return message 108 * to indicate that no MAC address has yet been assigned for 109 * the VF. 110 */ 111 if (msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK) && 112 msgbuf[0] != (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_NACK)) 113 return IXGBE_ERR_INVALID_MAC_ADDR; 114 115 if (msgbuf[0] == (IXGBE_VF_RESET | IXGBE_VT_MSGTYPE_ACK)) 116 ether_addr_copy(hw->mac.perm_addr, addr); 117 118 hw->mac.mc_filter_type = msgbuf[IXGBE_VF_MC_TYPE_WORD]; 119 120 return 0; 121 } 122 123 /** 124 * ixgbevf_hv_reset_hw_vf - reset via Hyper-V 125 * @hw: pointer to private hardware struct 126 * 127 * Hyper-V variant; the VF/PF communication is through the PCI 128 * config space. 129 */ 130 static s32 ixgbevf_hv_reset_hw_vf(struct ixgbe_hw *hw) 131 { 132 #if IS_ENABLED(CONFIG_PCI_MMCONFIG) 133 struct ixgbevf_adapter *adapter = hw->back; 134 int i; 135 136 for (i = 0; i < 6; i++) 137 pci_read_config_byte(adapter->pdev, 138 (i + IXGBE_HV_RESET_OFFSET), 139 &hw->mac.perm_addr[i]); 140 return 0; 141 #else 142 pr_err("PCI_MMCONFIG needs to be enabled for Hyper-V\n"); 143 return -EOPNOTSUPP; 144 #endif 145 } 146 147 /** 148 * ixgbevf_stop_hw_vf - Generic stop Tx/Rx units 149 * @hw: pointer to hardware structure 150 * 151 * Sets the adapter_stopped flag within ixgbe_hw struct. Clears interrupts, 152 * disables transmit and receive units. The adapter_stopped flag is used by 153 * the shared code and drivers to determine if the adapter is in a stopped 154 * state and should not touch the hardware. 155 **/ 156 static s32 ixgbevf_stop_hw_vf(struct ixgbe_hw *hw) 157 { 158 u32 number_of_queues; 159 u32 reg_val; 160 u16 i; 161 162 /* Set the adapter_stopped flag so other driver functions stop touching 163 * the hardware 164 */ 165 hw->adapter_stopped = true; 166 167 /* Disable the receive unit by stopped each queue */ 168 number_of_queues = hw->mac.max_rx_queues; 169 for (i = 0; i < number_of_queues; i++) { 170 reg_val = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); 171 if (reg_val & IXGBE_RXDCTL_ENABLE) { 172 reg_val &= ~IXGBE_RXDCTL_ENABLE; 173 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), reg_val); 174 } 175 } 176 177 IXGBE_WRITE_FLUSH(hw); 178 179 /* Clear interrupt mask to stop from interrupts being generated */ 180 IXGBE_WRITE_REG(hw, IXGBE_VTEIMC, IXGBE_VF_IRQ_CLEAR_MASK); 181 182 /* Clear any pending interrupts */ 183 IXGBE_READ_REG(hw, IXGBE_VTEICR); 184 185 /* Disable the transmit unit. Each queue must be disabled. */ 186 number_of_queues = hw->mac.max_tx_queues; 187 for (i = 0; i < number_of_queues; i++) { 188 reg_val = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); 189 if (reg_val & IXGBE_TXDCTL_ENABLE) { 190 reg_val &= ~IXGBE_TXDCTL_ENABLE; 191 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), reg_val); 192 } 193 } 194 195 return 0; 196 } 197 198 /** 199 * ixgbevf_mta_vector - Determines bit-vector in multicast table to set 200 * @hw: pointer to hardware structure 201 * @mc_addr: the multicast address 202 * 203 * Extracts the 12 bits, from a multicast address, to determine which 204 * bit-vector to set in the multicast table. The hardware uses 12 bits, from 205 * incoming Rx multicast addresses, to determine the bit-vector to check in 206 * the MTA. Which of the 4 combination, of 12-bits, the hardware uses is set 207 * by the MO field of the MCSTCTRL. The MO field is set during initialization 208 * to mc_filter_type. 209 **/ 210 static s32 ixgbevf_mta_vector(struct ixgbe_hw *hw, u8 *mc_addr) 211 { 212 u32 vector = 0; 213 214 switch (hw->mac.mc_filter_type) { 215 case 0: /* use bits [47:36] of the address */ 216 vector = ((mc_addr[4] >> 4) | (((u16)mc_addr[5]) << 4)); 217 break; 218 case 1: /* use bits [46:35] of the address */ 219 vector = ((mc_addr[4] >> 3) | (((u16)mc_addr[5]) << 5)); 220 break; 221 case 2: /* use bits [45:34] of the address */ 222 vector = ((mc_addr[4] >> 2) | (((u16)mc_addr[5]) << 6)); 223 break; 224 case 3: /* use bits [43:32] of the address */ 225 vector = ((mc_addr[4]) | (((u16)mc_addr[5]) << 8)); 226 break; 227 default: /* Invalid mc_filter_type */ 228 break; 229 } 230 231 /* vector can only be 12-bits or boundary will be exceeded */ 232 vector &= 0xFFF; 233 return vector; 234 } 235 236 /** 237 * ixgbevf_get_mac_addr_vf - Read device MAC address 238 * @hw: pointer to the HW structure 239 * @mac_addr: pointer to storage for retrieved MAC address 240 **/ 241 static s32 ixgbevf_get_mac_addr_vf(struct ixgbe_hw *hw, u8 *mac_addr) 242 { 243 ether_addr_copy(mac_addr, hw->mac.perm_addr); 244 245 return 0; 246 } 247 248 static s32 ixgbevf_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 249 { 250 u32 msgbuf[3], msgbuf_chk; 251 u8 *msg_addr = (u8 *)(&msgbuf[1]); 252 s32 ret_val; 253 254 memset(msgbuf, 0, sizeof(msgbuf)); 255 /* If index is one then this is the start of a new list and needs 256 * indication to the PF so it can do it's own list management. 257 * If it is zero then that tells the PF to just clear all of 258 * this VF's macvlans and there is no new list. 259 */ 260 msgbuf[0] |= index << IXGBE_VT_MSGINFO_SHIFT; 261 msgbuf[0] |= IXGBE_VF_SET_MACVLAN; 262 msgbuf_chk = msgbuf[0]; 263 264 if (addr) 265 ether_addr_copy(msg_addr, addr); 266 267 ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 268 ARRAY_SIZE(msgbuf)); 269 if (!ret_val) { 270 msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 271 272 if (msgbuf[0] == (msgbuf_chk | IXGBE_VT_MSGTYPE_NACK)) 273 return -ENOMEM; 274 } 275 276 return ret_val; 277 } 278 279 static s32 ixgbevf_hv_set_uc_addr_vf(struct ixgbe_hw *hw, u32 index, u8 *addr) 280 { 281 return -EOPNOTSUPP; 282 } 283 284 /** 285 * ixgbevf_get_reta_locked - get the RSS redirection table (RETA) contents. 286 * @hw: pointer to hardware structure 287 * @reta: buffer to fill with RETA contents. 288 * @num_rx_queues: Number of Rx queues configured for this port 289 * 290 * The "reta" buffer should be big enough to contain 32 registers. 291 * 292 * Returns: 0 on success. 293 * if API doesn't support this operation - (-EOPNOTSUPP). 294 */ 295 int ixgbevf_get_reta_locked(struct ixgbe_hw *hw, u32 *reta, int num_rx_queues) 296 { 297 int err, i, j; 298 u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 299 u32 *hw_reta = &msgbuf[1]; 300 u32 mask = 0; 301 302 /* We have to use a mailbox for 82599 and x540 devices only. 303 * For these devices RETA has 128 entries. 304 * Also these VFs support up to 4 RSS queues. Therefore PF will compress 305 * 16 RETA entries in each DWORD giving 2 bits to each entry. 306 */ 307 int dwords = IXGBEVF_82599_RETA_SIZE / 16; 308 309 /* We support the RSS querying for 82599 and x540 devices only. 310 * Thus return an error if API doesn't support RETA querying or querying 311 * is not supported for this device type. 312 */ 313 switch (hw->api_version) { 314 case ixgbe_mbox_api_14: 315 case ixgbe_mbox_api_13: 316 case ixgbe_mbox_api_12: 317 if (hw->mac.type < ixgbe_mac_X550_vf) 318 break; 319 fallthrough; 320 default: 321 return -EOPNOTSUPP; 322 } 323 324 msgbuf[0] = IXGBE_VF_GET_RETA; 325 326 err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 327 328 if (err) 329 return err; 330 331 err = hw->mbx.ops.read_posted(hw, msgbuf, dwords + 1); 332 333 if (err) 334 return err; 335 336 msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 337 338 /* If the operation has been refused by a PF return -EPERM */ 339 if (msgbuf[0] == (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_NACK)) 340 return -EPERM; 341 342 /* If we didn't get an ACK there must have been 343 * some sort of mailbox error so we should treat it 344 * as such. 345 */ 346 if (msgbuf[0] != (IXGBE_VF_GET_RETA | IXGBE_VT_MSGTYPE_ACK)) 347 return IXGBE_ERR_MBX; 348 349 /* ixgbevf doesn't support more than 2 queues at the moment */ 350 if (num_rx_queues > 1) 351 mask = 0x1; 352 353 for (i = 0; i < dwords; i++) 354 for (j = 0; j < 16; j++) 355 reta[i * 16 + j] = (hw_reta[i] >> (2 * j)) & mask; 356 357 return 0; 358 } 359 360 /** 361 * ixgbevf_get_rss_key_locked - get the RSS Random Key 362 * @hw: pointer to the HW structure 363 * @rss_key: buffer to fill with RSS Hash Key contents. 364 * 365 * The "rss_key" buffer should be big enough to contain 10 registers. 366 * 367 * Returns: 0 on success. 368 * if API doesn't support this operation - (-EOPNOTSUPP). 369 */ 370 int ixgbevf_get_rss_key_locked(struct ixgbe_hw *hw, u8 *rss_key) 371 { 372 int err; 373 u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 374 375 /* We currently support the RSS Random Key retrieval for 82599 and x540 376 * devices only. 377 * 378 * Thus return an error if API doesn't support RSS Random Key retrieval 379 * or if the operation is not supported for this device type. 380 */ 381 switch (hw->api_version) { 382 case ixgbe_mbox_api_14: 383 case ixgbe_mbox_api_13: 384 case ixgbe_mbox_api_12: 385 if (hw->mac.type < ixgbe_mac_X550_vf) 386 break; 387 fallthrough; 388 default: 389 return -EOPNOTSUPP; 390 } 391 392 msgbuf[0] = IXGBE_VF_GET_RSS_KEY; 393 err = hw->mbx.ops.write_posted(hw, msgbuf, 1); 394 395 if (err) 396 return err; 397 398 err = hw->mbx.ops.read_posted(hw, msgbuf, 11); 399 400 if (err) 401 return err; 402 403 msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 404 405 /* If the operation has been refused by a PF return -EPERM */ 406 if (msgbuf[0] == (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_NACK)) 407 return -EPERM; 408 409 /* If we didn't get an ACK there must have been 410 * some sort of mailbox error so we should treat it 411 * as such. 412 */ 413 if (msgbuf[0] != (IXGBE_VF_GET_RSS_KEY | IXGBE_VT_MSGTYPE_ACK)) 414 return IXGBE_ERR_MBX; 415 416 memcpy(rss_key, msgbuf + 1, IXGBEVF_RSS_HASH_KEY_SIZE); 417 418 return 0; 419 } 420 421 /** 422 * ixgbevf_set_rar_vf - set device MAC address 423 * @hw: pointer to hardware structure 424 * @index: Receive address register to write 425 * @addr: Address to put into receive address register 426 * @vmdq: Unused in this implementation 427 **/ 428 static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 429 u32 vmdq) 430 { 431 u32 msgbuf[3]; 432 u8 *msg_addr = (u8 *)(&msgbuf[1]); 433 s32 ret_val; 434 435 memset(msgbuf, 0, sizeof(msgbuf)); 436 msgbuf[0] = IXGBE_VF_SET_MAC_ADDR; 437 ether_addr_copy(msg_addr, addr); 438 439 ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 440 ARRAY_SIZE(msgbuf)); 441 msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 442 443 /* if nacked the address was rejected, use "perm_addr" */ 444 if (!ret_val && 445 (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK))) { 446 ixgbevf_get_mac_addr_vf(hw, hw->mac.addr); 447 return IXGBE_ERR_MBX; 448 } 449 450 return ret_val; 451 } 452 453 /** 454 * ixgbevf_hv_set_rar_vf - set device MAC address Hyper-V variant 455 * @hw: pointer to hardware structure 456 * @index: Receive address register to write 457 * @addr: Address to put into receive address register 458 * @vmdq: Unused in this implementation 459 * 460 * We don't really allow setting the device MAC address. However, 461 * if the address being set is the permanent MAC address we will 462 * permit that. 463 **/ 464 static s32 ixgbevf_hv_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr, 465 u32 vmdq) 466 { 467 if (ether_addr_equal(addr, hw->mac.perm_addr)) 468 return 0; 469 470 return -EOPNOTSUPP; 471 } 472 473 /** 474 * ixgbevf_update_mc_addr_list_vf - Update Multicast addresses 475 * @hw: pointer to the HW structure 476 * @netdev: pointer to net device structure 477 * 478 * Updates the Multicast Table Array. 479 **/ 480 static s32 ixgbevf_update_mc_addr_list_vf(struct ixgbe_hw *hw, 481 struct net_device *netdev) 482 { 483 struct netdev_hw_addr *ha; 484 u32 msgbuf[IXGBE_VFMAILBOX_SIZE]; 485 u16 *vector_list = (u16 *)&msgbuf[1]; 486 u32 cnt, i; 487 488 /* Each entry in the list uses 1 16 bit word. We have 30 489 * 16 bit words available in our HW msg buffer (minus 1 for the 490 * msg type). That's 30 hash values if we pack 'em right. If 491 * there are more than 30 MC addresses to add then punt the 492 * extras for now and then add code to handle more than 30 later. 493 * It would be unusual for a server to request that many multi-cast 494 * addresses except for in large enterprise network environments. 495 */ 496 497 cnt = netdev_mc_count(netdev); 498 if (cnt > 30) 499 cnt = 30; 500 msgbuf[0] = IXGBE_VF_SET_MULTICAST; 501 msgbuf[0] |= cnt << IXGBE_VT_MSGINFO_SHIFT; 502 503 i = 0; 504 netdev_for_each_mc_addr(ha, netdev) { 505 if (i == cnt) 506 break; 507 if (is_link_local_ether_addr(ha->addr)) 508 continue; 509 510 vector_list[i++] = ixgbevf_mta_vector(hw, ha->addr); 511 } 512 513 return ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 514 IXGBE_VFMAILBOX_SIZE); 515 } 516 517 /** 518 * ixgbevf_hv_update_mc_addr_list_vf - stub 519 * @hw: unused 520 * @netdev: unused 521 * 522 * Hyper-V variant - just a stub. 523 */ 524 static s32 ixgbevf_hv_update_mc_addr_list_vf(struct ixgbe_hw *hw, 525 struct net_device *netdev) 526 { 527 return -EOPNOTSUPP; 528 } 529 530 /** 531 * ixgbevf_update_xcast_mode - Update Multicast mode 532 * @hw: pointer to the HW structure 533 * @xcast_mode: new multicast mode 534 * 535 * Updates the Multicast Mode of VF. 536 **/ 537 static s32 ixgbevf_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 538 { 539 u32 msgbuf[2]; 540 s32 err; 541 542 switch (hw->api_version) { 543 case ixgbe_mbox_api_12: 544 /* promisc introduced in 1.3 version */ 545 if (xcast_mode == IXGBEVF_XCAST_MODE_PROMISC) 546 return -EOPNOTSUPP; 547 fallthrough; 548 case ixgbe_mbox_api_14: 549 case ixgbe_mbox_api_13: 550 break; 551 default: 552 return -EOPNOTSUPP; 553 } 554 555 msgbuf[0] = IXGBE_VF_UPDATE_XCAST_MODE; 556 msgbuf[1] = xcast_mode; 557 558 err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 559 ARRAY_SIZE(msgbuf)); 560 if (err) 561 return err; 562 563 msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 564 if (msgbuf[0] == (IXGBE_VF_UPDATE_XCAST_MODE | IXGBE_VT_MSGTYPE_NACK)) 565 return -EPERM; 566 567 return 0; 568 } 569 570 /** 571 * ixgbevf_hv_update_xcast_mode - stub 572 * @hw: unused 573 * @xcast_mode: unused 574 * 575 * Hyper-V variant - just a stub. 576 */ 577 static s32 ixgbevf_hv_update_xcast_mode(struct ixgbe_hw *hw, int xcast_mode) 578 { 579 return -EOPNOTSUPP; 580 } 581 582 /** 583 * ixgbevf_set_vfta_vf - Set/Unset VLAN filter table address 584 * @hw: pointer to the HW structure 585 * @vlan: 12 bit VLAN ID 586 * @vind: unused by VF drivers 587 * @vlan_on: if true then set bit, else clear bit 588 **/ 589 static s32 ixgbevf_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 590 bool vlan_on) 591 { 592 u32 msgbuf[2]; 593 s32 err; 594 595 msgbuf[0] = IXGBE_VF_SET_VLAN; 596 msgbuf[1] = vlan; 597 /* Setting the 8 bit field MSG INFO to TRUE indicates "add" */ 598 msgbuf[0] |= vlan_on << IXGBE_VT_MSGINFO_SHIFT; 599 600 err = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 601 ARRAY_SIZE(msgbuf)); 602 if (err) 603 goto mbx_err; 604 605 /* remove extra bits from the message */ 606 msgbuf[0] &= ~IXGBE_VT_MSGTYPE_CTS; 607 msgbuf[0] &= ~(0xFF << IXGBE_VT_MSGINFO_SHIFT); 608 609 if (msgbuf[0] != (IXGBE_VF_SET_VLAN | IXGBE_VT_MSGTYPE_ACK)) 610 err = IXGBE_ERR_INVALID_ARGUMENT; 611 612 mbx_err: 613 return err; 614 } 615 616 /** 617 * ixgbevf_hv_set_vfta_vf - * Hyper-V variant - just a stub. 618 * @hw: unused 619 * @vlan: unused 620 * @vind: unused 621 * @vlan_on: unused 622 */ 623 static s32 ixgbevf_hv_set_vfta_vf(struct ixgbe_hw *hw, u32 vlan, u32 vind, 624 bool vlan_on) 625 { 626 return -EOPNOTSUPP; 627 } 628 629 /** 630 * ixgbevf_setup_mac_link_vf - Setup MAC link settings 631 * @hw: pointer to hardware structure 632 * @speed: Unused in this implementation 633 * @autoneg: Unused in this implementation 634 * @autoneg_wait_to_complete: Unused in this implementation 635 * 636 * Do nothing and return success. VF drivers are not allowed to change 637 * global settings. Maintained for driver compatibility. 638 **/ 639 static s32 ixgbevf_setup_mac_link_vf(struct ixgbe_hw *hw, 640 ixgbe_link_speed speed, bool autoneg, 641 bool autoneg_wait_to_complete) 642 { 643 return 0; 644 } 645 646 /** 647 * ixgbevf_check_mac_link_vf - Get link/speed status 648 * @hw: pointer to hardware structure 649 * @speed: pointer to link speed 650 * @link_up: true is link is up, false otherwise 651 * @autoneg_wait_to_complete: unused 652 * 653 * Reads the links register to determine if link is up and the current speed 654 **/ 655 static s32 ixgbevf_check_mac_link_vf(struct ixgbe_hw *hw, 656 ixgbe_link_speed *speed, 657 bool *link_up, 658 bool autoneg_wait_to_complete) 659 { 660 struct ixgbe_mbx_info *mbx = &hw->mbx; 661 struct ixgbe_mac_info *mac = &hw->mac; 662 s32 ret_val = 0; 663 u32 links_reg; 664 u32 in_msg = 0; 665 666 /* If we were hit with a reset drop the link */ 667 if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 668 mac->get_link_status = true; 669 670 if (!mac->get_link_status) 671 goto out; 672 673 /* if link status is down no point in checking to see if pf is up */ 674 links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 675 if (!(links_reg & IXGBE_LINKS_UP)) 676 goto out; 677 678 /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 679 * before the link status is correct 680 */ 681 if (mac->type == ixgbe_mac_82599_vf) { 682 int i; 683 684 for (i = 0; i < 5; i++) { 685 udelay(100); 686 links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 687 688 if (!(links_reg & IXGBE_LINKS_UP)) 689 goto out; 690 } 691 } 692 693 switch (links_reg & IXGBE_LINKS_SPEED_82599) { 694 case IXGBE_LINKS_SPEED_10G_82599: 695 *speed = IXGBE_LINK_SPEED_10GB_FULL; 696 break; 697 case IXGBE_LINKS_SPEED_1G_82599: 698 *speed = IXGBE_LINK_SPEED_1GB_FULL; 699 break; 700 case IXGBE_LINKS_SPEED_100_82599: 701 *speed = IXGBE_LINK_SPEED_100_FULL; 702 break; 703 } 704 705 /* if the read failed it could just be a mailbox collision, best wait 706 * until we are called again and don't report an error 707 */ 708 if (mbx->ops.read(hw, &in_msg, 1)) 709 goto out; 710 711 if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) { 712 /* msg is not CTS and is NACK we must have lost CTS status */ 713 if (in_msg & IXGBE_VT_MSGTYPE_NACK) 714 ret_val = -1; 715 goto out; 716 } 717 718 /* the pf is talking, if we timed out in the past we reinit */ 719 if (!mbx->timeout) { 720 ret_val = -1; 721 goto out; 722 } 723 724 /* if we passed all the tests above then the link is up and we no 725 * longer need to check for link 726 */ 727 mac->get_link_status = false; 728 729 out: 730 *link_up = !mac->get_link_status; 731 return ret_val; 732 } 733 734 /** 735 * ixgbevf_hv_check_mac_link_vf - check link 736 * @hw: pointer to private hardware struct 737 * @speed: pointer to link speed 738 * @link_up: true is link is up, false otherwise 739 * @autoneg_wait_to_complete: unused 740 * 741 * Hyper-V variant; there is no mailbox communication. 742 */ 743 static s32 ixgbevf_hv_check_mac_link_vf(struct ixgbe_hw *hw, 744 ixgbe_link_speed *speed, 745 bool *link_up, 746 bool autoneg_wait_to_complete) 747 { 748 struct ixgbe_mbx_info *mbx = &hw->mbx; 749 struct ixgbe_mac_info *mac = &hw->mac; 750 u32 links_reg; 751 752 /* If we were hit with a reset drop the link */ 753 if (!mbx->ops.check_for_rst(hw) || !mbx->timeout) 754 mac->get_link_status = true; 755 756 if (!mac->get_link_status) 757 goto out; 758 759 /* if link status is down no point in checking to see if pf is up */ 760 links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 761 if (!(links_reg & IXGBE_LINKS_UP)) 762 goto out; 763 764 /* for SFP+ modules and DA cables on 82599 it can take up to 500usecs 765 * before the link status is correct 766 */ 767 if (mac->type == ixgbe_mac_82599_vf) { 768 int i; 769 770 for (i = 0; i < 5; i++) { 771 udelay(100); 772 links_reg = IXGBE_READ_REG(hw, IXGBE_VFLINKS); 773 774 if (!(links_reg & IXGBE_LINKS_UP)) 775 goto out; 776 } 777 } 778 779 switch (links_reg & IXGBE_LINKS_SPEED_82599) { 780 case IXGBE_LINKS_SPEED_10G_82599: 781 *speed = IXGBE_LINK_SPEED_10GB_FULL; 782 break; 783 case IXGBE_LINKS_SPEED_1G_82599: 784 *speed = IXGBE_LINK_SPEED_1GB_FULL; 785 break; 786 case IXGBE_LINKS_SPEED_100_82599: 787 *speed = IXGBE_LINK_SPEED_100_FULL; 788 break; 789 } 790 791 /* if we passed all the tests above then the link is up and we no 792 * longer need to check for link 793 */ 794 mac->get_link_status = false; 795 796 out: 797 *link_up = !mac->get_link_status; 798 return 0; 799 } 800 801 /** 802 * ixgbevf_set_rlpml_vf - Set the maximum receive packet length 803 * @hw: pointer to the HW structure 804 * @max_size: value to assign to max frame size 805 **/ 806 static s32 ixgbevf_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 807 { 808 u32 msgbuf[2]; 809 s32 ret_val; 810 811 msgbuf[0] = IXGBE_VF_SET_LPE; 812 msgbuf[1] = max_size; 813 814 ret_val = ixgbevf_write_msg_read_ack(hw, msgbuf, msgbuf, 815 ARRAY_SIZE(msgbuf)); 816 if (ret_val) 817 return ret_val; 818 if ((msgbuf[0] & IXGBE_VF_SET_LPE) && 819 (msgbuf[0] & IXGBE_VT_MSGTYPE_NACK)) 820 return IXGBE_ERR_MBX; 821 822 return 0; 823 } 824 825 /** 826 * ixgbevf_hv_set_rlpml_vf - Set the maximum receive packet length 827 * @hw: pointer to the HW structure 828 * @max_size: value to assign to max frame size 829 * Hyper-V variant. 830 **/ 831 static s32 ixgbevf_hv_set_rlpml_vf(struct ixgbe_hw *hw, u16 max_size) 832 { 833 u32 reg; 834 835 /* If we are on Hyper-V, we implement this functionality 836 * differently. 837 */ 838 reg = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(0)); 839 /* CRC == 4 */ 840 reg |= ((max_size + 4) | IXGBE_RXDCTL_RLPML_EN); 841 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(0), reg); 842 843 return 0; 844 } 845 846 /** 847 * ixgbevf_negotiate_api_version_vf - Negotiate supported API version 848 * @hw: pointer to the HW structure 849 * @api: integer containing requested API version 850 **/ 851 static int ixgbevf_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 852 { 853 int err; 854 u32 msg[3]; 855 856 /* Negotiate the mailbox API version */ 857 msg[0] = IXGBE_VF_API_NEGOTIATE; 858 msg[1] = api; 859 msg[2] = 0; 860 861 err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg)); 862 if (!err) { 863 msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 864 865 /* Store value and return 0 on success */ 866 if (msg[0] == (IXGBE_VF_API_NEGOTIATE | IXGBE_VT_MSGTYPE_ACK)) { 867 hw->api_version = api; 868 return 0; 869 } 870 871 err = IXGBE_ERR_INVALID_ARGUMENT; 872 } 873 874 return err; 875 } 876 877 /** 878 * ixgbevf_hv_negotiate_api_version_vf - Negotiate supported API version 879 * @hw: pointer to the HW structure 880 * @api: integer containing requested API version 881 * Hyper-V version - only ixgbe_mbox_api_10 supported. 882 **/ 883 static int ixgbevf_hv_negotiate_api_version_vf(struct ixgbe_hw *hw, int api) 884 { 885 /* Hyper-V only supports api version ixgbe_mbox_api_10 */ 886 if (api != ixgbe_mbox_api_10) 887 return IXGBE_ERR_INVALID_ARGUMENT; 888 889 return 0; 890 } 891 892 int ixgbevf_get_queues(struct ixgbe_hw *hw, unsigned int *num_tcs, 893 unsigned int *default_tc) 894 { 895 int err; 896 u32 msg[5]; 897 898 /* do nothing if API doesn't support ixgbevf_get_queues */ 899 switch (hw->api_version) { 900 case ixgbe_mbox_api_11: 901 case ixgbe_mbox_api_12: 902 case ixgbe_mbox_api_13: 903 case ixgbe_mbox_api_14: 904 break; 905 default: 906 return 0; 907 } 908 909 /* Fetch queue configuration from the PF */ 910 msg[0] = IXGBE_VF_GET_QUEUE; 911 msg[1] = msg[2] = msg[3] = msg[4] = 0; 912 913 err = ixgbevf_write_msg_read_ack(hw, msg, msg, ARRAY_SIZE(msg)); 914 if (!err) { 915 msg[0] &= ~IXGBE_VT_MSGTYPE_CTS; 916 917 /* if we we didn't get an ACK there must have been 918 * some sort of mailbox error so we should treat it 919 * as such 920 */ 921 if (msg[0] != (IXGBE_VF_GET_QUEUE | IXGBE_VT_MSGTYPE_ACK)) 922 return IXGBE_ERR_MBX; 923 924 /* record and validate values from message */ 925 hw->mac.max_tx_queues = msg[IXGBE_VF_TX_QUEUES]; 926 if (hw->mac.max_tx_queues == 0 || 927 hw->mac.max_tx_queues > IXGBE_VF_MAX_TX_QUEUES) 928 hw->mac.max_tx_queues = IXGBE_VF_MAX_TX_QUEUES; 929 930 hw->mac.max_rx_queues = msg[IXGBE_VF_RX_QUEUES]; 931 if (hw->mac.max_rx_queues == 0 || 932 hw->mac.max_rx_queues > IXGBE_VF_MAX_RX_QUEUES) 933 hw->mac.max_rx_queues = IXGBE_VF_MAX_RX_QUEUES; 934 935 *num_tcs = msg[IXGBE_VF_TRANS_VLAN]; 936 /* in case of unknown state assume we cannot tag frames */ 937 if (*num_tcs > hw->mac.max_rx_queues) 938 *num_tcs = 1; 939 940 *default_tc = msg[IXGBE_VF_DEF_QUEUE]; 941 /* default to queue 0 on out-of-bounds queue number */ 942 if (*default_tc >= hw->mac.max_tx_queues) 943 *default_tc = 0; 944 } 945 946 return err; 947 } 948 949 static const struct ixgbe_mac_operations ixgbevf_mac_ops = { 950 .init_hw = ixgbevf_init_hw_vf, 951 .reset_hw = ixgbevf_reset_hw_vf, 952 .start_hw = ixgbevf_start_hw_vf, 953 .get_mac_addr = ixgbevf_get_mac_addr_vf, 954 .stop_adapter = ixgbevf_stop_hw_vf, 955 .setup_link = ixgbevf_setup_mac_link_vf, 956 .check_link = ixgbevf_check_mac_link_vf, 957 .negotiate_api_version = ixgbevf_negotiate_api_version_vf, 958 .set_rar = ixgbevf_set_rar_vf, 959 .update_mc_addr_list = ixgbevf_update_mc_addr_list_vf, 960 .update_xcast_mode = ixgbevf_update_xcast_mode, 961 .set_uc_addr = ixgbevf_set_uc_addr_vf, 962 .set_vfta = ixgbevf_set_vfta_vf, 963 .set_rlpml = ixgbevf_set_rlpml_vf, 964 }; 965 966 static const struct ixgbe_mac_operations ixgbevf_hv_mac_ops = { 967 .init_hw = ixgbevf_init_hw_vf, 968 .reset_hw = ixgbevf_hv_reset_hw_vf, 969 .start_hw = ixgbevf_start_hw_vf, 970 .get_mac_addr = ixgbevf_get_mac_addr_vf, 971 .stop_adapter = ixgbevf_stop_hw_vf, 972 .setup_link = ixgbevf_setup_mac_link_vf, 973 .check_link = ixgbevf_hv_check_mac_link_vf, 974 .negotiate_api_version = ixgbevf_hv_negotiate_api_version_vf, 975 .set_rar = ixgbevf_hv_set_rar_vf, 976 .update_mc_addr_list = ixgbevf_hv_update_mc_addr_list_vf, 977 .update_xcast_mode = ixgbevf_hv_update_xcast_mode, 978 .set_uc_addr = ixgbevf_hv_set_uc_addr_vf, 979 .set_vfta = ixgbevf_hv_set_vfta_vf, 980 .set_rlpml = ixgbevf_hv_set_rlpml_vf, 981 }; 982 983 const struct ixgbevf_info ixgbevf_82599_vf_info = { 984 .mac = ixgbe_mac_82599_vf, 985 .mac_ops = &ixgbevf_mac_ops, 986 }; 987 988 const struct ixgbevf_info ixgbevf_82599_vf_hv_info = { 989 .mac = ixgbe_mac_82599_vf, 990 .mac_ops = &ixgbevf_hv_mac_ops, 991 }; 992 993 const struct ixgbevf_info ixgbevf_X540_vf_info = { 994 .mac = ixgbe_mac_X540_vf, 995 .mac_ops = &ixgbevf_mac_ops, 996 }; 997 998 const struct ixgbevf_info ixgbevf_X540_vf_hv_info = { 999 .mac = ixgbe_mac_X540_vf, 1000 .mac_ops = &ixgbevf_hv_mac_ops, 1001 }; 1002 1003 const struct ixgbevf_info ixgbevf_X550_vf_info = { 1004 .mac = ixgbe_mac_X550_vf, 1005 .mac_ops = &ixgbevf_mac_ops, 1006 }; 1007 1008 const struct ixgbevf_info ixgbevf_X550_vf_hv_info = { 1009 .mac = ixgbe_mac_X550_vf, 1010 .mac_ops = &ixgbevf_hv_mac_ops, 1011 }; 1012 1013 const struct ixgbevf_info ixgbevf_X550EM_x_vf_info = { 1014 .mac = ixgbe_mac_X550EM_x_vf, 1015 .mac_ops = &ixgbevf_mac_ops, 1016 }; 1017 1018 const struct ixgbevf_info ixgbevf_X550EM_x_vf_hv_info = { 1019 .mac = ixgbe_mac_X550EM_x_vf, 1020 .mac_ops = &ixgbevf_hv_mac_ops, 1021 }; 1022 1023 const struct ixgbevf_info ixgbevf_x550em_a_vf_info = { 1024 .mac = ixgbe_mac_x550em_a_vf, 1025 .mac_ops = &ixgbevf_mac_ops, 1026 }; 1027