xref: /openbmc/linux/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c (revision abade675e02e1b73da0c20ffaf08fbe309038298)
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 	 * There are 2 types of SIMATIC IOT2000: IOT2020 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 
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_dev_id(pdev);
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  */
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  */
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 
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 
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