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 stmmac_dvr_remove(&pdev->dev); 303 pci_disable_device(pdev); 304 } 305 306 static int __maybe_unused stmmac_pci_suspend(struct device *dev) 307 { 308 struct pci_dev *pdev = to_pci_dev(dev); 309 int ret; 310 311 ret = stmmac_suspend(dev); 312 if (ret) 313 return ret; 314 315 ret = pci_save_state(pdev); 316 if (ret) 317 return ret; 318 319 pci_disable_device(pdev); 320 pci_wake_from_d3(pdev, true); 321 return 0; 322 } 323 324 static int __maybe_unused stmmac_pci_resume(struct device *dev) 325 { 326 struct pci_dev *pdev = to_pci_dev(dev); 327 int ret; 328 329 pci_restore_state(pdev); 330 pci_set_power_state(pdev, PCI_D0); 331 332 ret = pci_enable_device(pdev); 333 if (ret) 334 return ret; 335 336 pci_set_master(pdev); 337 338 return stmmac_resume(dev); 339 } 340 341 static SIMPLE_DEV_PM_OPS(stmmac_pm_ops, stmmac_pci_suspend, stmmac_pci_resume); 342 343 /* synthetic ID, no official vendor */ 344 #define PCI_VENDOR_ID_STMMAC 0x700 345 346 #define STMMAC_QUARK_ID 0x0937 347 #define STMMAC_DEVICE_ID 0x1108 348 349 #define STMMAC_DEVICE(vendor_id, dev_id, info) { \ 350 PCI_VDEVICE(vendor_id, dev_id), \ 351 .driver_data = (kernel_ulong_t)&info \ 352 } 353 354 static const struct pci_device_id stmmac_id_table[] = { 355 STMMAC_DEVICE(STMMAC, STMMAC_DEVICE_ID, stmmac_pci_info), 356 STMMAC_DEVICE(STMICRO, PCI_DEVICE_ID_STMICRO_MAC, stmmac_pci_info), 357 STMMAC_DEVICE(INTEL, STMMAC_QUARK_ID, quark_pci_info), 358 {} 359 }; 360 361 MODULE_DEVICE_TABLE(pci, stmmac_id_table); 362 363 static struct pci_driver stmmac_pci_driver = { 364 .name = STMMAC_RESOURCE_NAME, 365 .id_table = stmmac_id_table, 366 .probe = stmmac_pci_probe, 367 .remove = stmmac_pci_remove, 368 .driver = { 369 .pm = &stmmac_pm_ops, 370 }, 371 }; 372 373 module_pci_driver(stmmac_pci_driver); 374 375 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PCI driver"); 376 MODULE_AUTHOR("Rayagond Kokatanur <rayagond.kokatanur@vayavyalabs.com>"); 377 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>"); 378 MODULE_LICENSE("GPL"); 379