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_dmi_data {
  34         const char *name;
  35         unsigned int func;
  36         int phy_addr;
  37 };
  38
  39 struct stmmac_pci_info {
  40         struct pci_dev *pdev;
  41         int (*setup)(struct plat_stmmacenet_data *plat,
  42                      struct stmmac_pci_info *info);
  43         struct stmmac_pci_dmi_data *dmi;
  44 };
  45
  46 static int stmmac_pci_find_phy_addr(struct stmmac_pci_info *info)
  47 {
  48         const char *name = dmi_get_system_info(DMI_BOARD_NAME);
  49         unsigned int func = PCI_FUNC(info->pdev->devfn);
  50         struct stmmac_pci_dmi_data *dmi;
  51
  52         /*
  53          * Galileo boards with old firmware don't support DMI. We always return
  54          * 1 here, so at least first found MAC controller would be probed.
  55          */
  56         if (!name)
  57                 return 1;
  58
  59         for (dmi = info->dmi; dmi->name && *dmi->name; dmi++) {
  60                 if (!strcmp(dmi->name, name) && dmi->func == func)
  61                         return dmi->phy_addr;
  62         }
  63
  64         return -ENODEV;
  65 }
  66
  67 static void stmmac_default_data(struct plat_stmmacenet_data *plat)
  68 {
  69         plat->bus_id = 1;
  70         plat->phy_addr = 0;
  71         plat->interface = PHY_INTERFACE_MODE_GMII;
  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         plat->dma_cfg->pbl = 32;
  80         plat->dma_cfg->pblx8 = true;
  81         /* TODO: AXI */
  82
  83         /* Set default value for multicast hash bins */
  84         plat->multicast_filter_bins = HASH_TABLE_SIZE;
  85
  86         /* Set default value for unicast filter entries */
  87         plat->unicast_filter_entries = 1;
  88
  89         /* Set the maxmtu to a default of JUMBO_LEN */
  90         plat->maxmtu = JUMBO_LEN;
  91 }
  92
  93 static int quark_default_data(struct plat_stmmacenet_data *plat,
  94                               struct stmmac_pci_info *info)
  95 {
  96         struct pci_dev *pdev = info->pdev;
  97         int ret;
  98
  99         /*
 100          * Refuse to load the driver and register net device if MAC controller
 101          * does not connect to any PHY interface.
 102          */
 103         ret = stmmac_pci_find_phy_addr(info);
 104         if (ret < 0)
 105                 return ret;
 106
 107         plat->bus_id = PCI_DEVID(pdev->bus->number, pdev->devfn);
 108         plat->phy_addr = ret;
 109         plat->interface = PHY_INTERFACE_MODE_RMII;
 110         plat->clk_csr = 2;
 111         plat->has_gmac = 1;
 112         plat->force_sf_dma_mode = 1;
 113
 114         plat->mdio_bus_data->phy_reset = NULL;
 115         plat->mdio_bus_data->phy_mask = 0;
 116
 117         plat->dma_cfg->pbl = 16;
 118         plat->dma_cfg->pblx8 = true;
 119         plat->dma_cfg->fixed_burst = 1;
 120         /* AXI (TODO) */
 121
 122         /* Set default value for multicast hash bins */
 123         plat->multicast_filter_bins = HASH_TABLE_SIZE;
 124
 125         /* Set default value for unicast filter entries */
 126         plat->unicast_filter_entries = 1;
 127
 128         /* Set the maxmtu to a default of JUMBO_LEN */
 129         plat->maxmtu = JUMBO_LEN;
 130
 131         return 0;
 132 }
 133
 134 static struct stmmac_pci_dmi_data quark_pci_dmi_data[] = {
 135         {
 136                 .name = "Galileo",
 137                 .func = 6,
 138                 .phy_addr = 1,
 139         },
 140         {
 141                 .name = "GalileoGen2",
 142                 .func = 6,
 143                 .phy_addr = 1,
 144         },
 145         {}
 146 };
 147
 148 static struct stmmac_pci_info quark_pci_info = {
 149         .setup = quark_default_data,
 150         .dmi = quark_pci_dmi_data,
 151 };
 152
 153 /**
 154  * stmmac_pci_probe
 155  *
 156  * @pdev: pci device pointer
 157  * @id: pointer to table of device id/id's.
 158  *
 159  * Description: This probing function gets called for all PCI devices which
 160  * match the ID table and are not "owned" by other driver yet. This function
 161  * gets passed a "struct pci_dev *" for each device whose entry in the ID table
 162  * matches the device. The probe functions returns zero when the driver choose
 163  * to take "ownership" of the device or an error code(-ve no) otherwise.
 164  */
 165 static int stmmac_pci_probe(struct pci_dev *pdev,
 166                             const struct pci_device_id *id)
 167 {
 168         struct stmmac_pci_info *info = (struct stmmac_pci_info *)id->driver_data;
 169         struct plat_stmmacenet_data *plat;
 170         struct stmmac_resources res;
 171         int i;
 172         int ret;
 173
 174         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
 175         if (!plat)
 176                 return -ENOMEM;
 177
 178         plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
 179                                            sizeof(*plat->mdio_bus_data),
 180                                            GFP_KERNEL);
 181         if (!plat->mdio_bus_data)
 182                 return -ENOMEM;
 183
 184         plat->dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*plat->dma_cfg),
 185                                      GFP_KERNEL);
 186         if (!plat->dma_cfg)
 187                 return -ENOMEM;
 188
 189         /* Enable pci device */
 190         ret = pcim_enable_device(pdev);
 191         if (ret) {
 192                 dev_err(&pdev->dev, "%s: ERROR: failed to enable device\n",
 193                         __func__);
 194                 return ret;
 195         }
 196
 197         /* Get the base address of device */
 198         for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {
 199                 if (pci_resource_len(pdev, i) == 0)
 200                         continue;
 201                 ret = pcim_iomap_regions(pdev, BIT(i), pci_name(pdev));
 202                 if (ret)
 203                         return ret;
 204                 break;
 205         }
 206
 207         pci_set_master(pdev);
 208
 209         if (info) {
 210                 info->pdev = pdev;
 211                 if (info->setup) {
 212                         ret = info->setup(plat, info);
 213                         if (ret)
 214                                 return ret;
 215                 }
 216         } else
 217                 stmmac_default_data(plat);
 218
 219         pci_enable_msi(pdev);
 220
 221         memset(&res, 0, sizeof(res));
 222         res.addr = pcim_iomap_table(pdev)[i];
 223         res.wol_irq = pdev->irq;
 224         res.irq = pdev->irq;
 225
 226         return stmmac_dvr_probe(&pdev->dev, plat, &res);
 227 }
 228
 229 /**
 230  * stmmac_pci_remove
 231  *
 232  * @pdev: platform device pointer
 233  * Description: this function calls the main to free the net resources
 234  * and releases the PCI resources.
 235  */
 236 static void stmmac_pci_remove(struct pci_dev *pdev)
 237 {
 238         stmmac_dvr_remove(&pdev->dev);
 239 }
 240
 241 static SIMPLE_DEV_PM_OPS(stmmac_pm_ops, stmmac_suspend, stmmac_resume);
 242
 243 #define STMMAC_VENDOR_ID 0x700
 244 #define STMMAC_QUARK_ID  0x0937
 245 #define STMMAC_DEVICE_ID 0x1108
 246
 247 static const struct pci_device_id stmmac_id_table[] = {
 248         {PCI_DEVICE(STMMAC_VENDOR_ID, STMMAC_DEVICE_ID)},
 249         {PCI_DEVICE(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_MAC)},
 250         {PCI_VDEVICE(INTEL, STMMAC_QUARK_ID), (kernel_ulong_t)&quark_pci_info},
 251         {}
 252 };
 253
 254 MODULE_DEVICE_TABLE(pci, stmmac_id_table);
 255
 256 static struct pci_driver stmmac_pci_driver = {
 257         .name = STMMAC_RESOURCE_NAME,
 258         .id_table = stmmac_id_table,
 259         .probe = stmmac_pci_probe,
 260         .remove = stmmac_pci_remove,
 261         .driver         = {
 262                 .pm     = &stmmac_pm_ops,
 263         },
 264 };
 265
 266 module_pci_driver(stmmac_pci_driver);
 267
 268 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PCI driver");
 269 MODULE_AUTHOR("Rayagond Kokatanur <rayagond.kokatanur@vayavyalabs.com>");
 270 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
 271 MODULE_LICENSE("GPL");