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