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
stmmac_pci_find_phy_addr(struct pci_dev * pdev,const struct dmi_system_id * dmi_list)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
common_default_data(struct plat_stmmacenet_data * plat)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
stmmac_default_data(struct pci_dev * pdev,struct plat_stmmacenet_data * plat)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: IOT20202 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
quark_default_data(struct pci_dev * pdev,struct plat_stmmacenet_data * plat)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 */
stmmac_pci_probe(struct pci_dev * pdev,const struct pci_device_id * id)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 */
stmmac_pci_remove(struct pci_dev * pdev)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
stmmac_pci_suspend(struct device * dev)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
stmmac_pci_resume(struct device * dev)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");
393