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"); 272