drivers/net/ixgbe/rte_pmd_ixgbe.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2017 Intel Corporation
   3  */
   4
   5 #include <rte_ethdev_driver.h>
   6
   7 #include "base/ixgbe_api.h"
   8 #include "base/ixgbe_x550.h"
   9 #include "ixgbe_ethdev.h"
  10 #include "rte_pmd_ixgbe.h"
  11
  12 int
  13 rte_pmd_ixgbe_set_vf_mac_addr(uint16_t port, uint16_t vf,
  14                               struct rte_ether_addr *mac_addr)
  15 {
  16         struct ixgbe_hw *hw;
  17         struct ixgbe_vf_info *vfinfo;
  18         int rar_entry;
  19         uint8_t *new_mac = (uint8_t *)(mac_addr);
  20         struct rte_eth_dev *dev;
  21         struct rte_pci_device *pci_dev;
  22
  23         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
  24
  25         dev = &rte_eth_devices[port];
  26         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
  27
  28         if (!is_ixgbe_supported(dev))
  29                 return -ENOTSUP;
  30
  31         if (vf >= pci_dev->max_vfs)
  32                 return -EINVAL;
  33
  34         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
  35         vfinfo = *(IXGBE_DEV_PRIVATE_TO_P_VFDATA(dev->data->dev_private));
  36         rar_entry = hw->mac.num_rar_entries - (vf + 1);
  37
  38         if (rte_is_valid_assigned_ether_addr(
  39                         (struct rte_ether_addr *)new_mac)) {
  40                 rte_memcpy(vfinfo[vf].vf_mac_addresses, new_mac,
  41                            RTE_ETHER_ADDR_LEN);
  42                 return hw->mac.ops.set_rar(hw, rar_entry, new_mac, vf,
  43                                            IXGBE_RAH_AV);
  44         }
  45         return -EINVAL;
  46 }
  47
  48 int
  49 rte_pmd_ixgbe_ping_vf(uint16_t port, uint16_t vf)
  50 {
  51         struct ixgbe_hw *hw;
  52         struct ixgbe_vf_info *vfinfo;
  53         struct rte_eth_dev *dev;
  54         struct rte_pci_device *pci_dev;
  55         uint32_t ctrl;
  56
  57         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
  58
  59         dev = &rte_eth_devices[port];
  60         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
  61
  62         if (!is_ixgbe_supported(dev))
  63                 return -ENOTSUP;
  64
  65         if (vf >= pci_dev->max_vfs)
  66                 return -EINVAL;
  67
  68         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
  69         vfinfo = *(IXGBE_DEV_PRIVATE_TO_P_VFDATA(dev->data->dev_private));
  70
  71         ctrl = IXGBE_PF_CONTROL_MSG;
  72         if (vfinfo[vf].clear_to_send)
  73                 ctrl |= IXGBE_VT_MSGTYPE_CTS;
  74
  75         ixgbe_write_mbx(hw, &ctrl, 1, vf);
  76
  77         return 0;
  78 }
  79
  80 int
  81 rte_pmd_ixgbe_set_vf_vlan_anti_spoof(uint16_t port, uint16_t vf, uint8_t on)
  82 {
  83         struct ixgbe_hw *hw;
  84         struct ixgbe_mac_info *mac;
  85         struct rte_eth_dev *dev;
  86         struct rte_pci_device *pci_dev;
  87
  88         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
  89
  90         dev = &rte_eth_devices[port];
  91         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
  92
  93         if (!is_ixgbe_supported(dev))
  94                 return -ENOTSUP;
  95
  96         if (vf >= pci_dev->max_vfs)
  97                 return -EINVAL;
  98
  99         if (on > 1)
 100                 return -EINVAL;
 101
 102         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 103         mac = &hw->mac;
 104
 105         mac->ops.set_vlan_anti_spoofing(hw, on, vf);
 106
 107         return 0;
 108 }
 109
 110 int
 111 rte_pmd_ixgbe_set_vf_mac_anti_spoof(uint16_t port, uint16_t vf, uint8_t on)
 112 {
 113         struct ixgbe_hw *hw;
 114         struct ixgbe_mac_info *mac;
 115         struct rte_eth_dev *dev;
 116         struct rte_pci_device *pci_dev;
 117
 118         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 119
 120         dev = &rte_eth_devices[port];
 121         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 122
 123         if (!is_ixgbe_supported(dev))
 124                 return -ENOTSUP;
 125
 126         if (vf >= pci_dev->max_vfs)
 127                 return -EINVAL;
 128
 129         if (on > 1)
 130                 return -EINVAL;
 131
 132         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 133         mac = &hw->mac;
 134         mac->ops.set_mac_anti_spoofing(hw, on, vf);
 135
 136         return 0;
 137 }
 138
 139 int
 140 rte_pmd_ixgbe_set_vf_vlan_insert(uint16_t port, uint16_t vf, uint16_t vlan_id)
 141 {
 142         struct ixgbe_hw *hw;
 143         uint32_t ctrl;
 144         struct rte_eth_dev *dev;
 145         struct rte_pci_device *pci_dev;
 146
 147         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 148
 149         dev = &rte_eth_devices[port];
 150         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 151
 152         if (!is_ixgbe_supported(dev))
 153                 return -ENOTSUP;
 154
 155         if (vf >= pci_dev->max_vfs)
 156                 return -EINVAL;
 157
 158         if (vlan_id > RTE_ETHER_MAX_VLAN_ID)
 159                 return -EINVAL;
 160
 161         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 162         ctrl = IXGBE_READ_REG(hw, IXGBE_VMVIR(vf));
 163         if (vlan_id) {
 164                 ctrl = vlan_id;
 165                 ctrl |= IXGBE_VMVIR_VLANA_DEFAULT;
 166         } else {
 167                 ctrl = 0;
 168         }
 169
 170         IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf), ctrl);
 171
 172         return 0;
 173 }
 174
 175 int
 176 rte_pmd_ixgbe_set_tx_loopback(uint16_t port, uint8_t on)
 177 {
 178         struct ixgbe_hw *hw;
 179         uint32_t ctrl;
 180         struct rte_eth_dev *dev;
 181
 182         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 183
 184         dev = &rte_eth_devices[port];
 185
 186         if (!is_ixgbe_supported(dev))
 187                 return -ENOTSUP;
 188
 189         if (on > 1)
 190                 return -EINVAL;
 191
 192         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 193         ctrl = IXGBE_READ_REG(hw, IXGBE_PFDTXGSWC);
 194         /* enable or disable VMDQ loopback */
 195         if (on)
 196                 ctrl |= IXGBE_PFDTXGSWC_VT_LBEN;
 197         else
 198                 ctrl &= ~IXGBE_PFDTXGSWC_VT_LBEN;
 199
 200         IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, ctrl);
 201
 202         return 0;
 203 }
 204
 205 int
 206 rte_pmd_ixgbe_set_all_queues_drop_en(uint16_t port, uint8_t on)
 207 {
 208         struct ixgbe_hw *hw;
 209         uint32_t reg_value;
 210         int i;
 211         int num_queues = (int)(IXGBE_QDE_IDX_MASK >> IXGBE_QDE_IDX_SHIFT);
 212         struct rte_eth_dev *dev;
 213
 214         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 215
 216         dev = &rte_eth_devices[port];
 217
 218         if (!is_ixgbe_supported(dev))
 219                 return -ENOTSUP;
 220
 221         if (on > 1)
 222                 return -EINVAL;
 223
 224         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 225         for (i = 0; i <= num_queues; i++) {
 226                 reg_value = IXGBE_QDE_WRITE |
 227                                 (i << IXGBE_QDE_IDX_SHIFT) |
 228                                 (on & IXGBE_QDE_ENABLE);
 229                 IXGBE_WRITE_REG(hw, IXGBE_QDE, reg_value);
 230         }
 231
 232         return 0;
 233 }
 234
 235 int
 236 rte_pmd_ixgbe_set_vf_split_drop_en(uint16_t port, uint16_t vf, uint8_t on)
 237 {
 238         struct ixgbe_hw *hw;
 239         uint32_t reg_value;
 240         struct rte_eth_dev *dev;
 241         struct rte_pci_device *pci_dev;
 242
 243         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 244
 245         dev = &rte_eth_devices[port];
 246         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 247
 248         if (!is_ixgbe_supported(dev))
 249                 return -ENOTSUP;
 250
 251         /* only support VF's 0 to 63 */
 252         if ((vf >= pci_dev->max_vfs) || (vf > 63))
 253                 return -EINVAL;
 254
 255         if (on > 1)
 256                 return -EINVAL;
 257
 258         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 259         reg_value = IXGBE_READ_REG(hw, IXGBE_SRRCTL(vf));
 260         if (on)
 261                 reg_value |= IXGBE_SRRCTL_DROP_EN;
 262         else
 263                 reg_value &= ~IXGBE_SRRCTL_DROP_EN;
 264
 265         IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(vf), reg_value);
 266
 267         return 0;
 268 }
 269
 270 int
 271 rte_pmd_ixgbe_set_vf_vlan_stripq(uint16_t port, uint16_t vf, uint8_t on)
 272 {
 273         struct rte_eth_dev *dev;
 274         struct rte_pci_device *pci_dev;
 275         struct ixgbe_hw *hw;
 276         uint16_t queues_per_pool;
 277         uint32_t q;
 278
 279         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 280
 281         dev = &rte_eth_devices[port];
 282         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 283         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 284
 285         if (!is_ixgbe_supported(dev))
 286                 return -ENOTSUP;
 287
 288         if (vf >= pci_dev->max_vfs)
 289                 return -EINVAL;
 290
 291         if (on > 1)
 292                 return -EINVAL;
 293
 294         RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->vlan_strip_queue_set, -ENOTSUP);
 295
 296         /* The PF has 128 queue pairs and in SRIOV configuration
 297          * those queues will be assigned to VF's, so RXDCTL
 298          * registers will be dealing with queues which will be
 299          * assigned to VF's.
 300          * Let's say we have SRIOV configured with 31 VF's then the
 301          * first 124 queues 0-123 will be allocated to VF's and only
 302          * the last 4 queues 123-127 will be assigned to the PF.
 303          */
 304         if (hw->mac.type == ixgbe_mac_82598EB)
 305                 queues_per_pool = (uint16_t)hw->mac.max_rx_queues /
 306                                   ETH_16_POOLS;
 307         else
 308                 queues_per_pool = (uint16_t)hw->mac.max_rx_queues /
 309                                   ETH_64_POOLS;
 310
 311         for (q = 0; q < queues_per_pool; q++)
 312                 (*dev->dev_ops->vlan_strip_queue_set)(dev,
 313                                 q + vf * queues_per_pool, on);
 314         return 0;
 315 }
 316
 317 int
 318 rte_pmd_ixgbe_set_vf_rxmode(uint16_t port, uint16_t vf,
 319                             uint16_t rx_mask, uint8_t on)
 320 {
 321         int val = 0;
 322         struct rte_eth_dev *dev;
 323         struct rte_pci_device *pci_dev;
 324         struct ixgbe_hw *hw;
 325         uint32_t vmolr;
 326
 327         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 328
 329         dev = &rte_eth_devices[port];
 330         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 331
 332         if (!is_ixgbe_supported(dev))
 333                 return -ENOTSUP;
 334
 335         if (vf >= pci_dev->max_vfs)
 336                 return -EINVAL;
 337
 338         if (on > 1)
 339                 return -EINVAL;
 340
 341         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 342         vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf));
 343
 344         if (hw->mac.type == ixgbe_mac_82598EB) {
 345                 PMD_INIT_LOG(ERR, "setting VF receive mode set should be done"
 346                              " on 82599 hardware and newer");
 347                 return -ENOTSUP;
 348         }
 349         if (ixgbe_vt_check(hw) < 0)
 350                 return -ENOTSUP;
 351
 352         val = ixgbe_convert_vm_rx_mask_to_val(rx_mask, val);
 353
 354         if (on)
 355                 vmolr |= val;
 356         else
 357                 vmolr &= ~val;
 358
 359         IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf), vmolr);
 360
 361         return 0;
 362 }
 363
 364 int
 365 rte_pmd_ixgbe_set_vf_rx(uint16_t port, uint16_t vf, uint8_t on)
 366 {
 367         struct rte_eth_dev *dev;
 368         struct rte_pci_device *pci_dev;
 369         uint32_t reg, addr;
 370         uint32_t val;
 371         const uint8_t bit1 = 0x1;
 372         struct ixgbe_hw *hw;
 373
 374         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 375
 376         dev = &rte_eth_devices[port];
 377         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 378
 379         if (!is_ixgbe_supported(dev))
 380                 return -ENOTSUP;
 381
 382         if (vf >= pci_dev->max_vfs)
 383                 return -EINVAL;
 384
 385         if (on > 1)
 386                 return -EINVAL;
 387
 388         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 389
 390         if (ixgbe_vt_check(hw) < 0)
 391                 return -ENOTSUP;
 392
 393         /* for vf >= 32, set bit in PFVFRE[1], otherwise PFVFRE[0] */
 394         if (vf >= 32) {
 395                 addr = IXGBE_VFRE(1);
 396                 val = bit1 << (vf - 32);
 397         } else {
 398                 addr = IXGBE_VFRE(0);
 399                 val = bit1 << vf;
 400         }
 401
 402         reg = IXGBE_READ_REG(hw, addr);
 403
 404         if (on)
 405                 reg |= val;
 406         else
 407                 reg &= ~val;
 408
 409         IXGBE_WRITE_REG(hw, addr, reg);
 410
 411         return 0;
 412 }
 413
 414 int
 415 rte_pmd_ixgbe_set_vf_tx(uint16_t port, uint16_t vf, uint8_t on)
 416 {
 417         struct rte_eth_dev *dev;
 418         struct rte_pci_device *pci_dev;
 419         uint32_t reg, addr;
 420         uint32_t val;
 421         const uint8_t bit1 = 0x1;
 422
 423         struct ixgbe_hw *hw;
 424
 425         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 426
 427         dev = &rte_eth_devices[port];
 428         pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 429
 430         if (!is_ixgbe_supported(dev))
 431                 return -ENOTSUP;
 432
 433         if (vf >= pci_dev->max_vfs)
 434                 return -EINVAL;
 435
 436         if (on > 1)
 437                 return -EINVAL;
 438
 439         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 440         if (ixgbe_vt_check(hw) < 0)
 441                 return -ENOTSUP;
 442
 443         /* for vf >= 32, set bit in PFVFTE[1], otherwise PFVFTE[0] */
 444         if (vf >= 32) {
 445                 addr = IXGBE_VFTE(1);
 446                 val = bit1 << (vf - 32);
 447         } else {
 448                 addr = IXGBE_VFTE(0);
 449                 val = bit1 << vf;
 450         }
 451
 452         reg = IXGBE_READ_REG(hw, addr);
 453
 454         if (on)
 455                 reg |= val;
 456         else
 457                 reg &= ~val;
 458
 459         IXGBE_WRITE_REG(hw, addr, reg);
 460
 461         return 0;
 462 }
 463
 464 int
 465 rte_pmd_ixgbe_set_vf_vlan_filter(uint16_t port, uint16_t vlan,
 466                                  uint64_t vf_mask, uint8_t vlan_on)
 467 {
 468         struct rte_eth_dev *dev;
 469         int ret = 0;
 470         uint16_t vf_idx;
 471         struct ixgbe_hw *hw;
 472
 473         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 474
 475         dev = &rte_eth_devices[port];
 476
 477         if (!is_ixgbe_supported(dev))
 478                 return -ENOTSUP;
 479
 480         if (vlan > RTE_ETHER_MAX_VLAN_ID || vf_mask == 0)
 481                 return -EINVAL;
 482
 483         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 484         if (ixgbe_vt_check(hw) < 0)
 485                 return -ENOTSUP;
 486
 487         for (vf_idx = 0; vf_idx < 64; vf_idx++) {
 488                 if (vf_mask & ((uint64_t)(1ULL << vf_idx))) {
 489                         ret = hw->mac.ops.set_vfta(hw, vlan, vf_idx,
 490                                                    vlan_on, false);
 491                         if (ret < 0)
 492                                 return ret;
 493                 }
 494         }
 495
 496         return ret;
 497 }
 498
 499 int
 500 rte_pmd_ixgbe_set_vf_rate_limit(uint16_t port, uint16_t vf,
 501                                 uint16_t tx_rate, uint64_t q_msk)
 502 {
 503         struct rte_eth_dev *dev;
 504
 505         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 506
 507         dev = &rte_eth_devices[port];
 508
 509         if (!is_ixgbe_supported(dev))
 510                 return -ENOTSUP;
 511
 512         return ixgbe_set_vf_rate_limit(dev, vf, tx_rate, q_msk);
 513 }
 514
 515 int
 516 rte_pmd_ixgbe_macsec_enable(uint16_t port, uint8_t en, uint8_t rp)
 517 {
 518         struct rte_eth_dev *dev;
 519         struct ixgbe_macsec_setting macsec_setting;
 520
 521         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 522
 523         dev = &rte_eth_devices[port];
 524
 525         macsec_setting.encrypt_en = en;
 526         macsec_setting.replayprotect_en = rp;
 527
 528         ixgbe_dev_macsec_setting_save(dev, &macsec_setting);
 529
 530         ixgbe_dev_macsec_register_enable(dev, &macsec_setting);
 531
 532         return 0;
 533 }
 534
 535 int
 536 rte_pmd_ixgbe_macsec_disable(uint16_t port)
 537 {
 538         struct rte_eth_dev *dev;
 539
 540         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 541
 542         dev = &rte_eth_devices[port];
 543
 544         ixgbe_dev_macsec_setting_reset(dev);
 545
 546         ixgbe_dev_macsec_register_disable(dev);
 547
 548         return 0;
 549 }
 550
 551 int
 552 rte_pmd_ixgbe_macsec_config_txsc(uint16_t port, uint8_t *mac)
 553 {
 554         struct ixgbe_hw *hw;
 555         struct rte_eth_dev *dev;
 556         uint32_t ctrl;
 557
 558         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 559
 560         dev = &rte_eth_devices[port];
 561
 562         if (!is_ixgbe_supported(dev))
 563                 return -ENOTSUP;
 564
 565         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 566
 567         ctrl = mac[0] | (mac[1] << 8) | (mac[2] << 16) | (mac[3] << 24);
 568         IXGBE_WRITE_REG(hw, IXGBE_LSECTXSCL, ctrl);
 569
 570         ctrl = mac[4] | (mac[5] << 8);
 571         IXGBE_WRITE_REG(hw, IXGBE_LSECTXSCH, ctrl);
 572
 573         return 0;
 574 }
 575
 576 int
 577 rte_pmd_ixgbe_macsec_config_rxsc(uint16_t port, uint8_t *mac, uint16_t pi)
 578 {
 579         struct ixgbe_hw *hw;
 580         struct rte_eth_dev *dev;
 581         uint32_t ctrl;
 582
 583         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 584
 585         dev = &rte_eth_devices[port];
 586
 587         if (!is_ixgbe_supported(dev))
 588                 return -ENOTSUP;
 589
 590         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 591
 592         ctrl = mac[0] | (mac[1] << 8) | (mac[2] << 16) | (mac[3] << 24);
 593         IXGBE_WRITE_REG(hw, IXGBE_LSECRXSCL, ctrl);
 594
 595         pi = rte_cpu_to_be_16(pi);
 596         ctrl = mac[4] | (mac[5] << 8) | (pi << 16);
 597         IXGBE_WRITE_REG(hw, IXGBE_LSECRXSCH, ctrl);
 598
 599         return 0;
 600 }
 601
 602 int
 603 rte_pmd_ixgbe_macsec_select_txsa(uint16_t port, uint8_t idx, uint8_t an,
 604                                  uint32_t pn, uint8_t *key)
 605 {
 606         struct ixgbe_hw *hw;
 607         struct rte_eth_dev *dev;
 608         uint32_t ctrl, i;
 609
 610         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 611
 612         dev = &rte_eth_devices[port];
 613
 614         if (!is_ixgbe_supported(dev))
 615                 return -ENOTSUP;
 616
 617         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 618
 619         if (idx != 0 && idx != 1)
 620                 return -EINVAL;
 621
 622         if (an >= 4)
 623                 return -EINVAL;
 624
 625         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 626
 627         /* Set the PN and key */
 628         pn = rte_cpu_to_be_32(pn);
 629         if (idx == 0) {
 630                 IXGBE_WRITE_REG(hw, IXGBE_LSECTXPN0, pn);
 631
 632                 for (i = 0; i < 4; i++) {
 633                         ctrl = (key[i * 4 + 0] <<  0) |
 634                                (key[i * 4 + 1] <<  8) |
 635                                (key[i * 4 + 2] << 16) |
 636                                (key[i * 4 + 3] << 24);
 637                         IXGBE_WRITE_REG(hw, IXGBE_LSECTXKEY0(i), ctrl);
 638                 }
 639         } else {
 640                 IXGBE_WRITE_REG(hw, IXGBE_LSECTXPN1, pn);
 641
 642                 for (i = 0; i < 4; i++) {
 643                         ctrl = (key[i * 4 + 0] <<  0) |
 644                                (key[i * 4 + 1] <<  8) |
 645                                (key[i * 4 + 2] << 16) |
 646                                (key[i * 4 + 3] << 24);
 647                         IXGBE_WRITE_REG(hw, IXGBE_LSECTXKEY1(i), ctrl);
 648                 }
 649         }
 650
 651         /* Set AN and select the SA */
 652         ctrl = (an << idx * 2) | (idx << 4);
 653         IXGBE_WRITE_REG(hw, IXGBE_LSECTXSA, ctrl);
 654
 655         return 0;
 656 }
 657
 658 int
 659 rte_pmd_ixgbe_macsec_select_rxsa(uint16_t port, uint8_t idx, uint8_t an,
 660                                  uint32_t pn, uint8_t *key)
 661 {
 662         struct ixgbe_hw *hw;
 663         struct rte_eth_dev *dev;
 664         uint32_t ctrl, i;
 665
 666         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 667
 668         dev = &rte_eth_devices[port];
 669
 670         if (!is_ixgbe_supported(dev))
 671                 return -ENOTSUP;
 672
 673         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 674
 675         if (idx != 0 && idx != 1)
 676                 return -EINVAL;
 677
 678         if (an >= 4)
 679                 return -EINVAL;
 680
 681         /* Set the PN */
 682         pn = rte_cpu_to_be_32(pn);
 683         IXGBE_WRITE_REG(hw, IXGBE_LSECRXPN(idx), pn);
 684
 685         /* Set the key */
 686         for (i = 0; i < 4; i++) {
 687                 ctrl = (key[i * 4 + 0] <<  0) |
 688                        (key[i * 4 + 1] <<  8) |
 689                        (key[i * 4 + 2] << 16) |
 690                        (key[i * 4 + 3] << 24);
 691                 IXGBE_WRITE_REG(hw, IXGBE_LSECRXKEY(idx, i), ctrl);
 692         }
 693
 694         /* Set the AN and validate the SA */
 695         ctrl = an | (1 << 2);
 696         IXGBE_WRITE_REG(hw, IXGBE_LSECRXSA(idx), ctrl);
 697
 698         return 0;
 699 }
 700
 701 int
 702 rte_pmd_ixgbe_set_tc_bw_alloc(uint16_t port,
 703                               uint8_t tc_num,
 704                               uint8_t *bw_weight)
 705 {
 706         struct rte_eth_dev *dev;
 707         struct ixgbe_dcb_config *dcb_config;
 708         struct ixgbe_dcb_tc_config *tc;
 709         struct rte_eth_conf *eth_conf;
 710         struct ixgbe_bw_conf *bw_conf;
 711         uint8_t i;
 712         uint8_t nb_tcs;
 713         uint16_t sum;
 714
 715         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 716
 717         dev = &rte_eth_devices[port];
 718
 719         if (!is_ixgbe_supported(dev))
 720                 return -ENOTSUP;
 721
 722         if (tc_num > IXGBE_DCB_MAX_TRAFFIC_CLASS) {
 723                 PMD_DRV_LOG(ERR, "TCs should be no more than %d.",
 724                             IXGBE_DCB_MAX_TRAFFIC_CLASS);
 725                 return -EINVAL;
 726         }
 727
 728         dcb_config = IXGBE_DEV_PRIVATE_TO_DCB_CFG(dev->data->dev_private);
 729         bw_conf = IXGBE_DEV_PRIVATE_TO_BW_CONF(dev->data->dev_private);
 730         eth_conf = &dev->data->dev_conf;
 731
 732         if (eth_conf->txmode.mq_mode == ETH_MQ_TX_DCB) {
 733                 nb_tcs = eth_conf->tx_adv_conf.dcb_tx_conf.nb_tcs;
 734         } else if (eth_conf->txmode.mq_mode == ETH_MQ_TX_VMDQ_DCB) {
 735                 if (eth_conf->tx_adv_conf.vmdq_dcb_tx_conf.nb_queue_pools ==
 736                     ETH_32_POOLS)
 737                         nb_tcs = ETH_4_TCS;
 738                 else
 739                         nb_tcs = ETH_8_TCS;
 740         } else {
 741                 nb_tcs = 1;
 742         }
 743
 744         if (nb_tcs != tc_num) {
 745                 PMD_DRV_LOG(ERR,
 746                             "Weight should be set for all %d enabled TCs.",
 747                             nb_tcs);
 748                 return -EINVAL;
 749         }
 750
 751         sum = 0;
 752         for (i = 0; i < nb_tcs; i++)
 753                 sum += bw_weight[i];
 754         if (sum != 100) {
 755                 PMD_DRV_LOG(ERR,
 756                             "The summary of the TC weight should be 100.");
 757                 return -EINVAL;
 758         }
 759
 760         for (i = 0; i < nb_tcs; i++) {
 761                 tc = &dcb_config->tc_config[i];
 762                 tc->path[IXGBE_DCB_TX_CONFIG].bwg_percent = bw_weight[i];
 763         }
 764         for (; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
 765                 tc = &dcb_config->tc_config[i];
 766                 tc->path[IXGBE_DCB_TX_CONFIG].bwg_percent = 0;
 767         }
 768
 769         bw_conf->tc_num = nb_tcs;
 770
 771         return 0;
 772 }
 773
 774 int
 775 rte_pmd_ixgbe_upd_fctrl_sbp(uint16_t port, int enable)
 776 {
 777         struct ixgbe_hw *hw;
 778         struct rte_eth_dev *dev;
 779         uint32_t fctrl;
 780
 781         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 782         dev = &rte_eth_devices[port];
 783         if (!is_ixgbe_supported(dev))
 784                 return -ENOTSUP;
 785
 786         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
 787         if (!hw)
 788                 return -ENOTSUP;
 789
 790         fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
 791
 792         /* If 'enable' set the SBP bit else clear it */
 793         if (enable)
 794                 fctrl |= IXGBE_FCTRL_SBP;
 795         else
 796                 fctrl &= ~(IXGBE_FCTRL_SBP);
 797
 798         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
 799         return 0;
 800 }
 801
 802 #ifdef RTE_LIBRTE_IXGBE_BYPASS
 803 int
 804 rte_pmd_ixgbe_bypass_init(uint16_t port_id)
 805 {
 806         struct rte_eth_dev *dev;
 807
 808         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 809
 810         dev = &rte_eth_devices[port_id];
 811         if (!is_ixgbe_supported(dev))
 812                 return -ENOTSUP;
 813
 814         ixgbe_bypass_init(dev);
 815         return 0;
 816 }
 817
 818 int
 819 rte_pmd_ixgbe_bypass_state_show(uint16_t port_id, uint32_t *state)
 820 {
 821         struct rte_eth_dev *dev;
 822
 823         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 824
 825         dev = &rte_eth_devices[port_id];
 826         if (!is_ixgbe_supported(dev))
 827                 return -ENOTSUP;
 828
 829         return ixgbe_bypass_state_show(dev, state);
 830 }
 831
 832 int
 833 rte_pmd_ixgbe_bypass_state_set(uint16_t port_id, uint32_t *new_state)
 834 {
 835         struct rte_eth_dev *dev;
 836
 837         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 838
 839         dev = &rte_eth_devices[port_id];
 840         if (!is_ixgbe_supported(dev))
 841                 return -ENOTSUP;
 842
 843         return ixgbe_bypass_state_store(dev, new_state);
 844 }
 845
 846 int
 847 rte_pmd_ixgbe_bypass_event_show(uint16_t port_id,
 848                                 uint32_t event,
 849                                 uint32_t *state)
 850 {
 851         struct rte_eth_dev *dev;
 852
 853         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 854
 855         dev = &rte_eth_devices[port_id];
 856         if (!is_ixgbe_supported(dev))
 857                 return -ENOTSUP;
 858
 859         return ixgbe_bypass_event_show(dev, event, state);
 860 }
 861
 862 int
 863 rte_pmd_ixgbe_bypass_event_store(uint16_t port_id,
 864                                  uint32_t event,
 865                                  uint32_t state)
 866 {
 867         struct rte_eth_dev *dev;
 868
 869         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 870
 871         dev = &rte_eth_devices[port_id];
 872         if (!is_ixgbe_supported(dev))
 873                 return -ENOTSUP;
 874
 875         return ixgbe_bypass_event_store(dev, event, state);
 876 }
 877
 878 int
 879 rte_pmd_ixgbe_bypass_wd_timeout_store(uint16_t port_id, uint32_t timeout)
 880 {
 881         struct rte_eth_dev *dev;
 882
 883         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 884
 885         dev = &rte_eth_devices[port_id];
 886         if (!is_ixgbe_supported(dev))
 887                 return -ENOTSUP;
 888
 889         return ixgbe_bypass_wd_timeout_store(dev, timeout);
 890 }
 891
 892 int
 893 rte_pmd_ixgbe_bypass_ver_show(uint16_t port_id, uint32_t *ver)
 894 {
 895         struct rte_eth_dev *dev;
 896
 897         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 898
 899         dev = &rte_eth_devices[port_id];
 900         if (!is_ixgbe_supported(dev))
 901                 return -ENOTSUP;
 902
 903         return ixgbe_bypass_ver_show(dev, ver);
 904 }
 905
 906 int
 907 rte_pmd_ixgbe_bypass_wd_timeout_show(uint16_t port_id, uint32_t *wd_timeout)
 908 {
 909         struct rte_eth_dev *dev;
 910
 911         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 912
 913         dev = &rte_eth_devices[port_id];
 914         if (!is_ixgbe_supported(dev))
 915                 return -ENOTSUP;
 916
 917         return ixgbe_bypass_wd_timeout_show(dev, wd_timeout);
 918 }
 919
 920 int
 921 rte_pmd_ixgbe_bypass_wd_reset(uint16_t port_id)
 922 {
 923         struct rte_eth_dev *dev;
 924
 925         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -ENODEV);
 926
 927         dev = &rte_eth_devices[port_id];
 928         if (!is_ixgbe_supported(dev))
 929                 return -ENOTSUP;
 930
 931         return ixgbe_bypass_wd_reset(dev);
 932 }
 933 #endif
 934
 935 /**
 936  *  rte_pmd_ixgbe_acquire_swfw - Acquire SWFW semaphore
 937  *  @hw: pointer to hardware structure
 938  *  @mask: Mask to specify which semaphore to acquire
 939  *
 940  *  Acquires the SWFW semaphore and get the shared phy token as needed
 941  */
 942 STATIC s32 rte_pmd_ixgbe_acquire_swfw(struct ixgbe_hw *hw, u32 mask)
 943 {
 944         int retries = FW_PHY_TOKEN_RETRIES;
 945         s32 status = IXGBE_SUCCESS;
 946
 947         while (--retries) {
 948                 status = ixgbe_acquire_swfw_semaphore(hw, mask);
 949                 if (status) {
 950                         PMD_DRV_LOG(ERR, "Get SWFW sem failed, Status = %d\n",
 951                                     status);
 952                         return status;
 953                 }
 954                 status = ixgbe_get_phy_token(hw);
 955                 if (status == IXGBE_SUCCESS)
 956                         return IXGBE_SUCCESS;
 957
 958                 if (status == IXGBE_ERR_TOKEN_RETRY)
 959                         PMD_DRV_LOG(ERR, "Get PHY token failed, Status = %d\n",
 960                                     status);
 961
 962                 ixgbe_release_swfw_semaphore(hw, mask);
 963                 if (status != IXGBE_ERR_TOKEN_RETRY) {
 964                         PMD_DRV_LOG(ERR,
 965                                     "Retry get PHY token failed, Status=%d\n",
 966                                     status);
 967                         return status;
 968                 }
 969         }
 970         PMD_DRV_LOG(ERR, "swfw acquisition retries failed!: PHY ID = 0x%08X\n",
 971                     hw->phy.id);
 972         return status;
 973 }
 974
 975 /**
 976  *  rte_pmd_ixgbe_release_swfw_sync - Release SWFW semaphore
 977  *  @hw: pointer to hardware structure
 978  *  @mask: Mask to specify which semaphore to release
 979  *
 980  *  Releases the SWFW semaphore and puts the shared phy token as needed
 981  */
 982 STATIC void rte_pmd_ixgbe_release_swfw(struct ixgbe_hw *hw, u32 mask)
 983 {
 984         ixgbe_put_phy_token(hw);
 985         ixgbe_release_swfw_semaphore(hw, mask);
 986 }
 987
 988 int
 989 rte_pmd_ixgbe_mdio_lock(uint16_t port)
 990 {
 991         struct ixgbe_hw *hw;
 992         struct rte_eth_dev *dev;
 993         u32 swfw_mask;
 994
 995         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
 996         dev = &rte_eth_devices[port];
 997         if (!is_ixgbe_supported(dev))
 998                 return -ENOTSUP;
 999
1000         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1001         if (!hw)
1002                 return -ENOTSUP;
1003
1004         if (hw->bus.lan_id)
1005                 swfw_mask = IXGBE_GSSR_PHY1_SM;
1006         else
1007                 swfw_mask = IXGBE_GSSR_PHY0_SM;
1008
1009         if (rte_pmd_ixgbe_acquire_swfw(hw, swfw_mask))
1010                 return IXGBE_ERR_SWFW_SYNC;
1011
1012         return IXGBE_SUCCESS;
1013 }
1014
1015 int
1016 rte_pmd_ixgbe_mdio_unlock(uint16_t port)
1017 {
1018         struct rte_eth_dev *dev;
1019         struct ixgbe_hw *hw;
1020         u32 swfw_mask;
1021
1022         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1023
1024         dev = &rte_eth_devices[port];
1025         if (!is_ixgbe_supported(dev))
1026                 return -ENOTSUP;
1027
1028         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1029         if (!hw)
1030                 return -ENOTSUP;
1031
1032         if (hw->bus.lan_id)
1033                 swfw_mask = IXGBE_GSSR_PHY1_SM;
1034         else
1035                 swfw_mask = IXGBE_GSSR_PHY0_SM;
1036
1037         rte_pmd_ixgbe_release_swfw(hw, swfw_mask);
1038
1039         return IXGBE_SUCCESS;
1040 }
1041
1042 int
1043 rte_pmd_ixgbe_mdio_unlocked_read(uint16_t port, uint32_t reg_addr,
1044                                  uint32_t dev_type, uint16_t *phy_data)
1045 {
1046         struct ixgbe_hw *hw;
1047         struct rte_eth_dev *dev;
1048         u32 i, data, command;
1049
1050         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1051         dev = &rte_eth_devices[port];
1052         if (!is_ixgbe_supported(dev))
1053                 return -ENOTSUP;
1054
1055         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1056         if (!hw)
1057                 return -ENOTSUP;
1058
1059         /* Setup and write the read command */
1060         command = (reg_addr << IXGBE_MSCA_DEV_TYPE_SHIFT) |
1061                   (dev_type << IXGBE_MSCA_PHY_ADDR_SHIFT) |
1062                   IXGBE_MSCA_OLD_PROTOCOL | IXGBE_MSCA_READ_AUTOINC |
1063                   IXGBE_MSCA_MDI_COMMAND;
1064
1065         IXGBE_WRITE_REG(hw, IXGBE_MSCA, command);
1066
1067         /* Check every 10 usec to see if the access completed.
1068          * The MDI Command bit will clear when the operation is
1069          * complete
1070          */
1071         for (i = 0; i < IXGBE_MDIO_COMMAND_TIMEOUT; i++) {
1072                 usec_delay(10);
1073
1074                 command = IXGBE_READ_REG(hw, IXGBE_MSCA);
1075                 if (!(command & IXGBE_MSCA_MDI_COMMAND))
1076                         break;
1077         }
1078         if (command & IXGBE_MSCA_MDI_COMMAND)
1079                 return IXGBE_ERR_PHY;
1080
1081         /* Read operation is complete.  Get the data from MSRWD */
1082         data = IXGBE_READ_REG(hw, IXGBE_MSRWD);
1083         data >>= IXGBE_MSRWD_READ_DATA_SHIFT;
1084         *phy_data = (u16)data;
1085
1086         return 0;
1087 }
1088
1089 int
1090 rte_pmd_ixgbe_mdio_unlocked_write(uint16_t port, uint32_t reg_addr,
1091                                   uint32_t dev_type, uint16_t phy_data)
1092 {
1093         struct ixgbe_hw *hw;
1094         u32 i, command;
1095         struct rte_eth_dev *dev;
1096
1097         RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
1098         dev = &rte_eth_devices[port];
1099         if (!is_ixgbe_supported(dev))
1100                 return -ENOTSUP;
1101
1102         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1103         if (!hw)
1104                 return -ENOTSUP;
1105
1106         /* Put the data in the MDI single read and write data register*/
1107         IXGBE_WRITE_REG(hw, IXGBE_MSRWD, (u32)phy_data);
1108
1109         /* Setup and write the write command */
1110         command = (reg_addr << IXGBE_MSCA_DEV_TYPE_SHIFT) |
1111                   (dev_type << IXGBE_MSCA_PHY_ADDR_SHIFT) |
1112                   IXGBE_MSCA_OLD_PROTOCOL | IXGBE_MSCA_WRITE |
1113                   IXGBE_MSCA_MDI_COMMAND;
1114
1115         IXGBE_WRITE_REG(hw, IXGBE_MSCA, command);
1116
1117         /* Check every 10 usec to see if the access completed.
1118          * The MDI Command bit will clear when the operation is
1119          * complete
1120          */
1121         for (i = 0; i < IXGBE_MDIO_COMMAND_TIMEOUT; i++) {
1122                 usec_delay(10);
1123
1124                 command = IXGBE_READ_REG(hw, IXGBE_MSCA);
1125                 if (!(command & IXGBE_MSCA_MDI_COMMAND))
1126                         break;
1127         }
1128         if (command & IXGBE_MSCA_MDI_COMMAND) {
1129                 ERROR_REPORT1(IXGBE_ERROR_POLLING,
1130                               "PHY write cmd didn't complete\n");
1131                 return IXGBE_ERR_PHY;
1132         }
1133         return 0;
1134 }