drivers/net/ethernet/stmicro/stmmac/dwmac-intel.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2020, Intel Corporation
   3  */
   4
   5 #include <linux/clk-provider.h>
   6 #include <linux/pci.h>
   7 #include <linux/dmi.h>
   8 #include "dwmac-intel.h"
   9 #include "dwmac4.h"
  10 #include "stmmac.h"
  11 #include "stmmac_ptp.h"
  12
  13 #define INTEL_MGBE_ADHOC_ADDR   0x15
  14 #define INTEL_MGBE_XPCS_ADDR    0x16
  15
  16 /* Selection for PTP Clock Freq belongs to PSE & PCH GbE */
  17 #define PSE_PTP_CLK_FREQ_MASK           (GMAC_GPO0 | GMAC_GPO3)
  18 #define PSE_PTP_CLK_FREQ_19_2MHZ        (GMAC_GPO0)
  19 #define PSE_PTP_CLK_FREQ_200MHZ         (GMAC_GPO0 | GMAC_GPO3)
  20 #define PSE_PTP_CLK_FREQ_256MHZ         (0)
  21 #define PCH_PTP_CLK_FREQ_MASK           (GMAC_GPO0)
  22 #define PCH_PTP_CLK_FREQ_19_2MHZ        (GMAC_GPO0)
  23 #define PCH_PTP_CLK_FREQ_200MHZ         (0)
  24
  25 struct intel_priv_data {
  26         int mdio_adhoc_addr;    /* mdio address for serdes & etc */
  27         bool is_pse;
  28 };
  29
  30 /* This struct is used to associate PCI Function of MAC controller on a board,
  31  * discovered via DMI, with the address of PHY connected to the MAC. The
  32  * negative value of the address means that MAC controller is not connected
  33  * with PHY.
  34  */
  35 struct stmmac_pci_func_data {
  36         unsigned int func;
  37         int phy_addr;
  38 };
  39
  40 struct stmmac_pci_dmi_data {
  41         const struct stmmac_pci_func_data *func;
  42         size_t nfuncs;
  43 };
  44
  45 struct stmmac_pci_info {
  46         int (*setup)(struct pci_dev *pdev, struct plat_stmmacenet_data *plat);
  47 };
  48
  49 static int stmmac_pci_find_phy_addr(struct pci_dev *pdev,
  50                                     const struct dmi_system_id *dmi_list)
  51 {
  52         const struct stmmac_pci_func_data *func_data;
  53         const struct stmmac_pci_dmi_data *dmi_data;
  54         const struct dmi_system_id *dmi_id;
  55         int func = PCI_FUNC(pdev->devfn);
  56         size_t n;
  57
  58         dmi_id = dmi_first_match(dmi_list);
  59         if (!dmi_id)
  60                 return -ENODEV;
  61
  62         dmi_data = dmi_id->driver_data;
  63         func_data = dmi_data->func;
  64
  65         for (n = 0; n < dmi_data->nfuncs; n++, func_data++)
  66                 if (func_data->func == func)
  67                         return func_data->phy_addr;
  68
  69         return -ENODEV;
  70 }
  71
  72 static int serdes_status_poll(struct stmmac_priv *priv, int phyaddr,
  73                               int phyreg, u32 mask, u32 val)
  74 {
  75         unsigned int retries = 10;
  76         int val_rd;
  77
  78         do {
  79                 val_rd = mdiobus_read(priv->mii, phyaddr, phyreg);
  80                 if ((val_rd & mask) == (val & mask))
  81                         return 0;
  82                 udelay(POLL_DELAY_US);
  83         } while (--retries);
  84
  85         return -ETIMEDOUT;
  86 }
  87
  88 static int intel_serdes_powerup(struct net_device *ndev, void *priv_data)
  89 {
  90         struct intel_priv_data *intel_priv = priv_data;
  91         struct stmmac_priv *priv = netdev_priv(ndev);
  92         int serdes_phy_addr = 0;
  93         u32 data = 0;
  94
  95         if (!intel_priv->mdio_adhoc_addr)
  96                 return 0;
  97
  98         serdes_phy_addr = intel_priv->mdio_adhoc_addr;
  99
 100         /* assert clk_req */
 101         data = mdiobus_read(priv->mii, serdes_phy_addr, SERDES_GCR0);
 102         data |= SERDES_PLL_CLK;
 103         mdiobus_write(priv->mii, serdes_phy_addr, SERDES_GCR0, data);
 104
 105         /* check for clk_ack assertion */
 106         data = serdes_status_poll(priv, serdes_phy_addr,
 107                                   SERDES_GSR0,
 108                                   SERDES_PLL_CLK,
 109                                   SERDES_PLL_CLK);
 110
 111         if (data) {
 112                 dev_err(priv->device, "Serdes PLL clk request timeout\n");
 113                 return data;
 114         }
 115
 116         /* assert lane reset */
 117         data = mdiobus_read(priv->mii, serdes_phy_addr, SERDES_GCR0);
 118         data |= SERDES_RST;
 119         mdiobus_write(priv->mii, serdes_phy_addr, SERDES_GCR0, data);
 120
 121         /* check for assert lane reset reflection */
 122         data = serdes_status_poll(priv, serdes_phy_addr,
 123                                   SERDES_GSR0,
 124                                   SERDES_RST,
 125                                   SERDES_RST);
 126
 127         if (data) {
 128                 dev_err(priv->device, "Serdes assert lane reset timeout\n");
 129                 return data;
 130         }
 131
 132         /*  move power state to P0 */
 133         data = mdiobus_read(priv->mii, serdes_phy_addr, SERDES_GCR0);
 134
 135         data &= ~SERDES_PWR_ST_MASK;
 136         data |= SERDES_PWR_ST_P0 << SERDES_PWR_ST_SHIFT;
 137
 138         mdiobus_write(priv->mii, serdes_phy_addr, SERDES_GCR0, data);
 139
 140         /* Check for P0 state */
 141         data = serdes_status_poll(priv, serdes_phy_addr,
 142                                   SERDES_GSR0,
 143                                   SERDES_PWR_ST_MASK,
 144                                   SERDES_PWR_ST_P0 << SERDES_PWR_ST_SHIFT);
 145
 146         if (data) {
 147                 dev_err(priv->device, "Serdes power state P0 timeout.\n");
 148                 return data;
 149         }
 150
 151         return 0;
 152 }
 153
 154 static void intel_serdes_powerdown(struct net_device *ndev, void *intel_data)
 155 {
 156         struct intel_priv_data *intel_priv = intel_data;
 157         struct stmmac_priv *priv = netdev_priv(ndev);
 158         int serdes_phy_addr = 0;
 159         u32 data = 0;
 160
 161         if (!intel_priv->mdio_adhoc_addr)
 162                 return;
 163
 164         serdes_phy_addr = intel_priv->mdio_adhoc_addr;
 165
 166         /*  move power state to P3 */
 167         data = mdiobus_read(priv->mii, serdes_phy_addr, SERDES_GCR0);
 168
 169         data &= ~SERDES_PWR_ST_MASK;
 170         data |= SERDES_PWR_ST_P3 << SERDES_PWR_ST_SHIFT;
 171
 172         mdiobus_write(priv->mii, serdes_phy_addr, SERDES_GCR0, data);
 173
 174         /* Check for P3 state */
 175         data = serdes_status_poll(priv, serdes_phy_addr,
 176                                   SERDES_GSR0,
 177                                   SERDES_PWR_ST_MASK,
 178                                   SERDES_PWR_ST_P3 << SERDES_PWR_ST_SHIFT);
 179
 180         if (data) {
 181                 dev_err(priv->device, "Serdes power state P3 timeout\n");
 182                 return;
 183         }
 184
 185         /* de-assert clk_req */
 186         data = mdiobus_read(priv->mii, serdes_phy_addr, SERDES_GCR0);
 187         data &= ~SERDES_PLL_CLK;
 188         mdiobus_write(priv->mii, serdes_phy_addr, SERDES_GCR0, data);
 189
 190         /* check for clk_ack de-assert */
 191         data = serdes_status_poll(priv, serdes_phy_addr,
 192                                   SERDES_GSR0,
 193                                   SERDES_PLL_CLK,
 194                                   (u32)~SERDES_PLL_CLK);
 195
 196         if (data) {
 197                 dev_err(priv->device, "Serdes PLL clk de-assert timeout\n");
 198                 return;
 199         }
 200
 201         /* de-assert lane reset */
 202         data = mdiobus_read(priv->mii, serdes_phy_addr, SERDES_GCR0);
 203         data &= ~SERDES_RST;
 204         mdiobus_write(priv->mii, serdes_phy_addr, SERDES_GCR0, data);
 205
 206         /* check for de-assert lane reset reflection */
 207         data = serdes_status_poll(priv, serdes_phy_addr,
 208                                   SERDES_GSR0,
 209                                   SERDES_RST,
 210                                   (u32)~SERDES_RST);
 211
 212         if (data) {
 213                 dev_err(priv->device, "Serdes de-assert lane reset timeout\n");
 214                 return;
 215         }
 216 }
 217
 218 /* Program PTP Clock Frequency for different variant of
 219  * Intel mGBE that has slightly different GPO mapping
 220  */
 221 static void intel_mgbe_ptp_clk_freq_config(void *npriv)
 222 {
 223         struct stmmac_priv *priv = (struct stmmac_priv *)npriv;
 224         struct intel_priv_data *intel_priv;
 225         u32 gpio_value;
 226
 227         intel_priv = (struct intel_priv_data *)priv->plat->bsp_priv;
 228
 229         gpio_value = readl(priv->ioaddr + GMAC_GPIO_STATUS);
 230
 231         if (intel_priv->is_pse) {
 232                 /* For PSE GbE, use 200MHz */
 233                 gpio_value &= ~PSE_PTP_CLK_FREQ_MASK;
 234                 gpio_value |= PSE_PTP_CLK_FREQ_200MHZ;
 235         } else {
 236                 /* For PCH GbE, use 200MHz */
 237                 gpio_value &= ~PCH_PTP_CLK_FREQ_MASK;
 238                 gpio_value |= PCH_PTP_CLK_FREQ_200MHZ;
 239         }
 240
 241         writel(gpio_value, priv->ioaddr + GMAC_GPIO_STATUS);
 242 }
 243
 244 static void get_arttime(struct mii_bus *mii, int intel_adhoc_addr,
 245                         u64 *art_time)
 246 {
 247         u64 ns;
 248
 249         ns = mdiobus_read(mii, intel_adhoc_addr, PMC_ART_VALUE3);
 250         ns <<= GMAC4_ART_TIME_SHIFT;
 251         ns |= mdiobus_read(mii, intel_adhoc_addr, PMC_ART_VALUE2);
 252         ns <<= GMAC4_ART_TIME_SHIFT;
 253         ns |= mdiobus_read(mii, intel_adhoc_addr, PMC_ART_VALUE1);
 254         ns <<= GMAC4_ART_TIME_SHIFT;
 255         ns |= mdiobus_read(mii, intel_adhoc_addr, PMC_ART_VALUE0);
 256
 257         *art_time = ns;
 258 }
 259
 260 static int intel_crosststamp(ktime_t *device,
 261                              struct system_counterval_t *system,
 262                              void *ctx)
 263 {
 264         struct intel_priv_data *intel_priv;
 265
 266         struct stmmac_priv *priv = (struct stmmac_priv *)ctx;
 267         void __iomem *ptpaddr = priv->ptpaddr;
 268         void __iomem *ioaddr = priv->hw->pcsr;
 269         unsigned long flags;
 270         u64 art_time = 0;
 271         u64 ptp_time = 0;
 272         u32 num_snapshot;
 273         u32 gpio_value;
 274         u32 acr_value;
 275         int ret;
 276         u32 v;
 277         int i;
 278
 279         if (!boot_cpu_has(X86_FEATURE_ART))
 280                 return -EOPNOTSUPP;
 281
 282         intel_priv = priv->plat->bsp_priv;
 283
 284         /* Enable Internal snapshot trigger */
 285         acr_value = readl(ptpaddr + PTP_ACR);
 286         acr_value &= ~PTP_ACR_MASK;
 287         switch (priv->plat->int_snapshot_num) {
 288         case AUX_SNAPSHOT0:
 289                 acr_value |= PTP_ACR_ATSEN0;
 290                 break;
 291         case AUX_SNAPSHOT1:
 292                 acr_value |= PTP_ACR_ATSEN1;
 293                 break;
 294         case AUX_SNAPSHOT2:
 295                 acr_value |= PTP_ACR_ATSEN2;
 296                 break;
 297         case AUX_SNAPSHOT3:
 298                 acr_value |= PTP_ACR_ATSEN3;
 299                 break;
 300         default:
 301                 return -EINVAL;
 302         }
 303         writel(acr_value, ptpaddr + PTP_ACR);
 304
 305         /* Clear FIFO */
 306         acr_value = readl(ptpaddr + PTP_ACR);
 307         acr_value |= PTP_ACR_ATSFC;
 308         writel(acr_value, ptpaddr + PTP_ACR);
 309
 310         /* Trigger Internal snapshot signal
 311          * Create a rising edge by just toggle the GPO1 to low
 312          * and back to high.
 313          */
 314         gpio_value = readl(ioaddr + GMAC_GPIO_STATUS);
 315         gpio_value &= ~GMAC_GPO1;
 316         writel(gpio_value, ioaddr + GMAC_GPIO_STATUS);
 317         gpio_value |= GMAC_GPO1;
 318         writel(gpio_value, ioaddr + GMAC_GPIO_STATUS);
 319
 320         /* Poll for time sync operation done */
 321         ret = readl_poll_timeout(priv->ioaddr + GMAC_INT_STATUS, v,
 322                                  (v & GMAC_INT_TSIE), 100, 10000);
 323
 324         if (ret == -ETIMEDOUT) {
 325                 pr_err("%s: Wait for time sync operation timeout\n", __func__);
 326                 return ret;
 327         }
 328
 329         num_snapshot = (readl(ioaddr + GMAC_TIMESTAMP_STATUS) &
 330                         GMAC_TIMESTAMP_ATSNS_MASK) >>
 331                         GMAC_TIMESTAMP_ATSNS_SHIFT;
 332
 333         /* Repeat until the timestamps are from the FIFO last segment */
 334         for (i = 0; i < num_snapshot; i++) {
 335                 spin_lock_irqsave(&priv->ptp_lock, flags);
 336                 stmmac_get_ptptime(priv, ptpaddr, &ptp_time);
 337                 *device = ns_to_ktime(ptp_time);
 338                 spin_unlock_irqrestore(&priv->ptp_lock, flags);
 339                 get_arttime(priv->mii, intel_priv->mdio_adhoc_addr, &art_time);
 340                 *system = convert_art_to_tsc(art_time);
 341         }
 342
 343         return 0;
 344 }
 345
 346 static void common_default_data(struct plat_stmmacenet_data *plat)
 347 {
 348         plat->clk_csr = 2;      /* clk_csr_i = 20-35MHz & MDC = clk_csr_i/16 */
 349         plat->has_gmac = 1;
 350         plat->force_sf_dma_mode = 1;
 351
 352         plat->mdio_bus_data->needs_reset = true;
 353
 354         /* Set default value for multicast hash bins */
 355         plat->multicast_filter_bins = HASH_TABLE_SIZE;
 356
 357         /* Set default value for unicast filter entries */
 358         plat->unicast_filter_entries = 1;
 359
 360         /* Set the maxmtu to a default of JUMBO_LEN */
 361         plat->maxmtu = JUMBO_LEN;
 362
 363         /* Set default number of RX and TX queues to use */
 364         plat->tx_queues_to_use = 1;
 365         plat->rx_queues_to_use = 1;
 366
 367         /* Disable Priority config by default */
 368         plat->tx_queues_cfg[0].use_prio = false;
 369         plat->rx_queues_cfg[0].use_prio = false;
 370
 371         /* Disable RX queues routing by default */
 372         plat->rx_queues_cfg[0].pkt_route = 0x0;
 373 }
 374
 375 static int intel_mgbe_common_data(struct pci_dev *pdev,
 376                                   struct plat_stmmacenet_data *plat)
 377 {
 378         char clk_name[20];
 379         int ret;
 380         int i;
 381
 382         plat->pdev = pdev;
 383         plat->phy_addr = -1;
 384         plat->clk_csr = 5;
 385         plat->has_gmac = 0;
 386         plat->has_gmac4 = 1;
 387         plat->force_sf_dma_mode = 0;
 388         plat->tso_en = 1;
 389
 390         plat->rx_sched_algorithm = MTL_RX_ALGORITHM_SP;
 391
 392         for (i = 0; i < plat->rx_queues_to_use; i++) {
 393                 plat->rx_queues_cfg[i].mode_to_use = MTL_QUEUE_DCB;
 394                 plat->rx_queues_cfg[i].chan = i;
 395
 396                 /* Disable Priority config by default */
 397                 plat->rx_queues_cfg[i].use_prio = false;
 398
 399                 /* Disable RX queues routing by default */
 400                 plat->rx_queues_cfg[i].pkt_route = 0x0;
 401         }
 402
 403         for (i = 0; i < plat->tx_queues_to_use; i++) {
 404                 plat->tx_queues_cfg[i].mode_to_use = MTL_QUEUE_DCB;
 405
 406                 /* Disable Priority config by default */
 407                 plat->tx_queues_cfg[i].use_prio = false;
 408         }
 409
 410         /* FIFO size is 4096 bytes for 1 tx/rx queue */
 411         plat->tx_fifo_size = plat->tx_queues_to_use * 4096;
 412         plat->rx_fifo_size = plat->rx_queues_to_use * 4096;
 413
 414         plat->tx_sched_algorithm = MTL_TX_ALGORITHM_WRR;
 415         plat->tx_queues_cfg[0].weight = 0x09;
 416         plat->tx_queues_cfg[1].weight = 0x0A;
 417         plat->tx_queues_cfg[2].weight = 0x0B;
 418         plat->tx_queues_cfg[3].weight = 0x0C;
 419         plat->tx_queues_cfg[4].weight = 0x0D;
 420         plat->tx_queues_cfg[5].weight = 0x0E;
 421         plat->tx_queues_cfg[6].weight = 0x0F;
 422         plat->tx_queues_cfg[7].weight = 0x10;
 423
 424         plat->dma_cfg->pbl = 32;
 425         plat->dma_cfg->pblx8 = true;
 426         plat->dma_cfg->fixed_burst = 0;
 427         plat->dma_cfg->mixed_burst = 0;
 428         plat->dma_cfg->aal = 0;
 429
 430         plat->axi = devm_kzalloc(&pdev->dev, sizeof(*plat->axi),
 431                                  GFP_KERNEL);
 432         if (!plat->axi)
 433                 return -ENOMEM;
 434
 435         plat->axi->axi_lpi_en = 0;
 436         plat->axi->axi_xit_frm = 0;
 437         plat->axi->axi_wr_osr_lmt = 1;
 438         plat->axi->axi_rd_osr_lmt = 1;
 439         plat->axi->axi_blen[0] = 4;
 440         plat->axi->axi_blen[1] = 8;
 441         plat->axi->axi_blen[2] = 16;
 442
 443         plat->ptp_max_adj = plat->clk_ptp_rate;
 444         plat->eee_usecs_rate = plat->clk_ptp_rate;
 445
 446         /* Set system clock */
 447         sprintf(clk_name, "%s-%s", "stmmac", pci_name(pdev));
 448
 449         plat->stmmac_clk = clk_register_fixed_rate(&pdev->dev,
 450                                                    clk_name, NULL, 0,
 451                                                    plat->clk_ptp_rate);
 452
 453         if (IS_ERR(plat->stmmac_clk)) {
 454                 dev_warn(&pdev->dev, "Fail to register stmmac-clk\n");
 455                 plat->stmmac_clk = NULL;
 456         }
 457
 458         ret = clk_prepare_enable(plat->stmmac_clk);
 459         if (ret) {
 460                 clk_unregister_fixed_rate(plat->stmmac_clk);
 461                 return ret;
 462         }
 463
 464         plat->ptp_clk_freq_config = intel_mgbe_ptp_clk_freq_config;
 465
 466         /* Set default value for multicast hash bins */
 467         plat->multicast_filter_bins = HASH_TABLE_SIZE;
 468
 469         /* Set default value for unicast filter entries */
 470         plat->unicast_filter_entries = 1;
 471
 472         /* Set the maxmtu to a default of JUMBO_LEN */
 473         plat->maxmtu = JUMBO_LEN;
 474
 475         plat->vlan_fail_q_en = true;
 476
 477         /* Use the last Rx queue */
 478         plat->vlan_fail_q = plat->rx_queues_to_use - 1;
 479
 480         /* Intel mgbe SGMII interface uses pcs-xcps */
 481         if (plat->phy_interface == PHY_INTERFACE_MODE_SGMII) {
 482                 plat->mdio_bus_data->has_xpcs = true;
 483                 plat->mdio_bus_data->xpcs_an_inband = true;
 484         }
 485
 486         /* Ensure mdio bus scan skips intel serdes and pcs-xpcs */
 487         plat->mdio_bus_data->phy_mask = 1 << INTEL_MGBE_ADHOC_ADDR;
 488         plat->mdio_bus_data->phy_mask |= 1 << INTEL_MGBE_XPCS_ADDR;
 489
 490         plat->int_snapshot_num = AUX_SNAPSHOT1;
 491
 492         plat->has_crossts = true;
 493         plat->crosststamp = intel_crosststamp;
 494
 495         return 0;
 496 }
 497
 498 static int ehl_common_data(struct pci_dev *pdev,
 499                            struct plat_stmmacenet_data *plat)
 500 {
 501         plat->rx_queues_to_use = 8;
 502         plat->tx_queues_to_use = 8;
 503         plat->clk_ptp_rate = 200000000;
 504
 505         return intel_mgbe_common_data(pdev, plat);
 506 }
 507
 508 static int ehl_sgmii_data(struct pci_dev *pdev,
 509                           struct plat_stmmacenet_data *plat)
 510 {
 511         plat->bus_id = 1;
 512         plat->phy_interface = PHY_INTERFACE_MODE_SGMII;
 513
 514         plat->serdes_powerup = intel_serdes_powerup;
 515         plat->serdes_powerdown = intel_serdes_powerdown;
 516
 517         return ehl_common_data(pdev, plat);
 518 }
 519
 520 static struct stmmac_pci_info ehl_sgmii1g_info = {
 521         .setup = ehl_sgmii_data,
 522 };
 523
 524 static int ehl_rgmii_data(struct pci_dev *pdev,
 525                           struct plat_stmmacenet_data *plat)
 526 {
 527         plat->bus_id = 1;
 528         plat->phy_interface = PHY_INTERFACE_MODE_RGMII;
 529
 530         return ehl_common_data(pdev, plat);
 531 }
 532
 533 static struct stmmac_pci_info ehl_rgmii1g_info = {
 534         .setup = ehl_rgmii_data,
 535 };
 536
 537 static int ehl_pse0_common_data(struct pci_dev *pdev,
 538                                 struct plat_stmmacenet_data *plat)
 539 {
 540         struct intel_priv_data *intel_priv = plat->bsp_priv;
 541
 542         intel_priv->is_pse = true;
 543         plat->bus_id = 2;
 544         plat->addr64 = 32;
 545
 546         return ehl_common_data(pdev, plat);
 547 }
 548
 549 static int ehl_pse0_rgmii1g_data(struct pci_dev *pdev,
 550                                  struct plat_stmmacenet_data *plat)
 551 {
 552         plat->phy_interface = PHY_INTERFACE_MODE_RGMII_ID;
 553         return ehl_pse0_common_data(pdev, plat);
 554 }
 555
 556 static struct stmmac_pci_info ehl_pse0_rgmii1g_info = {
 557         .setup = ehl_pse0_rgmii1g_data,
 558 };
 559
 560 static int ehl_pse0_sgmii1g_data(struct pci_dev *pdev,
 561                                  struct plat_stmmacenet_data *plat)
 562 {
 563         plat->phy_interface = PHY_INTERFACE_MODE_SGMII;
 564         plat->serdes_powerup = intel_serdes_powerup;
 565         plat->serdes_powerdown = intel_serdes_powerdown;
 566         return ehl_pse0_common_data(pdev, plat);
 567 }
 568
 569 static struct stmmac_pci_info ehl_pse0_sgmii1g_info = {
 570         .setup = ehl_pse0_sgmii1g_data,
 571 };
 572
 573 static int ehl_pse1_common_data(struct pci_dev *pdev,
 574                                 struct plat_stmmacenet_data *plat)
 575 {
 576         struct intel_priv_data *intel_priv = plat->bsp_priv;
 577
 578         intel_priv->is_pse = true;
 579         plat->bus_id = 3;
 580         plat->addr64 = 32;
 581
 582         return ehl_common_data(pdev, plat);
 583 }
 584
 585 static int ehl_pse1_rgmii1g_data(struct pci_dev *pdev,
 586                                  struct plat_stmmacenet_data *plat)
 587 {
 588         plat->phy_interface = PHY_INTERFACE_MODE_RGMII_ID;
 589         return ehl_pse1_common_data(pdev, plat);
 590 }
 591
 592 static struct stmmac_pci_info ehl_pse1_rgmii1g_info = {
 593         .setup = ehl_pse1_rgmii1g_data,
 594 };
 595
 596 static int ehl_pse1_sgmii1g_data(struct pci_dev *pdev,
 597                                  struct plat_stmmacenet_data *plat)
 598 {
 599         plat->phy_interface = PHY_INTERFACE_MODE_SGMII;
 600         plat->serdes_powerup = intel_serdes_powerup;
 601         plat->serdes_powerdown = intel_serdes_powerdown;
 602         return ehl_pse1_common_data(pdev, plat);
 603 }
 604
 605 static struct stmmac_pci_info ehl_pse1_sgmii1g_info = {
 606         .setup = ehl_pse1_sgmii1g_data,
 607 };
 608
 609 static int tgl_common_data(struct pci_dev *pdev,
 610                            struct plat_stmmacenet_data *plat)
 611 {
 612         plat->rx_queues_to_use = 6;
 613         plat->tx_queues_to_use = 4;
 614         plat->clk_ptp_rate = 200000000;
 615
 616         return intel_mgbe_common_data(pdev, plat);
 617 }
 618
 619 static int tgl_sgmii_phy0_data(struct pci_dev *pdev,
 620                                struct plat_stmmacenet_data *plat)
 621 {
 622         plat->bus_id = 1;
 623         plat->phy_interface = PHY_INTERFACE_MODE_SGMII;
 624         plat->serdes_powerup = intel_serdes_powerup;
 625         plat->serdes_powerdown = intel_serdes_powerdown;
 626         return tgl_common_data(pdev, plat);
 627 }
 628
 629 static struct stmmac_pci_info tgl_sgmii1g_phy0_info = {
 630         .setup = tgl_sgmii_phy0_data,
 631 };
 632
 633 static int tgl_sgmii_phy1_data(struct pci_dev *pdev,
 634                                struct plat_stmmacenet_data *plat)
 635 {
 636         plat->bus_id = 2;
 637         plat->phy_interface = PHY_INTERFACE_MODE_SGMII;
 638         plat->serdes_powerup = intel_serdes_powerup;
 639         plat->serdes_powerdown = intel_serdes_powerdown;
 640         return tgl_common_data(pdev, plat);
 641 }
 642
 643 static struct stmmac_pci_info tgl_sgmii1g_phy1_info = {
 644         .setup = tgl_sgmii_phy1_data,
 645 };
 646
 647 static int adls_sgmii_phy0_data(struct pci_dev *pdev,
 648                                 struct plat_stmmacenet_data *plat)
 649 {
 650         plat->bus_id = 1;
 651         plat->phy_interface = PHY_INTERFACE_MODE_SGMII;
 652
 653         /* SerDes power up and power down are done in BIOS for ADL */
 654
 655         return tgl_common_data(pdev, plat);
 656 }
 657
 658 static struct stmmac_pci_info adls_sgmii1g_phy0_info = {
 659         .setup = adls_sgmii_phy0_data,
 660 };
 661
 662 static int adls_sgmii_phy1_data(struct pci_dev *pdev,
 663                                 struct plat_stmmacenet_data *plat)
 664 {
 665         plat->bus_id = 2;
 666         plat->phy_interface = PHY_INTERFACE_MODE_SGMII;
 667
 668         /* SerDes power up and power down are done in BIOS for ADL */
 669
 670         return tgl_common_data(pdev, plat);
 671 }
 672
 673 static struct stmmac_pci_info adls_sgmii1g_phy1_info = {
 674         .setup = adls_sgmii_phy1_data,
 675 };
 676 static const struct stmmac_pci_func_data galileo_stmmac_func_data[] = {
 677         {
 678                 .func = 6,
 679                 .phy_addr = 1,
 680         },
 681 };
 682
 683 static const struct stmmac_pci_dmi_data galileo_stmmac_dmi_data = {
 684         .func = galileo_stmmac_func_data,
 685         .nfuncs = ARRAY_SIZE(galileo_stmmac_func_data),
 686 };
 687
 688 static const struct stmmac_pci_func_data iot2040_stmmac_func_data[] = {
 689         {
 690                 .func = 6,
 691                 .phy_addr = 1,
 692         },
 693         {
 694                 .func = 7,
 695                 .phy_addr = 1,
 696         },
 697 };
 698
 699 static const struct stmmac_pci_dmi_data iot2040_stmmac_dmi_data = {
 700         .func = iot2040_stmmac_func_data,
 701         .nfuncs = ARRAY_SIZE(iot2040_stmmac_func_data),
 702 };
 703
 704 static const struct dmi_system_id quark_pci_dmi[] = {
 705         {
 706                 .matches = {
 707                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "Galileo"),
 708                 },
 709                 .driver_data = (void *)&galileo_stmmac_dmi_data,
 710         },
 711         {
 712                 .matches = {
 713                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "GalileoGen2"),
 714                 },
 715                 .driver_data = (void *)&galileo_stmmac_dmi_data,
 716         },
 717         /* There are 2 types of SIMATIC IOT2000: IOT2020 and IOT2040.
 718          * The asset tag "6ES7647-0AA00-0YA2" is only for IOT2020 which
 719          * has only one pci network device while other asset tags are
 720          * for IOT2040 which has two.
 721          */
 722         {
 723                 .matches = {
 724                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 725                         DMI_EXACT_MATCH(DMI_BOARD_ASSET_TAG,
 726                                         "6ES7647-0AA00-0YA2"),
 727                 },
 728                 .driver_data = (void *)&galileo_stmmac_dmi_data,
 729         },
 730         {
 731                 .matches = {
 732                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 733                 },
 734                 .driver_data = (void *)&iot2040_stmmac_dmi_data,
 735         },
 736         {}
 737 };
 738
 739 static int quark_default_data(struct pci_dev *pdev,
 740                               struct plat_stmmacenet_data *plat)
 741 {
 742         int ret;
 743
 744         /* Set common default data first */
 745         common_default_data(plat);
 746
 747         /* Refuse to load the driver and register net device if MAC controller
 748          * does not connect to any PHY interface.
 749          */
 750         ret = stmmac_pci_find_phy_addr(pdev, quark_pci_dmi);
 751         if (ret < 0) {
 752                 /* Return error to the caller on DMI enabled boards. */
 753                 if (dmi_get_system_info(DMI_BOARD_NAME))
 754                         return ret;
 755
 756                 /* Galileo boards with old firmware don't support DMI. We always
 757                  * use 1 here as PHY address, so at least the first found MAC
 758                  * controller would be probed.
 759                  */
 760                 ret = 1;
 761         }
 762
 763         plat->bus_id = pci_dev_id(pdev);
 764         plat->phy_addr = ret;
 765         plat->phy_interface = PHY_INTERFACE_MODE_RMII;
 766
 767         plat->dma_cfg->pbl = 16;
 768         plat->dma_cfg->pblx8 = true;
 769         plat->dma_cfg->fixed_burst = 1;
 770         /* AXI (TODO) */
 771
 772         return 0;
 773 }
 774
 775 static const struct stmmac_pci_info quark_info = {
 776         .setup = quark_default_data,
 777 };
 778
 779 /**
 780  * intel_eth_pci_probe
 781  *
 782  * @pdev: pci device pointer
 783  * @id: pointer to table of device id/id's.
 784  *
 785  * Description: This probing function gets called for all PCI devices which
 786  * match the ID table and are not "owned" by other driver yet. This function
 787  * gets passed a "struct pci_dev *" for each device whose entry in the ID table
 788  * matches the device. The probe functions returns zero when the driver choose
 789  * to take "ownership" of the device or an error code(-ve no) otherwise.
 790  */
 791 static int intel_eth_pci_probe(struct pci_dev *pdev,
 792                                const struct pci_device_id *id)
 793 {
 794         struct stmmac_pci_info *info = (struct stmmac_pci_info *)id->driver_data;
 795         struct intel_priv_data *intel_priv;
 796         struct plat_stmmacenet_data *plat;
 797         struct stmmac_resources res;
 798         int ret;
 799
 800         intel_priv = devm_kzalloc(&pdev->dev, sizeof(*intel_priv), GFP_KERNEL);
 801         if (!intel_priv)
 802                 return -ENOMEM;
 803
 804         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
 805         if (!plat)
 806                 return -ENOMEM;
 807
 808         plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
 809                                            sizeof(*plat->mdio_bus_data),
 810                                            GFP_KERNEL);
 811         if (!plat->mdio_bus_data)
 812                 return -ENOMEM;
 813
 814         plat->dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*plat->dma_cfg),
 815                                      GFP_KERNEL);
 816         if (!plat->dma_cfg)
 817                 return -ENOMEM;
 818
 819         /* Enable pci device */
 820         ret = pci_enable_device(pdev);
 821         if (ret) {
 822                 dev_err(&pdev->dev, "%s: ERROR: failed to enable device\n",
 823                         __func__);
 824                 return ret;
 825         }
 826
 827         ret = pcim_iomap_regions(pdev, BIT(0), pci_name(pdev));
 828         if (ret)
 829                 return ret;
 830
 831         pci_set_master(pdev);
 832
 833         plat->bsp_priv = intel_priv;
 834         intel_priv->mdio_adhoc_addr = INTEL_MGBE_ADHOC_ADDR;
 835
 836         ret = info->setup(pdev, plat);
 837         if (ret)
 838                 return ret;
 839
 840         ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_ALL_TYPES);
 841         if (ret < 0)
 842                 return ret;
 843
 844         memset(&res, 0, sizeof(res));
 845         res.addr = pcim_iomap_table(pdev)[0];
 846         res.wol_irq = pci_irq_vector(pdev, 0);
 847         res.irq = pci_irq_vector(pdev, 0);
 848
 849         if (plat->eee_usecs_rate > 0) {
 850                 u32 tx_lpi_usec;
 851
 852                 tx_lpi_usec = (plat->eee_usecs_rate / 1000000) - 1;
 853                 writel(tx_lpi_usec, res.addr + GMAC_1US_TIC_COUNTER);
 854         }
 855
 856         ret = stmmac_dvr_probe(&pdev->dev, plat, &res);
 857         if (ret) {
 858                 pci_free_irq_vectors(pdev);
 859                 clk_disable_unprepare(plat->stmmac_clk);
 860                 clk_unregister_fixed_rate(plat->stmmac_clk);
 861         }
 862
 863         return ret;
 864 }
 865
 866 /**
 867  * intel_eth_pci_remove
 868  *
 869  * @pdev: platform device pointer
 870  * Description: this function calls the main to free the net resources
 871  * and releases the PCI resources.
 872  */
 873 static void intel_eth_pci_remove(struct pci_dev *pdev)
 874 {
 875         struct net_device *ndev = dev_get_drvdata(&pdev->dev);
 876         struct stmmac_priv *priv = netdev_priv(ndev);
 877
 878         stmmac_dvr_remove(&pdev->dev);
 879
 880         pci_free_irq_vectors(pdev);
 881
 882         clk_unregister_fixed_rate(priv->plat->stmmac_clk);
 883
 884         pcim_iounmap_regions(pdev, BIT(0));
 885
 886         pci_disable_device(pdev);
 887 }
 888
 889 static int __maybe_unused intel_eth_pci_suspend(struct device *dev)
 890 {
 891         struct pci_dev *pdev = to_pci_dev(dev);
 892         int ret;
 893
 894         ret = stmmac_suspend(dev);
 895         if (ret)
 896                 return ret;
 897
 898         ret = pci_save_state(pdev);
 899         if (ret)
 900                 return ret;
 901
 902         pci_disable_device(pdev);
 903         pci_wake_from_d3(pdev, true);
 904         return 0;
 905 }
 906
 907 static int __maybe_unused intel_eth_pci_resume(struct device *dev)
 908 {
 909         struct pci_dev *pdev = to_pci_dev(dev);
 910         int ret;
 911
 912         pci_restore_state(pdev);
 913         pci_set_power_state(pdev, PCI_D0);
 914
 915         ret = pci_enable_device(pdev);
 916         if (ret)
 917                 return ret;
 918
 919         pci_set_master(pdev);
 920
 921         return stmmac_resume(dev);
 922 }
 923
 924 static SIMPLE_DEV_PM_OPS(intel_eth_pm_ops, intel_eth_pci_suspend,
 925                          intel_eth_pci_resume);
 926
 927 #define PCI_DEVICE_ID_INTEL_QUARK_ID                    0x0937
 928 #define PCI_DEVICE_ID_INTEL_EHL_RGMII1G_ID              0x4b30
 929 #define PCI_DEVICE_ID_INTEL_EHL_SGMII1G_ID              0x4b31
 930 #define PCI_DEVICE_ID_INTEL_EHL_SGMII2G5_ID             0x4b32
 931 /* Intel(R) Programmable Services Engine (Intel(R) PSE) consist of 2 MAC
 932  * which are named PSE0 and PSE1
 933  */
 934 #define PCI_DEVICE_ID_INTEL_EHL_PSE0_RGMII1G_ID         0x4ba0
 935 #define PCI_DEVICE_ID_INTEL_EHL_PSE0_SGMII1G_ID         0x4ba1
 936 #define PCI_DEVICE_ID_INTEL_EHL_PSE0_SGMII2G5_ID        0x4ba2
 937 #define PCI_DEVICE_ID_INTEL_EHL_PSE1_RGMII1G_ID         0x4bb0
 938 #define PCI_DEVICE_ID_INTEL_EHL_PSE1_SGMII1G_ID         0x4bb1
 939 #define PCI_DEVICE_ID_INTEL_EHL_PSE1_SGMII2G5_ID        0x4bb2
 940 #define PCI_DEVICE_ID_INTEL_TGLH_SGMII1G_0_ID           0x43ac
 941 #define PCI_DEVICE_ID_INTEL_TGLH_SGMII1G_1_ID           0x43a2
 942 #define PCI_DEVICE_ID_INTEL_TGL_SGMII1G_ID              0xa0ac
 943 #define PCI_DEVICE_ID_INTEL_ADLS_SGMII1G_0_ID           0x7aac
 944 #define PCI_DEVICE_ID_INTEL_ADLS_SGMII1G_1_ID           0x7aad
 945
 946 static const struct pci_device_id intel_eth_pci_id_table[] = {
 947         { PCI_DEVICE_DATA(INTEL, QUARK_ID, &quark_info) },
 948         { PCI_DEVICE_DATA(INTEL, EHL_RGMII1G_ID, &ehl_rgmii1g_info) },
 949         { PCI_DEVICE_DATA(INTEL, EHL_SGMII1G_ID, &ehl_sgmii1g_info) },
 950         { PCI_DEVICE_DATA(INTEL, EHL_SGMII2G5_ID, &ehl_sgmii1g_info) },
 951         { PCI_DEVICE_DATA(INTEL, EHL_PSE0_RGMII1G_ID, &ehl_pse0_rgmii1g_info) },
 952         { PCI_DEVICE_DATA(INTEL, EHL_PSE0_SGMII1G_ID, &ehl_pse0_sgmii1g_info) },
 953         { PCI_DEVICE_DATA(INTEL, EHL_PSE0_SGMII2G5_ID, &ehl_pse0_sgmii1g_info) },
 954         { PCI_DEVICE_DATA(INTEL, EHL_PSE1_RGMII1G_ID, &ehl_pse1_rgmii1g_info) },
 955         { PCI_DEVICE_DATA(INTEL, EHL_PSE1_SGMII1G_ID, &ehl_pse1_sgmii1g_info) },
 956         { PCI_DEVICE_DATA(INTEL, EHL_PSE1_SGMII2G5_ID, &ehl_pse1_sgmii1g_info) },
 957         { PCI_DEVICE_DATA(INTEL, TGL_SGMII1G_ID, &tgl_sgmii1g_phy0_info) },
 958         { PCI_DEVICE_DATA(INTEL, TGLH_SGMII1G_0_ID, &tgl_sgmii1g_phy0_info) },
 959         { PCI_DEVICE_DATA(INTEL, TGLH_SGMII1G_1_ID, &tgl_sgmii1g_phy1_info) },
 960         { PCI_DEVICE_DATA(INTEL, ADLS_SGMII1G_0_ID, &adls_sgmii1g_phy0_info) },
 961         { PCI_DEVICE_DATA(INTEL, ADLS_SGMII1G_1_ID, &adls_sgmii1g_phy1_info) },
 962         {}
 963 };
 964 MODULE_DEVICE_TABLE(pci, intel_eth_pci_id_table);
 965
 966 static struct pci_driver intel_eth_pci_driver = {
 967         .name = "intel-eth-pci",
 968         .id_table = intel_eth_pci_id_table,
 969         .probe = intel_eth_pci_probe,
 970         .remove = intel_eth_pci_remove,
 971         .driver         = {
 972                 .pm     = &intel_eth_pm_ops,
 973         },
 974 };
 975
 976 module_pci_driver(intel_eth_pci_driver);
 977
 978 MODULE_DESCRIPTION("INTEL 10/100/1000 Ethernet PCI driver");
 979 MODULE_AUTHOR("Voon Weifeng <weifeng.voon@intel.com>");
 980 MODULE_LICENSE("GPL v2");