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 = pcim_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 }
304 
305 static SIMPLE_DEV_PM_OPS(stmmac_pm_ops, stmmac_suspend, stmmac_resume);
306 
307 /* synthetic ID, no official vendor */
308 #define PCI_VENDOR_ID_STMMAC 0x700
309 
310 #define STMMAC_QUARK_ID  0x0937
311 #define STMMAC_DEVICE_ID 0x1108
312 
313 #define STMMAC_DEVICE(vendor_id, dev_id, info)	{	\
314 	PCI_VDEVICE(vendor_id, dev_id),			\
315 	.driver_data = (kernel_ulong_t)&info		\
316 	}
317 
318 static const struct pci_device_id stmmac_id_table[] = {
319 	STMMAC_DEVICE(STMMAC, STMMAC_DEVICE_ID, stmmac_pci_info),
320 	STMMAC_DEVICE(STMICRO, PCI_DEVICE_ID_STMICRO_MAC, stmmac_pci_info),
321 	STMMAC_DEVICE(INTEL, STMMAC_QUARK_ID, quark_pci_info),
322 	{}
323 };
324 
325 MODULE_DEVICE_TABLE(pci, stmmac_id_table);
326 
327 static struct pci_driver stmmac_pci_driver = {
328 	.name = STMMAC_RESOURCE_NAME,
329 	.id_table = stmmac_id_table,
330 	.probe = stmmac_pci_probe,
331 	.remove = stmmac_pci_remove,
332 	.driver         = {
333 		.pm     = &stmmac_pm_ops,
334 	},
335 };
336 
337 module_pci_driver(stmmac_pci_driver);
338 
339 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PCI driver");
340 MODULE_AUTHOR("Rayagond Kokatanur <rayagond.kokatanur@vayavyalabs.com>");
341 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
342 MODULE_LICENSE("GPL");
343