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          * There are 2 types of SIMATIC IOT2000: IOT2020 and IOT2040.
 164          * The asset tag "6ES7647-0AA00-0YA2" is only for IOT2020 which
 165          * has only one pci network device while other asset tags are
 166          * for IOT2040 which has two.
 167          */
 168         {
 169                 .matches = {
 170                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 171                         DMI_EXACT_MATCH(DMI_BOARD_ASSET_TAG,
 172                                         "6ES7647-0AA00-0YA2"),
 173                 },
 174                 .driver_data = (void *)&galileo_stmmac_dmi_data,
 175         },
 176         {
 177                 .matches = {
 178                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "SIMATIC IOT2000"),
 179                 },
 180                 .driver_data = (void *)&iot2040_stmmac_dmi_data,
 181         },
 182         {}
 183 };
 184
 185 static int quark_default_data(struct pci_dev *pdev,
 186                               struct plat_stmmacenet_data *plat)
 187 {
 188         int ret;
 189
 190         /* Set common default data first */
 191         common_default_data(plat);
 192
 193         /*
 194          * Refuse to load the driver and register net device if MAC controller
 195          * does not connect to any PHY interface.
 196          */
 197         ret = stmmac_pci_find_phy_addr(pdev, quark_pci_dmi);
 198         if (ret < 0) {
 199                 /* Return error to the caller on DMI enabled boards. */
 200                 if (dmi_get_system_info(DMI_BOARD_NAME))
 201                         return ret;
 202
 203                 /*
 204                  * Galileo boards with old firmware don't support DMI. We always
 205                  * use 1 here as PHY address, so at least the first found MAC
 206                  * controller would be probed.
 207                  */
 208                 ret = 1;
 209         }
 210
 211         plat->bus_id = PCI_DEVID(pdev->bus->number, pdev->devfn);
 212         plat->phy_addr = ret;
 213         plat->interface = PHY_INTERFACE_MODE_RMII;
 214
 215         plat->dma_cfg->pbl = 16;
 216         plat->dma_cfg->pblx8 = true;
 217         plat->dma_cfg->fixed_burst = 1;
 218         /* AXI (TODO) */
 219
 220         return 0;
 221 }
 222
 223 static const struct stmmac_pci_info quark_pci_info = {
 224         .setup = quark_default_data,
 225 };
 226
 227 /**
 228  * stmmac_pci_probe
 229  *
 230  * @pdev: pci device pointer
 231  * @id: pointer to table of device id/id's.
 232  *
 233  * Description: This probing function gets called for all PCI devices which
 234  * match the ID table and are not "owned" by other driver yet. This function
 235  * gets passed a "struct pci_dev *" for each device whose entry in the ID table
 236  * matches the device. The probe functions returns zero when the driver choose
 237  * to take "ownership" of the device or an error code(-ve no) otherwise.
 238  */
 239 static int stmmac_pci_probe(struct pci_dev *pdev,
 240                             const struct pci_device_id *id)
 241 {
 242         struct stmmac_pci_info *info = (struct stmmac_pci_info *)id->driver_data;
 243         struct plat_stmmacenet_data *plat;
 244         struct stmmac_resources res;
 245         int i;
 246         int ret;
 247
 248         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
 249         if (!plat)
 250                 return -ENOMEM;
 251
 252         plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
 253                                            sizeof(*plat->mdio_bus_data),
 254                                            GFP_KERNEL);
 255         if (!plat->mdio_bus_data)
 256                 return -ENOMEM;
 257
 258         plat->dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*plat->dma_cfg),
 259                                      GFP_KERNEL);
 260         if (!plat->dma_cfg)
 261                 return -ENOMEM;
 262
 263         /* Enable pci device */
 264         ret = pci_enable_device(pdev);
 265         if (ret) {
 266                 dev_err(&pdev->dev, "%s: ERROR: failed to enable device\n",
 267                         __func__);
 268                 return ret;
 269         }
 270
 271         /* Get the base address of device */
 272         for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {
 273                 if (pci_resource_len(pdev, i) == 0)
 274                         continue;
 275                 ret = pcim_iomap_regions(pdev, BIT(i), pci_name(pdev));
 276                 if (ret)
 277                         return ret;
 278                 break;
 279         }
 280
 281         pci_set_master(pdev);
 282
 283         ret = info->setup(pdev, plat);
 284         if (ret)
 285                 return ret;
 286
 287         pci_enable_msi(pdev);
 288
 289         memset(&res, 0, sizeof(res));
 290         res.addr = pcim_iomap_table(pdev)[i];
 291         res.wol_irq = pdev->irq;
 292         res.irq = pdev->irq;
 293
 294         return stmmac_dvr_probe(&pdev->dev, plat, &res);
 295 }
 296
 297 /**
 298  * stmmac_pci_remove
 299  *
 300  * @pdev: platform device pointer
 301  * Description: this function calls the main to free the net resources
 302  * and releases the PCI resources.
 303  */
 304 static void stmmac_pci_remove(struct pci_dev *pdev)
 305 {
 306         int i;
 307
 308         stmmac_dvr_remove(&pdev->dev);
 309
 310         for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {
 311                 if (pci_resource_len(pdev, i) == 0)
 312                         continue;
 313                 pcim_iounmap_regions(pdev, BIT(i));
 314                 break;
 315         }
 316
 317         pci_disable_device(pdev);
 318 }
 319
 320 static int __maybe_unused stmmac_pci_suspend(struct device *dev)
 321 {
 322         struct pci_dev *pdev = to_pci_dev(dev);
 323         int ret;
 324
 325         ret = stmmac_suspend(dev);
 326         if (ret)
 327                 return ret;
 328
 329         ret = pci_save_state(pdev);
 330         if (ret)
 331                 return ret;
 332
 333         pci_disable_device(pdev);
 334         pci_wake_from_d3(pdev, true);
 335         return 0;
 336 }
 337
 338 static int __maybe_unused stmmac_pci_resume(struct device *dev)
 339 {
 340         struct pci_dev *pdev = to_pci_dev(dev);
 341         int ret;
 342
 343         pci_restore_state(pdev);
 344         pci_set_power_state(pdev, PCI_D0);
 345
 346         ret = pci_enable_device(pdev);
 347         if (ret)
 348                 return ret;
 349
 350         pci_set_master(pdev);
 351
 352         return stmmac_resume(dev);
 353 }
 354
 355 static SIMPLE_DEV_PM_OPS(stmmac_pm_ops, stmmac_pci_suspend, stmmac_pci_resume);
 356
 357 /* synthetic ID, no official vendor */
 358 #define PCI_VENDOR_ID_STMMAC 0x700
 359
 360 #define STMMAC_QUARK_ID  0x0937
 361 #define STMMAC_DEVICE_ID 0x1108
 362
 363 #define STMMAC_DEVICE(vendor_id, dev_id, info)  {       \
 364         PCI_VDEVICE(vendor_id, dev_id),                 \
 365         .driver_data = (kernel_ulong_t)&info            \
 366         }
 367
 368 static const struct pci_device_id stmmac_id_table[] = {
 369         STMMAC_DEVICE(STMMAC, STMMAC_DEVICE_ID, stmmac_pci_info),
 370         STMMAC_DEVICE(STMICRO, PCI_DEVICE_ID_STMICRO_MAC, stmmac_pci_info),
 371         STMMAC_DEVICE(INTEL, STMMAC_QUARK_ID, quark_pci_info),
 372         {}
 373 };
 374
 375 MODULE_DEVICE_TABLE(pci, stmmac_id_table);
 376
 377 static struct pci_driver stmmac_pci_driver = {
 378         .name = STMMAC_RESOURCE_NAME,
 379         .id_table = stmmac_id_table,
 380         .probe = stmmac_pci_probe,
 381         .remove = stmmac_pci_remove,
 382         .driver         = {
 383                 .pm     = &stmmac_pm_ops,
 384         },
 385 };
 386
 387 module_pci_driver(stmmac_pci_driver);
 388
 389 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PCI driver");
 390 MODULE_AUTHOR("Rayagond Kokatanur <rayagond.kokatanur@vayavyalabs.com>");
 391 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
 392 MODULE_LICENSE("GPL");