drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c

   1 /*******************************************************************************
   2   This contains the functions to handle the pci driver.
   3
   4   Copyright (C) 2011-2012  Vayavya Labs Pvt Ltd
   5
   6   This program is free software; you can redistribute it and/or modify it
   7   under the terms and conditions of the GNU General Public License,
   8   version 2, as published by the Free Software Foundation.
   9
  10   This program is distributed in the hope it will be useful, but WITHOUT
  11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13   more details.
  14
  15   The full GNU General Public License is included in this distribution in
  16   the file called "COPYING".
  17
  18   Author: Rayagond Kokatanur <rayagond@vayavyalabs.com>
  19   Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
  20 *******************************************************************************/
  21
  22 #include <linux/pci.h>
  23 #include <linux/dmi.h>
  24
  25 #include "stmmac.h"
  26
  27 /*
  28  * This struct is used to associate PCI Function of MAC controller on a board,
  29  * discovered via DMI, with the address of PHY connected to the MAC. The
  30  * negative value of the address means that MAC controller is not connected
  31  * with PHY.
  32  */
  33 struct stmmac_pci_func_data {
  34         unsigned int func;
  35         int phy_addr;
  36 };
  37
  38 struct stmmac_pci_dmi_data {
  39         const struct stmmac_pci_func_data *func;
  40         size_t nfuncs;
  41 };
  42
  43 struct stmmac_pci_info {
  44         int (*setup)(struct pci_dev *pdev, struct plat_stmmacenet_data *plat);
  45 };
  46
  47 static int stmmac_pci_find_phy_addr(struct pci_dev *pdev,
  48                                     const struct dmi_system_id *dmi_list)
  49 {
  50         const struct stmmac_pci_func_data *func_data;
  51         const struct stmmac_pci_dmi_data *dmi_data;
  52         const struct dmi_system_id *dmi_id;
  53         int func = PCI_FUNC(pdev->devfn);
  54         size_t n;
  55
  56         dmi_id = dmi_first_match(dmi_list);
  57         if (!dmi_id)
  58                 return -ENODEV;
  59
  60         dmi_data = dmi_id->driver_data;
  61         func_data = dmi_data->func;
  62
  63         for (n = 0; n < dmi_data->nfuncs; n++, func_data++)
  64                 if (func_data->func == func)
  65                         return func_data->phy_addr;
  66
  67         return -ENODEV;
  68 }
  69
  70 static void common_default_data(struct plat_stmmacenet_data *plat)
  71 {
  72         plat->clk_csr = 2;      /* clk_csr_i = 20-35MHz & MDC = clk_csr_i/16 */
  73         plat->has_gmac = 1;
  74         plat->force_sf_dma_mode = 1;
  75
  76         plat->mdio_bus_data->phy_reset = NULL;
  77         plat->mdio_bus_data->phy_mask = 0;
  78
  79         /* Set default value for multicast hash bins */
  80         plat->multicast_filter_bins = HASH_TABLE_SIZE;
  81
  82         /* Set default value for unicast filter entries */
  83         plat->unicast_filter_entries = 1;
  84
  85         /* Set the maxmtu to a default of JUMBO_LEN */
  86         plat->maxmtu = JUMBO_LEN;
  87
  88         /* Set default number of RX and TX queues to use */
  89         plat->tx_queues_to_use = 1;
  90         plat->rx_queues_to_use = 1;
  91
  92         /* Disable Priority config by default */
  93         plat->tx_queues_cfg[0].use_prio = false;
  94         plat->rx_queues_cfg[0].use_prio = false;
  95
  96         /* Disable RX queues routing by default */
  97         plat->rx_queues_cfg[0].pkt_route = 0x0;
  98 }
  99
 100 static int stmmac_default_data(struct pci_dev *pdev,
 101                                struct plat_stmmacenet_data *plat)
 102 {
 103         /* Set common default data first */
 104         common_default_data(plat);
 105
 106         plat->bus_id = 1;
 107         plat->phy_addr = 0;
 108         plat->interface = PHY_INTERFACE_MODE_GMII;
 109
 110         plat->dma_cfg->pbl = 32;
 111         plat->dma_cfg->pblx8 = true;
 112         /* TODO: AXI */
 113
 114         return 0;
 115 }
 116
 117 static const struct stmmac_pci_info stmmac_pci_info = {
 118         .setup = stmmac_default_data,
 119 };
 120
 121 static const struct stmmac_pci_func_data galileo_stmmac_func_data[] = {
 122         {
 123                 .func = 6,
 124                 .phy_addr = 1,
 125         },
 126 };
 127
 128 static const struct stmmac_pci_dmi_data galileo_stmmac_dmi_data = {
 129         .func = galileo_stmmac_func_data,
 130         .nfuncs = ARRAY_SIZE(galileo_stmmac_func_data),
 131 };
 132
 133 static const struct stmmac_pci_func_data iot2040_stmmac_func_data[] = {
 134         {
 135                 .func = 6,
 136                 .phy_addr = 1,
 137         },
 138         {
 139                 .func = 7,
 140                 .phy_addr = 1,
 141         },
 142 };
 143
 144 static const struct stmmac_pci_dmi_data iot2040_stmmac_dmi_data = {
 145         .func = iot2040_stmmac_func_data,
 146         .nfuncs = ARRAY_SIZE(iot2040_stmmac_func_data),
 147 };
 148
 149 static const struct dmi_system_id quark_pci_dmi[] = {
 150         {
 151                 .matches = {
 152                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "Galileo"),
 153                 },
 154                 .driver_data = (void *)&galileo_stmmac_dmi_data,
 155         },
 156         {
 157                 .matches = {
 158                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "GalileoGen2"),
 159                 },
 160                 .driver_data = (void *)&galileo_stmmac_dmi_data,
 161         },
 162         {
 163                 .matches = {
 164                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 165                         DMI_EXACT_MATCH(DMI_BOARD_ASSET_TAG,
 166                                         "6ES7647-0AA00-0YA2"),
 167                 },
 168                 .driver_data = (void *)&galileo_stmmac_dmi_data,
 169         },
 170         {
 171                 .matches = {
 172                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 173                         DMI_EXACT_MATCH(DMI_BOARD_ASSET_TAG,
 174                                         "6ES7647-0AA00-1YA2"),
 175                 },
 176                 .driver_data = (void *)&iot2040_stmmac_dmi_data,
 177         },
 178         {}
 179 };
 180
 181 static int quark_default_data(struct pci_dev *pdev,
 182                               struct plat_stmmacenet_data *plat)
 183 {
 184         int ret;
 185
 186         /* Set common default data first */
 187         common_default_data(plat);
 188
 189         /*
 190          * Refuse to load the driver and register net device if MAC controller
 191          * does not connect to any PHY interface.
 192          */
 193         ret = stmmac_pci_find_phy_addr(pdev, quark_pci_dmi);
 194         if (ret < 0) {
 195                 /* Return error to the caller on DMI enabled boards. */
 196                 if (dmi_get_system_info(DMI_BOARD_NAME))
 197                         return ret;
 198
 199                 /*
 200                  * Galileo boards with old firmware don't support DMI. We always
 201                  * use 1 here as PHY address, so at least the first found MAC
 202                  * controller would be probed.
 203                  */
 204                 ret = 1;
 205         }
 206
 207         plat->bus_id = PCI_DEVID(pdev->bus->number, pdev->devfn);
 208         plat->phy_addr = ret;
 209         plat->interface = PHY_INTERFACE_MODE_RMII;
 210
 211         plat->dma_cfg->pbl = 16;
 212         plat->dma_cfg->pblx8 = true;
 213         plat->dma_cfg->fixed_burst = 1;
 214         /* AXI (TODO) */
 215
 216         return 0;
 217 }
 218
 219 static const struct stmmac_pci_info quark_pci_info = {
 220         .setup = quark_default_data,
 221 };
 222
 223 /**
 224  * stmmac_pci_probe
 225  *
 226  * @pdev: pci device pointer
 227  * @id: pointer to table of device id/id's.
 228  *
 229  * Description: This probing function gets called for all PCI devices which
 230  * match the ID table and are not "owned" by other driver yet. This function
 231  * gets passed a "struct pci_dev *" for each device whose entry in the ID table
 232  * matches the device. The probe functions returns zero when the driver choose
 233  * to take "ownership" of the device or an error code(-ve no) otherwise.
 234  */
 235 static int stmmac_pci_probe(struct pci_dev *pdev,
 236                             const struct pci_device_id *id)
 237 {
 238         struct stmmac_pci_info *info = (struct stmmac_pci_info *)id->driver_data;
 239         struct plat_stmmacenet_data *plat;
 240         struct stmmac_resources res;
 241         int i;
 242         int ret;
 243
 244         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
 245         if (!plat)
 246                 return -ENOMEM;
 247
 248         plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
 249                                            sizeof(*plat->mdio_bus_data),
 250                                            GFP_KERNEL);
 251         if (!plat->mdio_bus_data)
 252                 return -ENOMEM;
 253
 254         plat->dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*plat->dma_cfg),
 255                                      GFP_KERNEL);
 256         if (!plat->dma_cfg)
 257                 return -ENOMEM;
 258
 259         /* Enable pci device */
 260         ret = pci_enable_device(pdev);
 261         if (ret) {
 262                 dev_err(&pdev->dev, "%s: ERROR: failed to enable device\n",
 263                         __func__);
 264                 return ret;
 265         }
 266
 267         /* Get the base address of device */
 268         for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {
 269                 if (pci_resource_len(pdev, i) == 0)
 270                         continue;
 271                 ret = pcim_iomap_regions(pdev, BIT(i), pci_name(pdev));
 272                 if (ret)
 273                         return ret;
 274                 break;
 275         }
 276
 277         pci_set_master(pdev);
 278
 279         ret = info->setup(pdev, plat);
 280         if (ret)
 281                 return ret;
 282
 283         pci_enable_msi(pdev);
 284
 285         memset(&res, 0, sizeof(res));
 286         res.addr = pcim_iomap_table(pdev)[i];
 287         res.wol_irq = pdev->irq;
 288         res.irq = pdev->irq;
 289
 290         return stmmac_dvr_probe(&pdev->dev, plat, &res);
 291 }
 292
 293 /**
 294  * stmmac_pci_remove
 295  *
 296  * @pdev: platform device pointer
 297  * Description: this function calls the main to free the net resources
 298  * and releases the PCI resources.
 299  */
 300 static void stmmac_pci_remove(struct pci_dev *pdev)
 301 {
 302         int i;
 303
 304         stmmac_dvr_remove(&pdev->dev);
 305
 306         for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {
 307                 if (pci_resource_len(pdev, i) == 0)
 308                         continue;
 309                 pcim_iounmap_regions(pdev, BIT(i));
 310                 break;
 311         }
 312
 313         pci_disable_device(pdev);
 314 }
 315
 316 static int __maybe_unused stmmac_pci_suspend(struct device *dev)
 317 {
 318         struct pci_dev *pdev = to_pci_dev(dev);
 319         int ret;
 320
 321         ret = stmmac_suspend(dev);
 322         if (ret)
 323                 return ret;
 324
 325         ret = pci_save_state(pdev);
 326         if (ret)
 327                 return ret;
 328
 329         pci_disable_device(pdev);
 330         pci_wake_from_d3(pdev, true);
 331         return 0;
 332 }
 333
 334 static int __maybe_unused stmmac_pci_resume(struct device *dev)
 335 {
 336         struct pci_dev *pdev = to_pci_dev(dev);
 337         int ret;
 338
 339         pci_restore_state(pdev);
 340         pci_set_power_state(pdev, PCI_D0);
 341
 342         ret = pci_enable_device(pdev);
 343         if (ret)
 344                 return ret;
 345
 346         pci_set_master(pdev);
 347
 348         return stmmac_resume(dev);
 349 }
 350
 351 static SIMPLE_DEV_PM_OPS(stmmac_pm_ops, stmmac_pci_suspend, stmmac_pci_resume);
 352
 353 /* synthetic ID, no official vendor */
 354 #define PCI_VENDOR_ID_STMMAC 0x700
 355
 356 #define STMMAC_QUARK_ID  0x0937
 357 #define STMMAC_DEVICE_ID 0x1108
 358
 359 #define STMMAC_DEVICE(vendor_id, dev_id, info)  {       \
 360         PCI_VDEVICE(vendor_id, dev_id),                 \
 361         .driver_data = (kernel_ulong_t)&info            \
 362         }
 363
 364 static const struct pci_device_id stmmac_id_table[] = {
 365         STMMAC_DEVICE(STMMAC, STMMAC_DEVICE_ID, stmmac_pci_info),
 366         STMMAC_DEVICE(STMICRO, PCI_DEVICE_ID_STMICRO_MAC, stmmac_pci_info),
 367         STMMAC_DEVICE(INTEL, STMMAC_QUARK_ID, quark_pci_info),
 368         {}
 369 };
 370
 371 MODULE_DEVICE_TABLE(pci, stmmac_id_table);
 372
 373 static struct pci_driver stmmac_pci_driver = {
 374         .name = STMMAC_RESOURCE_NAME,
 375         .id_table = stmmac_id_table,
 376         .probe = stmmac_pci_probe,
 377         .remove = stmmac_pci_remove,
 378         .driver         = {
 379                 .pm     = &stmmac_pm_ops,
 380         },
 381 };
 382
 383 module_pci_driver(stmmac_pci_driver);
 384
 385 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PCI driver");
 386 MODULE_AUTHOR("Rayagond Kokatanur <rayagond.kokatanur@vayavyalabs.com>");
 387 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
 388 MODULE_LICENSE("GPL");