[deliverable/linux.git] / drivers / net / ethernet / stmicro / stmmac / stmmac_platform.c

/*******************************************************************************
  This contains the functions to handle the platform driver.

  Copyright (C) 2007-2011  STMicroelectronics Ltd

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
*******************************************************************************/

#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_net.h>
#include "stmmac.h"

#ifdef CONFIG_OF
static int stmmac_probe_config_dt(struct platform_device *pdev,
				  struct plat_stmmacenet_data *plat,
				  const char **mac)
{
	struct device_node *np = pdev->dev.of_node;
	struct stmmac_dma_cfg *dma_cfg;

	if (!np)
		return -ENODEV;

	*mac = of_get_mac_address(np);
	plat->interface = of_get_phy_mode(np);

	plat->bus_id = of_alias_get_id(np, "ethernet");
	if (plat->bus_id < 0)
		plat->bus_id = 0;

	of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr);

	plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
					   sizeof(struct stmmac_mdio_bus_data),
					   GFP_KERNEL);

	/*
	 * Currently only the properties needed on SPEAr600
	 * are provided. All other properties should be added
	 * once needed on other platforms.
	 */
	if (of_device_is_compatible(np, "st,spear600-gmac") ||
		of_device_is_compatible(np, "snps,dwmac-3.70a") ||
		of_device_is_compatible(np, "snps,dwmac")) {
		plat->has_gmac = 1;
		plat->pmt = 1;
	}

	if (of_device_is_compatible(np, "snps,dwmac-3.610") ||
		of_device_is_compatible(np, "snps,dwmac-3.710")) {
		plat->enh_desc = 1;
		plat->bugged_jumbo = 1;
		plat->force_sf_dma_mode = 1;
	}

	dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg), GFP_KERNEL);
	if (!dma_cfg)
		return -ENOMEM;

	plat->dma_cfg = dma_cfg;
	of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl);
	dma_cfg->fixed_burst = of_property_read_bool(np, "snps,fixed-burst");
	dma_cfg->mixed_burst = of_property_read_bool(np, "snps,mixed-burst");

	return 0;
}
#else
static int stmmac_probe_config_dt(struct platform_device *pdev,
				  struct plat_stmmacenet_data *plat,
				  const char **mac)
{
	return -ENOSYS;
}
#endif /* CONFIG_OF */

/**
 * stmmac_pltfr_probe
 * @pdev: platform device pointer
 * Description: platform_device probe function. It allocates
 * the necessary resources and invokes the main to init
 * the net device, register the mdio bus etc.
 */
static int stmmac_pltfr_probe(struct platform_device *pdev)
{
	int ret = 0;
	struct resource *res;
	struct device *dev = &pdev->dev;
	void __iomem *addr = NULL;
	struct stmmac_priv *priv = NULL;
	struct plat_stmmacenet_data *plat_dat = NULL;
	const char *mac = NULL;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res)
		return -ENODEV;

	addr = devm_ioremap_resource(dev, res);
	if (IS_ERR(addr))
		return PTR_ERR(addr);

	plat_dat = pdev->dev.platform_data;
	if (pdev->dev.of_node) {
		if (!plat_dat)
			plat_dat = devm_kzalloc(&pdev->dev,
					sizeof(struct plat_stmmacenet_data),
					GFP_KERNEL);
		if (!plat_dat) {
			pr_err("%s: ERROR: no memory", __func__);
			return  -ENOMEM;
		}

		ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
		if (ret) {
			pr_err("%s: main dt probe failed", __func__);
			return ret;
		}
	}

	/* Custom initialisation (if needed)*/
	if (plat_dat->init) {
		ret = plat_dat->init(pdev);
		if (unlikely(ret))
			return ret;
	}

	priv = stmmac_dvr_probe(&(pdev->dev), plat_dat, addr);
	if (!priv) {
		pr_err("%s: main driver probe failed", __func__);
		return -ENODEV;
	}

	/* Get MAC address if available (DT) */
	if (mac)
		memcpy(priv->dev->dev_addr, mac, ETH_ALEN);

	/* Get the MAC information */
	priv->dev->irq = platform_get_irq_byname(pdev, "macirq");
	if (priv->dev->irq == -ENXIO) {
		pr_err("%s: ERROR: MAC IRQ configuration "
		       "information not found\n", __func__);
		return -ENXIO;
	}

	/*
	 * On some platforms e.g. SPEAr the wake up irq differs from the mac irq
	 * The external wake up irq can be passed through the platform code
	 * named as "eth_wake_irq"
	 *
	 * In case the wake up interrupt is not passed from the platform
	 * so the driver will continue to use the mac irq (ndev->irq)
	 */
	priv->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
	if (priv->wol_irq == -ENXIO)
		priv->wol_irq = priv->dev->irq;

	priv->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");

	platform_set_drvdata(pdev, priv->dev);

	pr_debug("STMMAC platform driver registration completed");

	return 0;
}

/**
 * stmmac_pltfr_remove
 * @pdev: platform device pointer
 * Description: this function calls the main to free the net resources
 * and calls the platforms hook and release the resources (e.g. mem).
 */
static int stmmac_pltfr_remove(struct platform_device *pdev)
{
	struct net_device *ndev = platform_get_drvdata(pdev);
	struct stmmac_priv *priv = netdev_priv(ndev);
	int ret = stmmac_dvr_remove(ndev);

	if (priv->plat->exit)
		priv->plat->exit(pdev);

	return ret;
}

#ifdef CONFIG_PM
static int stmmac_pltfr_suspend(struct device *dev)
{
	struct net_device *ndev = dev_get_drvdata(dev);

	return stmmac_suspend(ndev);
}

static int stmmac_pltfr_resume(struct device *dev)
{
	struct net_device *ndev = dev_get_drvdata(dev);

	return stmmac_resume(ndev);
}

int stmmac_pltfr_freeze(struct device *dev)
{
	int ret;
	struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
	struct net_device *ndev = dev_get_drvdata(dev);
	struct platform_device *pdev = to_platform_device(dev);

	ret = stmmac_freeze(ndev);
	if (plat_dat->exit)
		plat_dat->exit(pdev);

	return ret;
}

int stmmac_pltfr_restore(struct device *dev)
{
	struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
	struct net_device *ndev = dev_get_drvdata(dev);
	struct platform_device *pdev = to_platform_device(dev);

	if (plat_dat->init)
		plat_dat->init(pdev);

	return stmmac_restore(ndev);
}

static const struct dev_pm_ops stmmac_pltfr_pm_ops = {
	.suspend = stmmac_pltfr_suspend,
	.resume = stmmac_pltfr_resume,
	.freeze = stmmac_pltfr_freeze,
	.thaw = stmmac_pltfr_restore,
	.restore = stmmac_pltfr_restore,
};
#else
static const struct dev_pm_ops stmmac_pltfr_pm_ops;
#endif /* CONFIG_PM */

static const struct of_device_id stmmac_dt_ids[] = {
	{ .compatible = "st,spear600-gmac"},
	{ .compatible = "snps,dwmac-3.610"},
	{ .compatible = "snps,dwmac-3.70a"},
	{ .compatible = "snps,dwmac-3.710"},
	{ .compatible = "snps,dwmac"},
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, stmmac_dt_ids);

struct platform_driver stmmac_pltfr_driver = {
	.probe = stmmac_pltfr_probe,
	.remove = stmmac_pltfr_remove,
	.driver = {
		   .name = STMMAC_RESOURCE_NAME,
		   .owner = THIS_MODULE,
		   .pm = &stmmac_pltfr_pm_ops,
		   .of_match_table = of_match_ptr(stmmac_dt_ids),
		   },
};

MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PLATFORM driver");
MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
bfab27a1 GC	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>
6a228452 SR	27	#include <linux/of.h>
6a228452 SR	28	#include <linux/of_net.h>
bfab27a1 GC	29	#include "stmmac.h"
bfab27a1 GC	30
6a228452	31	#ifdef CONFIG_OF
979857bb	32	static int stmmac_probe_config_dt(struct platform_device *pdev,
1dd06ae8 GKH	33	struct plat_stmmacenet_data *plat,
1dd06ae8 GKH	34	const char **mac)
6a228452 SR	35	{
6a228452 SR	36	struct device_node *np = pdev->dev.of_node;
25c83b5c	37	struct stmmac_dma_cfg *dma_cfg;
6a228452 SR	38
	39	if (!np)
	40	return -ENODEV;
	41
	42	*mac = of_get_mac_address(np);
	43	plat->interface = of_get_phy_mode(np);
25c83b5c SK	44
	45	plat->bus_id = of_alias_get_id(np, "ethernet");
	46	if (plat->bus_id < 0)
	47	plat->bus_id = 0;
	48
	49	of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr);
	50
6a228452 SR	51	plat->mdio_bus_data = devm_kzalloc(&pdev->dev,
	52	sizeof(struct stmmac_mdio_bus_data),
	53	GFP_KERNEL);
	54
	55	/*
	56	* Currently only the properties needed on SPEAr600
	57	* are provided. All other properties should be added
	58	* once needed on other platforms.
	59	*/
84c9f8c4 DN	60	if (of_device_is_compatible(np, "st,spear600-gmac") \|\|
	61	of_device_is_compatible(np, "snps,dwmac-3.70a") \|\|
	62	of_device_is_compatible(np, "snps,dwmac")) {
6a228452 SR	63	plat->has_gmac = 1;
	64	plat->pmt = 1;
	65	}
	66
25c83b5c SK	67	if (of_device_is_compatible(np, "snps,dwmac-3.610") \|\|
	68	of_device_is_compatible(np, "snps,dwmac-3.710")) {
	69	plat->enh_desc = 1;
	70	plat->bugged_jumbo = 1;
	71	plat->force_sf_dma_mode = 1;
	72	}
	73
	74	dma_cfg = devm_kzalloc(&pdev->dev, sizeof(*dma_cfg), GFP_KERNEL);
	75	if (!dma_cfg)
	76	return -ENOMEM;
	77
	78	plat->dma_cfg = dma_cfg;
	79	of_property_read_u32(np, "snps,pbl", &dma_cfg->pbl);
	80	dma_cfg->fixed_burst = of_property_read_bool(np, "snps,fixed-burst");
	81	dma_cfg->mixed_burst = of_property_read_bool(np, "snps,mixed-burst");
	82
6a228452 SR	83	return 0;
	84	}
	85	#else
979857bb	86	static int stmmac_probe_config_dt(struct platform_device *pdev,
1dd06ae8 GKH	87	struct plat_stmmacenet_data *plat,
1dd06ae8 GKH	88	const char **mac)
6a228452 SR	89	{
	90	return -ENOSYS;
	91	}
	92	#endif /* CONFIG_OF */
	93
bfab27a1 GC	94	/**
	95	* stmmac_pltfr_probe
	96	* @pdev: platform device pointer
	97	* Description: platform_device probe function. It allocates
	98	* the necessary resources and invokes the main to init
	99	* the net device, register the mdio bus etc.
	100	*/
979857bb	101	static int stmmac_pltfr_probe(struct platform_device *pdev)
bfab27a1 GC	102	{
	103	int ret = 0;
	104	struct resource *res;
3f8bdecd	105	struct device *dev = &pdev->dev;
bfab27a1 GC	106	void __iomem *addr = NULL;
bfab27a1 GC	107	struct stmmac_priv *priv = NULL;
6a228452 SR	108	struct plat_stmmacenet_data *plat_dat = NULL;
6a228452 SR	109	const char *mac = NULL;
bfab27a1 GC	110
	111	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	112	if (!res)
	113	return -ENODEV;
	114
5760f427 SMP	115	addr = devm_ioremap_resource(dev, res);
	116	if (IS_ERR(addr))
	117	return PTR_ERR(addr);
6a228452	118
d741434c	119	plat_dat = pdev->dev.platform_data;
6a228452	120	if (pdev->dev.of_node) {
d741434c SK	121	if (!plat_dat)
d741434c SK	122	plat_dat = devm_kzalloc(&pdev->dev,
6a228452 SR	123	sizeof(struct plat_stmmacenet_data),
	124	GFP_KERNEL);
	125	if (!plat_dat) {
	126	pr_err("%s: ERROR: no memory", __func__);
3f8bdecd	127	return -ENOMEM;
6a228452 SR	128	}
	129
	130	ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
	131	if (ret) {
	132	pr_err("%s: main dt probe failed", __func__);
3f8bdecd	133	return ret;
6a228452	134	}
6a228452	135	}
cf3f047b GC	136
	137	/* Custom initialisation (if needed)*/
	138	if (plat_dat->init) {
	139	ret = plat_dat->init(pdev);
	140	if (unlikely(ret))
3f8bdecd	141	return ret;
cf3f047b GC	142	}
	143
	144	priv = stmmac_dvr_probe(&(pdev->dev), plat_dat, addr);
bfab27a1	145	if (!priv) {
cf3f047b	146	pr_err("%s: main driver probe failed", __func__);
3f8bdecd	147	return -ENODEV;
bfab27a1 GC	148	}
bfab27a1 GC	149
6a228452 SR	150	/* Get MAC address if available (DT) */
	151	if (mac)
	152	memcpy(priv->dev->dev_addr, mac, ETH_ALEN);
	153
bfab27a1 GC	154	/* Get the MAC information */
	155	priv->dev->irq = platform_get_irq_byname(pdev, "macirq");
	156	if (priv->dev->irq == -ENXIO) {
	157	pr_err("%s: ERROR: MAC IRQ configuration "
	158	"information not found\n", __func__);
3f8bdecd	159	return -ENXIO;
bfab27a1 GC	160	}
	161
	162	/*
	163	* On some platforms e.g. SPEAr the wake up irq differs from the mac irq
	164	* The external wake up irq can be passed through the platform code
	165	* named as "eth_wake_irq"
	166	*
	167	* In case the wake up interrupt is not passed from the platform
	168	* so the driver will continue to use the mac irq (ndev->irq)
	169	*/
	170	priv->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
	171	if (priv->wol_irq == -ENXIO)
	172	priv->wol_irq = priv->dev->irq;
	173
d765955d GC	174	priv->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");
d765955d GC	175
bfab27a1 GC	176	platform_set_drvdata(pdev, priv->dev);
bfab27a1 GC	177
bfab27a1 GC	178	pr_debug("STMMAC platform driver registration completed");
	179
	180	return 0;
bfab27a1 GC	181	}
	182
	183	/**
	184	* stmmac_pltfr_remove
	185	* @pdev: platform device pointer
	186	* Description: this function calls the main to free the net resources
	187	* and calls the platforms hook and release the resources (e.g. mem).
	188	*/
	189	static int stmmac_pltfr_remove(struct platform_device *pdev)
	190	{
	191	struct net_device *ndev = platform_get_drvdata(pdev);
	192	struct stmmac_priv *priv = netdev_priv(ndev);
bfab27a1 GC	193	int ret = stmmac_dvr_remove(ndev);
bfab27a1 GC	194
bfab27a1 GC	195	if (priv->plat->exit)
	196	priv->plat->exit(pdev);
	197
bfab27a1 GC	198	return ret;
	199	}
	200
	201	#ifdef CONFIG_PM
	202	static int stmmac_pltfr_suspend(struct device *dev)
	203	{
	204	struct net_device *ndev = dev_get_drvdata(dev);
	205
	206	return stmmac_suspend(ndev);
	207	}
	208
	209	static int stmmac_pltfr_resume(struct device *dev)
	210	{
	211	struct net_device *ndev = dev_get_drvdata(dev);
	212
	213	return stmmac_resume(ndev);
	214	}
	215
	216	int stmmac_pltfr_freeze(struct device *dev)
	217	{
3256251f FV	218	int ret;
3256251f FV	219	struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
bfab27a1	220	struct net_device *ndev = dev_get_drvdata(dev);
3256251f	221	struct platform_device *pdev = to_platform_device(dev);
bfab27a1	222
3256251f FV	223	ret = stmmac_freeze(ndev);
	224	if (plat_dat->exit)
	225	plat_dat->exit(pdev);
	226
	227	return ret;
bfab27a1 GC	228	}
	229
	230	int stmmac_pltfr_restore(struct device *dev)
	231	{
3256251f	232	struct plat_stmmacenet_data *plat_dat = dev_get_platdata(dev);
bfab27a1	233	struct net_device *ndev = dev_get_drvdata(dev);
3256251f FV	234	struct platform_device *pdev = to_platform_device(dev);
	235
	236	if (plat_dat->init)
	237	plat_dat->init(pdev);
bfab27a1 GC	238
	239	return stmmac_restore(ndev);
	240	}
	241
	242	static const struct dev_pm_ops stmmac_pltfr_pm_ops = {
	243	.suspend = stmmac_pltfr_suspend,
	244	.resume = stmmac_pltfr_resume,
	245	.freeze = stmmac_pltfr_freeze,
	246	.thaw = stmmac_pltfr_restore,
	247	.restore = stmmac_pltfr_restore,
	248	};
	249	#else
	250	static const struct dev_pm_ops stmmac_pltfr_pm_ops;
	251	#endif /* CONFIG_PM */
	252
6a228452	253	static const struct of_device_id stmmac_dt_ids[] = {
84c9f8c4	254	{ .compatible = "st,spear600-gmac"},
25c83b5c	255	{ .compatible = "snps,dwmac-3.610"},
84c9f8c4	256	{ .compatible = "snps,dwmac-3.70a"},
25c83b5c	257	{ .compatible = "snps,dwmac-3.710"},
84c9f8c4	258	{ .compatible = "snps,dwmac"},
6a228452 SR	259	{ /* sentinel */ }
	260	};
	261	MODULE_DEVICE_TABLE(of, stmmac_dt_ids);
	262
ba27ec66	263	struct platform_driver stmmac_pltfr_driver = {
bfab27a1 GC	264	.probe = stmmac_pltfr_probe,
	265	.remove = stmmac_pltfr_remove,
	266	.driver = {
	267	.name = STMMAC_RESOURCE_NAME,
	268	.owner = THIS_MODULE,
	269	.pm = &stmmac_pltfr_pm_ops,
6a228452	270	.of_match_table = of_match_ptr(stmmac_dt_ids),
bfab27a1 GC	271	},
	272	};
	273
bfab27a1 GC	274	MODULE_DESCRIPTION("STMMAC 10/100/1000 Ethernet PLATFORM driver");
	275	MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
	276	MODULE_LICENSE("GPL");