Version:  2.0.40 2.2.26 2.4.37 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0

Linux/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c

  1 /*******************************************************************************
  2   This contains the functions to handle the platform driver.
  3 
  4   Copyright (C) 2007-2011  STMicroelectronics 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   You should have received a copy of the GNU General Public License along with
 16   this program; if not, write to the Free Software Foundation, Inc.,
 17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 18 
 19   The full GNU General Public License is included in this distribution in
 20   the file called "COPYING".
 21 
 22   Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
 23 *******************************************************************************/
 24 
 25 #include <linux/platform_device.h>
 26 #include <linux/io.h>
 27 #include <linux/of.h>
 28 #include <linux/of_net.h>
 29 #include <linux/of_device.h>
 30 
 31 #include "stmmac.h"
 32 #include "stmmac_platform.h"
 33 
 34 static const struct of_device_id stmmac_dt_ids[] = {
 35         /* SoC specific glue layers should come before generic bindings */
 36         { .compatible = "rockchip,rk3288-gmac", .data = &rk3288_gmac_data},
 37         { .compatible = "amlogic,meson6-dwmac", .data = &meson6_dwmac_data},
 38         { .compatible = "allwinner,sun7i-a20-gmac", .data = &sun7i_gmac_data},
 39         { .compatible = "st,stih415-dwmac", .data = &stih4xx_dwmac_data},
 40         { .compatible = "st,stih416-dwmac", .data = &stih4xx_dwmac_data},
 41         { .compatible = "st,stid127-dwmac", .data = &stid127_dwmac_data},
 42         { .compatible = "st,stih407-dwmac", .data = &stih4xx_dwmac_data},
 43         { .compatible = "altr,socfpga-stmmac", .data = &socfpga_gmac_data },
 44         { .compatible = "st,spear600-gmac"},
 45         { .compatible = "snps,dwmac-3.610"},
 46         { .compatible = "snps,dwmac-3.70a"},
 47         { .compatible = "snps,dwmac-3.710"},
 48         { .compatible = "snps,dwmac"},
 49         { /* sentinel */ }
 50 };
 51 MODULE_DEVICE_TABLE(of, stmmac_dt_ids);
 52 
 53 #ifdef CONFIG_OF
 54 
 55 /**
 56  * dwmac1000_validate_mcast_bins - validates the number of Multicast filter bins
 57  * @mcast_bins: Multicast filtering bins
 58  * Description:
 59  * this function validates the number of Multicast filtering bins specified
 60  * by the configuration through the device tree. The Synopsys GMAC supports
 61  * 64 bins, 128 bins, or 256 bins. "bins" refer to the division of CRC
 62  * number space. 64 bins correspond to 6 bits of the CRC, 128 corresponds
 63  * to 7 bits, and 256 refers to 8 bits of the CRC. Any other setting is
 64  * invalid and will cause the filtering algorithm to use Multicast
 65  * promiscuous mode.
 66  */
 67 static int dwmac1000_validate_mcast_bins(int mcast_bins)
 68 {
 69         int x = mcast_bins;
 70 
 71         switch (x) {
 72         case HASH_TABLE_SIZE:
 73         case 128:
 74         case 256:
 75                 break;
 76         default:
 77                 x = 0;
 78                 pr_info("Hash table entries set to unexpected value %d",
 79                         mcast_bins);
 80                 break;
 81         }
 82         return x;
 83 }
 84 
 85 /**
 86  * dwmac1000_validate_ucast_entries - validate the Unicast address entries
 87  * @ucast_entries: number of Unicast address entries
 88  * Description:
 89  * This function validates the number of Unicast address entries supported
 90  * by a particular Synopsys 10/100/1000 controller. The Synopsys controller
 91  * supports 1, 32, 64, or 128 Unicast filter entries for it's Unicast filter
 92  * logic. This function validates a valid, supported configuration is
 93  * selected, and defaults to 1 Unicast address if an unsupported
 94  * configuration is selected.
 95  */
 96 static int dwmac1000_validate_ucast_entries(int ucast_entries)
 97 {
 98         int x = ucast_entries;
 99 
100         switch (x) {
101         case 1:
102         case 32:
103         case 64:
104         case 128:
105                 break;
106         default:
107                 x = 1;
108                 pr_info("Unicast table entries set to unexpected value %d\n",
109                         ucast_entries);
110                 break;
111         }
112         return x;
113 }
114 
115 /**
116  * stmmac_probe_config_dt - parse device-tree driver parameters
117  * @pdev: platform_device structure
118  * @plat: driver data platform structure
119  * @mac: MAC address to use
120  * Description:
121  * this function is to read the driver parameters from device-tree and
122  * set some private fields that will be used by the main at runtime.
123  */
124 static int stmmac_probe_config_dt(struct platform_device *pdev,
125                                   struct plat_stmmacenet_data *plat,
126                                   const char **mac)
127 {
128         struct device_node *np = pdev->dev.of_node;
129         struct stmmac_dma_cfg *dma_cfg;
130         const struct of_device_id *device;
131 
132         if (!np)
133                 return -ENODEV;
134 
135         device = of_match_device(stmmac_dt_ids, &pdev->dev);
136         if (!device)
137                 return -ENODEV;
138 
139         if (device->data) {
140                 const struct stmmac_of_data *data = device->data;
141                 plat->has_gmac = data->has_gmac;
142                 plat->enh_desc = data->enh_desc;
143                 plat->tx_coe = data->tx_coe;
144                 plat->rx_coe = data->rx_coe;
145                 plat->bugged_jumbo = data->bugged_jumbo;
146                 plat->pmt = data->pmt;
147                 plat->riwt_off = data->riwt_off;
148                 plat->fix_mac_speed = data->fix_mac_speed;
149                 plat->bus_setup = data->bus_setup;
150                 plat->setup = data->setup;
151                 plat->free = data->free;
152                 plat->init = data->init;
153                 plat->exit = data->exit;
154         }
155 
156         *mac = of_get_mac_address(np);
157         plat->interface = of_get_phy_mode(np);
158 
159         /* Get max speed of operation from device tree */
160         if (of_property_read_u32(np, "max-speed", &plat->max_speed))
161                 plat->max_speed = -1;
162 
163         plat->bus_id = of_alias_get_id(np, "ethernet");
164         if (plat->bus_id < 0)
165                 plat->bus_id = 0;
166 
167         /* Default to phy auto-detection */
168         plat->phy_addr = -1;
169 
170         /* "snps,phy-addr" is not a standard property. Mark it as deprecated
171          * and warn of its use. Remove this when phy node support is added.
172          */
173         if (of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr) == 0)
174                 dev_warn(&pdev->dev, "snps,phy-addr property is deprecated\n");
175 
176         if (plat->phy_bus_name)
177                 plat->mdio_bus_data = NULL;
178         else
179                 plat->mdio_bus_data =
180                         devm_kzalloc(&pdev->dev,
181                                      sizeof(struct stmmac_mdio_bus_data),
182                                      GFP_KERNEL);
183 
184         plat->force_sf_dma_mode =
185                 of_property_read_bool(np, "snps,force_sf_dma_mode");
186 
187         /* Set the maxmtu to a default of JUMBO_LEN in case the
188          * parameter is not present in the device tree.
189          */
190         plat->maxmtu = JUMBO_LEN;
191 
192         /*
193          * Currently only the properties needed on SPEAr600
194          * are provided. All other properties should be added
195          * once needed on other platforms.
196          */
197         if (of_device_is_compatible(np, "st,spear600-gmac") ||
198                 of_device_is_compatible(np, "snps,dwmac-3.70a") ||
199                 of_device_is_compatible(np, "snps,dwmac")) {
200                 /* Note that the max-frame-size parameter as defined in the
201                  * ePAPR v1.1 spec is defined as max-frame-size, it's
202                  * actually used as the IEEE definition of MAC Client
203                  * data, or MTU. The ePAPR specification is confusing as
204                  * the definition is max-frame-size, but usage examples
205                  * are clearly MTUs
206                  */
207                 of_property_read_u32(np, "max-frame-size", &plat->maxmtu);
208                 of_property_read_u32(np, "snps,multicast-filter-bins",
209                                      &plat->multicast_filter_bins);
210                 of_property_read_u32(np, "snps,perfect-filter-entries",
211                                      &plat->unicast_filter_entries);
212                 plat->unicast_filter_entries = dwmac1000_validate_ucast_entries(
213                                                plat->unicast_filter_entries);
214                 plat->multicast_filter_bins = dwmac1000_validate_mcast_bins(
215                                               plat->multicast_filter_bins);
216                 plat->has_gmac = 1;
217                 plat->pmt = 1;
218         }
219 
220         if (of_device_is_compatible(np, "snps,dwmac-3.610") ||
221                 of_device_is_compatible(np, "snps,dwmac-3.710")) {
222                 plat->enh_desc = 1;
223                 plat->bugged_jumbo = 1;
224                 plat->force_sf_dma_mode = 1;
225         }
226 
227         if (of_find_property(np, "snps,pbl", NULL)) {
228                 dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg),
229                                        GFP_KERNEL);
230                 if (!dma_cfg)
231                         return -ENOMEM;
232                 plat->dma_cfg = dma_cfg;
233                 of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl);
234                 dma_cfg->fixed_burst =
235                         of_property_read_bool(np, "snps,fixed-burst");
236                 dma_cfg->mixed_burst =
237                         of_property_read_bool(np, "snps,mixed-burst");
238                 of_property_read_u32(np, "snps,burst_len", &dma_cfg->burst_len);
239                 if (dma_cfg->burst_len < 0 || dma_cfg->burst_len > 256)
240                         dma_cfg->burst_len = 0;
241         }
242         plat->force_thresh_dma_mode = of_property_read_bool(np, "snps,force_thresh_dma_mode");
243         if (plat->force_thresh_dma_mode) {
244                 plat->force_sf_dma_mode = 0;
245                 pr_warn("force_sf_dma_mode is ignored if force_thresh_dma_mode is set.");
246         }
247 
248         return 0;
249 }
250 #else
251 static int stmmac_probe_config_dt(struct platform_device *pdev,
252                                   struct plat_stmmacenet_data *plat,
253                                   const char **mac)
254 {
255         return -ENOSYS;
256 }
257 #endif /* CONFIG_OF */
258 
259 /**
260  * stmmac_pltfr_probe - platform driver probe.
261  * @pdev: platform device pointer
262  * Description: platform_device probe function. It is to allocate
263  * the necessary platform resources, invoke custom helper (if required) and
264  * invoke the main probe function.
265  */
266 static int stmmac_pltfr_probe(struct platform_device *pdev)
267 {
268         int ret = 0;
269         struct resource *res;
270         struct device *dev = &pdev->dev;
271         void __iomem *addr = NULL;
272         struct stmmac_priv *priv = NULL;
273         struct plat_stmmacenet_data *plat_dat = NULL;
274         const char *mac = NULL;
275         int irq, wol_irq, lpi_irq;
276 
277         /* Get IRQ information early to have an ability to ask for deferred
278          * probe if needed before we went too far with resource allocation.
279          */
280         irq = platform_get_irq_byname(pdev, "macirq");
281         if (irq < 0) {
282                 if (irq != -EPROBE_DEFER) {
283                         dev_err(dev,
284                                 "MAC IRQ configuration information not found\n");
285                 }
286                 return irq;
287         }
288 
289         /* On some platforms e.g. SPEAr the wake up irq differs from the mac irq
290          * The external wake up irq can be passed through the platform code
291          * named as "eth_wake_irq"
292          *
293          * In case the wake up interrupt is not passed from the platform
294          * so the driver will continue to use the mac irq (ndev->irq)
295          */
296         wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
297         if (wol_irq < 0) {
298                 if (wol_irq == -EPROBE_DEFER)
299                         return -EPROBE_DEFER;
300                 wol_irq = irq;
301         }
302 
303         lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");
304         if (lpi_irq == -EPROBE_DEFER)
305                 return -EPROBE_DEFER;
306 
307         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
308         addr = devm_ioremap_resource(dev, res);
309         if (IS_ERR(addr))
310                 return PTR_ERR(addr);
311 
312         plat_dat = dev_get_platdata(&pdev->dev);
313 
314         if (!plat_dat)
315                 plat_dat = devm_kzalloc(&pdev->dev,
316                                         sizeof(struct plat_stmmacenet_data),
317                                         GFP_KERNEL);
318         if (!plat_dat) {
319                 pr_err("%s: ERROR: no memory", __func__);
320                 return  -ENOMEM;
321         }
322 
323         /* Set default value for multicast hash bins */
324         plat_dat->multicast_filter_bins = HASH_TABLE_SIZE;
325 
326         /* Set default value for unicast filter entries */
327         plat_dat->unicast_filter_entries = 1;
328 
329         if (pdev->dev.of_node) {
330                 ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
331                 if (ret) {
332                         pr_err("%s: main dt probe failed", __func__);
333                         return ret;
334                 }
335         }
336 
337         /* Custom setup (if needed) */
338         if (plat_dat->setup) {
339                 plat_dat->bsp_priv = plat_dat->setup(pdev);
340                 if (IS_ERR(plat_dat->bsp_priv))
341                         return PTR_ERR(plat_dat->bsp_priv);
342         }
343 
344         /* Custom initialisation (if needed)*/
345         if (plat_dat->init) {
346                 ret = plat_dat->init(pdev, plat_dat->bsp_priv);
347                 if (unlikely(ret))
348                         return ret;
349         }
350 
351         priv = stmmac_dvr_probe(&(pdev->dev), plat_dat, addr);
352         if (IS_ERR(priv)) {
353                 pr_err("%s: main driver probe failed", __func__);
354                 return PTR_ERR(priv);
355         }
356 
357         /* Copy IRQ values to priv structure which is now avaialble */
358         priv->dev->irq = irq;
359         priv->wol_irq = wol_irq;
360         priv->lpi_irq = lpi_irq;
361 
362         /* Get MAC address if available (DT) */
363         if (mac)
364                 memcpy(priv->dev->dev_addr, mac, ETH_ALEN);
365 
366         platform_set_drvdata(pdev, priv->dev);
367 
368         pr_debug("STMMAC platform driver registration completed");
369 
370         return 0;
371 }
372 
373 /**
374  * stmmac_pltfr_remove
375  * @pdev: platform device pointer
376  * Description: this function calls the main to free the net resources
377  * and calls the platforms hook and release the resources (e.g. mem).
378  */
379 static int stmmac_pltfr_remove(struct platform_device *pdev)
380 {
381         struct net_device *ndev = platform_get_drvdata(pdev);
382         struct stmmac_priv *priv = netdev_priv(ndev);
383         int ret = stmmac_dvr_remove(ndev);
384 
385         if (priv->plat->exit)
386                 priv->plat->exit(pdev, priv->plat->bsp_priv);
387 
388         if (priv->plat->free)
389                 priv->plat->free(pdev, priv->plat->bsp_priv);
390 
391         return ret;
392 }
393 
394 #ifdef CONFIG_PM_SLEEP
395 /**
396  * stmmac_pltfr_suspend
397  * @dev: device pointer
398  * Description: this function is invoked when suspend the driver and it direcly
399  * call the main suspend function and then, if required, on some platform, it
400  * can call an exit helper.
401  */
402 static int stmmac_pltfr_suspend(struct device *dev)
403 {
404         int ret;
405         struct net_device *ndev = dev_get_drvdata(dev);
406         struct stmmac_priv *priv = netdev_priv(ndev);
407         struct platform_device *pdev = to_platform_device(dev);
408 
409         ret = stmmac_suspend(ndev);
410         if (priv->plat->exit)
411                 priv->plat->exit(pdev, priv->plat->bsp_priv);
412 
413         return ret;
414 }
415 
416 /**
417  * stmmac_pltfr_resume
418  * @dev: device pointer
419  * Description: this function is invoked when resume the driver before calling
420  * the main resume function, on some platforms, it can call own init helper
421  * if required.
422  */
423 static int stmmac_pltfr_resume(struct device *dev)
424 {
425         struct net_device *ndev = dev_get_drvdata(dev);
426         struct stmmac_priv *priv = netdev_priv(ndev);
427         struct platform_device *pdev = to_platform_device(dev);
428 
429         if (priv->plat->init)
430                 priv->plat->init(pdev, priv->plat->bsp_priv);
431 
432         return stmmac_resume(ndev);
433 }
434 #endif /* CONFIG_PM_SLEEP */
435 
436 static SIMPLE_DEV_PM_OPS(stmmac_pltfr_pm_ops,
437                          stmmac_pltfr_suspend, stmmac_pltfr_resume);
438 
439 static struct platform_driver stmmac_pltfr_driver = {
440         .probe = stmmac_pltfr_probe,
441         .remove = stmmac_pltfr_remove,
442         .driver = {
443                    .name = STMMAC_RESOURCE_NAME,
444                    .pm = &stmmac_pltfr_pm_ops,
445                    .of_match_table = of_match_ptr(stmmac_dt_ids),
446         },
447 };
448 
449 module_platform_driver(stmmac_pltfr_driver);
450 
451 MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PLATFORM driver");
452 MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
453 MODULE_LICENSE("GPL");
454 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us