[deliverable/linux.git] / drivers / net / ethernet / ibm / emac / zmii.c

/*
 * drivers/net/ethernet/ibm/emac/zmii.c
 *
 * Driver for PowerPC 4xx on-chip ethernet controller, ZMII bridge support.
 *
 * Copyright 2007 Benjamin Herrenschmidt, IBM Corp.
 *                <benh@kernel.crashing.org>
 *
 * Based on the arch/ppc version of the driver:
 *
 * Copyright (c) 2004, 2005 Zultys Technologies.
 * Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
 *
 * Based on original work by
 *      Armin Kuster <akuster@mvista.com>
 * 	Copyright 2001 MontaVista Softare Inc.
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 *
 */
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/ethtool.h>
#include <linux/of_address.h>
#include <asm/io.h>

#include "emac.h"
#include "core.h"

/* ZMIIx_FER */
#define ZMII_FER_MDI(idx)	(0x80000000 >> ((idx) * 4))
#define ZMII_FER_MDI_ALL	(ZMII_FER_MDI(0) | ZMII_FER_MDI(1) | \
				 ZMII_FER_MDI(2) | ZMII_FER_MDI(3))

#define ZMII_FER_SMII(idx)	(0x40000000 >> ((idx) * 4))
#define ZMII_FER_RMII(idx)	(0x20000000 >> ((idx) * 4))
#define ZMII_FER_MII(idx)	(0x10000000 >> ((idx) * 4))

/* ZMIIx_SSR */
#define ZMII_SSR_SCI(idx)	(0x40000000 >> ((idx) * 4))
#define ZMII_SSR_FSS(idx)	(0x20000000 >> ((idx) * 4))
#define ZMII_SSR_SP(idx)	(0x10000000 >> ((idx) * 4))

/* ZMII only supports MII, RMII and SMII
 * we also support autodetection for backward compatibility
 */
static inline int zmii_valid_mode(int mode)
{
	return  mode == PHY_MODE_MII ||
		mode == PHY_MODE_RMII ||
		mode == PHY_MODE_SMII ||
		mode == PHY_MODE_NA;
}

static inline const char *zmii_mode_name(int mode)
{
	switch (mode) {
	case PHY_MODE_MII:
		return "MII";
	case PHY_MODE_RMII:
		return "RMII";
	case PHY_MODE_SMII:
		return "SMII";
	default:
		BUG();
	}
}

static inline u32 zmii_mode_mask(int mode, int input)
{
	switch (mode) {
	case PHY_MODE_MII:
		return ZMII_FER_MII(input);
	case PHY_MODE_RMII:
		return ZMII_FER_RMII(input);
	case PHY_MODE_SMII:
		return ZMII_FER_SMII(input);
	default:
		return 0;
	}
}

int zmii_attach(struct platform_device *ofdev, int input, int *mode)
{
	struct zmii_instance *dev = platform_get_drvdata(ofdev);
	struct zmii_regs __iomem *p = dev->base;

	ZMII_DBG(dev, "init(%d, %d)" NL, input, *mode);

	if (!zmii_valid_mode(*mode)) {
		/* Probably an EMAC connected to RGMII,
		 * but it still may need ZMII for MDIO so
		 * we don't fail here.
		 */
		dev->users++;
		return 0;
	}

	mutex_lock(&dev->lock);

	/* Autodetect ZMII mode if not specified.
	 * This is only for backward compatibility with the old driver.
	 * Please, always specify PHY mode in your board port to avoid
	 * any surprises.
	 */
	if (dev->mode == PHY_MODE_NA) {
		if (*mode == PHY_MODE_NA) {
			u32 r = dev->fer_save;

			ZMII_DBG(dev, "autodetecting mode, FER = 0x%08x" NL, r);

			if (r & (ZMII_FER_MII(0) | ZMII_FER_MII(1)))
				dev->mode = PHY_MODE_MII;
			else if (r & (ZMII_FER_RMII(0) | ZMII_FER_RMII(1)))
				dev->mode = PHY_MODE_RMII;
			else
				dev->mode = PHY_MODE_SMII;
		} else
			dev->mode = *mode;

		printk(KERN_NOTICE "%s: bridge in %s mode\n",
		       ofdev->dev.of_node->full_name,
		       zmii_mode_name(dev->mode));
	} else {
		/* All inputs must use the same mode */
		if (*mode != PHY_MODE_NA && *mode != dev->mode) {
			printk(KERN_ERR
			       "%s: invalid mode %d specified for input %d\n",
			       ofdev->dev.of_node->full_name, *mode, input);
			mutex_unlock(&dev->lock);
			return -EINVAL;
		}
	}

	/* Report back correct PHY mode,
	 * it may be used during PHY initialization.
	 */
	*mode = dev->mode;

	/* Enable this input */
	out_be32(&p->fer, in_be32(&p->fer) | zmii_mode_mask(dev->mode, input));
	++dev->users;

	mutex_unlock(&dev->lock);

	return 0;
}

void zmii_get_mdio(struct platform_device *ofdev, int input)
{
	struct zmii_instance *dev = platform_get_drvdata(ofdev);
	u32 fer;

	ZMII_DBG2(dev, "get_mdio(%d)" NL, input);

	mutex_lock(&dev->lock);

	fer = in_be32(&dev->base->fer) & ~ZMII_FER_MDI_ALL;
	out_be32(&dev->base->fer, fer | ZMII_FER_MDI(input));
}

void zmii_put_mdio(struct platform_device *ofdev, int input)
{
	struct zmii_instance *dev = platform_get_drvdata(ofdev);

	ZMII_DBG2(dev, "put_mdio(%d)" NL, input);
	mutex_unlock(&dev->lock);
}


void zmii_set_speed(struct platform_device *ofdev, int input, int speed)
{
	struct zmii_instance *dev = platform_get_drvdata(ofdev);
	u32 ssr;

	mutex_lock(&dev->lock);

	ssr = in_be32(&dev->base->ssr);

	ZMII_DBG(dev, "speed(%d, %d)" NL, input, speed);

	if (speed == SPEED_100)
		ssr |= ZMII_SSR_SP(input);
	else
		ssr &= ~ZMII_SSR_SP(input);

	out_be32(&dev->base->ssr, ssr);

	mutex_unlock(&dev->lock);
}

void zmii_detach(struct platform_device *ofdev, int input)
{
	struct zmii_instance *dev = platform_get_drvdata(ofdev);

	BUG_ON(!dev || dev->users == 0);

	mutex_lock(&dev->lock);

	ZMII_DBG(dev, "detach(%d)" NL, input);

	/* Disable this input */
	out_be32(&dev->base->fer,
		 in_be32(&dev->base->fer) & ~zmii_mode_mask(dev->mode, input));

	--dev->users;

	mutex_unlock(&dev->lock);
}

int zmii_get_regs_len(struct platform_device *ofdev)
{
	return sizeof(struct emac_ethtool_regs_subhdr) +
		sizeof(struct zmii_regs);
}

void *zmii_dump_regs(struct platform_device *ofdev, void *buf)
{
	struct zmii_instance *dev = platform_get_drvdata(ofdev);
	struct emac_ethtool_regs_subhdr *hdr = buf;
	struct zmii_regs *regs = (struct zmii_regs *)(hdr + 1);

	hdr->version = 0;
	hdr->index = 0; /* for now, are there chips with more than one
			 * zmii ? if yes, then we'll add a cell_index
			 * like we do for emac
			 */
	memcpy_fromio(regs, dev->base, sizeof(struct zmii_regs));
	return regs + 1;
}

static int zmii_probe(struct platform_device *ofdev)
{
	struct device_node *np = ofdev->dev.of_node;
	struct zmii_instance *dev;
	struct resource regs;
	int rc;

	rc = -ENOMEM;
	dev = kzalloc(sizeof(struct zmii_instance), GFP_KERNEL);
	if (dev == NULL)
		goto err_gone;

	mutex_init(&dev->lock);
	dev->ofdev = ofdev;
	dev->mode = PHY_MODE_NA;

	rc = -ENXIO;
	if (of_address_to_resource(np, 0, &regs)) {
		printk(KERN_ERR "%s: Can't get registers address\n",
		       np->full_name);
		goto err_free;
	}

	rc = -ENOMEM;
	dev->base = (struct zmii_regs __iomem *)ioremap(regs.start,
						sizeof(struct zmii_regs));
	if (dev->base == NULL) {
		printk(KERN_ERR "%s: Can't map device registers!\n",
		       np->full_name);
		goto err_free;
	}

	/* We may need FER value for autodetection later */
	dev->fer_save = in_be32(&dev->base->fer);

	/* Disable all inputs by default */
	out_be32(&dev->base->fer, 0);

	printk(KERN_INFO
	       "ZMII %s initialized\n", ofdev->dev.of_node->full_name);
	wmb();
	platform_set_drvdata(ofdev, dev);

	return 0;

 err_free:
	kfree(dev);
 err_gone:
	return rc;
}

static int zmii_remove(struct platform_device *ofdev)
{
	struct zmii_instance *dev = platform_get_drvdata(ofdev);

	WARN_ON(dev->users != 0);

	iounmap(dev->base);
	kfree(dev);

	return 0;
}

static struct of_device_id zmii_match[] =
{
	{
		.compatible	= "ibm,zmii",
	},
	/* For backward compat with old DT */
	{
		.type		= "emac-zmii",
	},
	{},
};

static struct platform_driver zmii_driver = {
	.driver = {
		.name = "emac-zmii",
		.owner = THIS_MODULE,
		.of_match_table = zmii_match,
	},
	.probe = zmii_probe,
	.remove = zmii_remove,
};

int __init zmii_init(void)
{
	return platform_driver_register(&zmii_driver);
}

void zmii_exit(void)
{
	platform_driver_unregister(&zmii_driver);
}
Commit	Line	Data
1d3bb996	1	/*
3396c782	2	* drivers/net/ethernet/ibm/emac/zmii.c
1d3bb996 DG	3	*
	4	* Driver for PowerPC 4xx on-chip ethernet controller, ZMII bridge support.
	5	*
17cf803a BH	6	* Copyright 2007 Benjamin Herrenschmidt, IBM Corp.
	7	* <benh@kernel.crashing.org>
	8	*
	9	* Based on the arch/ppc version of the driver:
	10	*
1d3bb996 DG	11	* Copyright (c) 2004, 2005 Zultys Technologies.
	12	* Eugene Surovegin <eugene.surovegin@zultys.com> or <ebs@ebshome.net>
	13	*
	14	* Based on original work by
	15	* Armin Kuster <akuster@mvista.com>
	16	* Copyright 2001 MontaVista Softare Inc.
	17	*
	18	* This program is free software; you can redistribute it and/or modify it
	19	* under the terms of the GNU General Public License as published by the
	20	* Free Software Foundation; either version 2 of the License, or (at your
	21	* option) any later version.
	22	*
	23	*/
5a0e3ad6	24	#include <linux/slab.h>
1d3bb996 DG	25	#include <linux/kernel.h>
1d3bb996 DG	26	#include <linux/ethtool.h>
5af50730	27	#include <linux/of_address.h>
1d3bb996 DG	28	#include <asm/io.h>
	29
	30	#include "emac.h"
	31	#include "core.h"
	32
	33	/* ZMIIx_FER */
	34	#define ZMII_FER_MDI(idx) (0x80000000 >> ((idx) * 4))
	35	#define ZMII_FER_MDI_ALL (ZMII_FER_MDI(0) \| ZMII_FER_MDI(1) \| \
	36	ZMII_FER_MDI(2) \| ZMII_FER_MDI(3))
	37
	38	#define ZMII_FER_SMII(idx) (0x40000000 >> ((idx) * 4))
	39	#define ZMII_FER_RMII(idx) (0x20000000 >> ((idx) * 4))
	40	#define ZMII_FER_MII(idx) (0x10000000 >> ((idx) * 4))
	41
	42	/* ZMIIx_SSR */
	43	#define ZMII_SSR_SCI(idx) (0x40000000 >> ((idx) * 4))
	44	#define ZMII_SSR_FSS(idx) (0x20000000 >> ((idx) * 4))
	45	#define ZMII_SSR_SP(idx) (0x10000000 >> ((idx) * 4))
	46
	47	/* ZMII only supports MII, RMII and SMII
	48	* we also support autodetection for backward compatibility
	49	*/
	50	static inline int zmii_valid_mode(int mode)
	51	{
	52	return mode == PHY_MODE_MII \|\|
	53	mode == PHY_MODE_RMII \|\|
	54	mode == PHY_MODE_SMII \|\|
	55	mode == PHY_MODE_NA;
	56	}
	57
	58	static inline const char *zmii_mode_name(int mode)
	59	{
	60	switch (mode) {
	61	case PHY_MODE_MII:
	62	return "MII";
	63	case PHY_MODE_RMII:
	64	return "RMII";
	65	case PHY_MODE_SMII:
	66	return "SMII";
	67	default:
	68	BUG();
	69	}
	70	}
	71
	72	static inline u32 zmii_mode_mask(int mode, int input)
	73	{
	74	switch (mode) {
	75	case PHY_MODE_MII:
	76	return ZMII_FER_MII(input);
	77	case PHY_MODE_RMII:
	78	return ZMII_FER_RMII(input);
	79	case PHY_MODE_SMII:
	80	return ZMII_FER_SMII(input);
	81	default:
	82	return 0;
	83	}
	84	}
	85
fe17dc1e	86	int zmii_attach(struct platform_device ofdev, int input, int mode)
1d3bb996	87	{
8513fbd8	88	struct zmii_instance *dev = platform_get_drvdata(ofdev);
eb4d84f1	89	struct zmii_regs __iomem *p = dev->base;
1d3bb996 DG	90
	91	ZMII_DBG(dev, "init(%d, %d)" NL, input, *mode);
	92
96853064	93	if (!zmii_valid_mode(*mode)) {
1d3bb996 DG	94	/* Probably an EMAC connected to RGMII,
	95	* but it still may need ZMII for MDIO so
	96	* we don't fail here.
	97	*/
96853064	98	dev->users++;
1d3bb996	99	return 0;
96853064	100	}
1d3bb996 DG	101
	102	mutex_lock(&dev->lock);
	103
	104	/* Autodetect ZMII mode if not specified.
	105	* This is only for backward compatibility with the old driver.
	106	* Please, always specify PHY mode in your board port to avoid
	107	* any surprises.
	108	*/
	109	if (dev->mode == PHY_MODE_NA) {
	110	if (*mode == PHY_MODE_NA) {
	111	u32 r = dev->fer_save;
	112
	113	ZMII_DBG(dev, "autodetecting mode, FER = 0x%08x" NL, r);
	114
	115	if (r & (ZMII_FER_MII(0) \| ZMII_FER_MII(1)))
	116	dev->mode = PHY_MODE_MII;
	117	else if (r & (ZMII_FER_RMII(0) \| ZMII_FER_RMII(1)))
	118	dev->mode = PHY_MODE_RMII;
	119	else
	120	dev->mode = PHY_MODE_SMII;
	121	} else
	122	dev->mode = *mode;
	123
	124	printk(KERN_NOTICE "%s: bridge in %s mode\n",
61c7a080 GL	125	ofdev->dev.of_node->full_name,
61c7a080 GL	126	zmii_mode_name(dev->mode));
1d3bb996 DG	127	} else {
	128	/* All inputs must use the same mode */
	129	if (mode != PHY_MODE_NA && mode != dev->mode) {
	130	printk(KERN_ERR
	131	"%s: invalid mode %d specified for input %d\n",
61c7a080	132	ofdev->dev.of_node->full_name, *mode, input);
1d3bb996 DG	133	mutex_unlock(&dev->lock);
	134	return -EINVAL;
	135	}
	136	}
	137
	138	/* Report back correct PHY mode,
	139	* it may be used during PHY initialization.
	140	*/
	141	*mode = dev->mode;
	142
	143	/* Enable this input */
	144	out_be32(&p->fer, in_be32(&p->fer) \| zmii_mode_mask(dev->mode, input));
	145	++dev->users;
	146
	147	mutex_unlock(&dev->lock);
	148
	149	return 0;
	150	}
	151
2dc11581	152	void zmii_get_mdio(struct platform_device *ofdev, int input)
1d3bb996	153	{
8513fbd8	154	struct zmii_instance *dev = platform_get_drvdata(ofdev);
1d3bb996 DG	155	u32 fer;
	156
	157	ZMII_DBG2(dev, "get_mdio(%d)" NL, input);
	158
	159	mutex_lock(&dev->lock);
	160
	161	fer = in_be32(&dev->base->fer) & ~ZMII_FER_MDI_ALL;
	162	out_be32(&dev->base->fer, fer \| ZMII_FER_MDI(input));
	163	}
	164
2dc11581	165	void zmii_put_mdio(struct platform_device *ofdev, int input)
1d3bb996	166	{
8513fbd8	167	struct zmii_instance *dev = platform_get_drvdata(ofdev);
1d3bb996 DG	168
	169	ZMII_DBG2(dev, "put_mdio(%d)" NL, input);
	170	mutex_unlock(&dev->lock);
	171	}
	172
	173
2dc11581	174	void zmii_set_speed(struct platform_device *ofdev, int input, int speed)
1d3bb996	175	{
8513fbd8	176	struct zmii_instance *dev = platform_get_drvdata(ofdev);
1d3bb996 DG	177	u32 ssr;
	178
	179	mutex_lock(&dev->lock);
	180
	181	ssr = in_be32(&dev->base->ssr);
	182
	183	ZMII_DBG(dev, "speed(%d, %d)" NL, input, speed);
	184
	185	if (speed == SPEED_100)
	186	ssr \|= ZMII_SSR_SP(input);
	187	else
	188	ssr &= ~ZMII_SSR_SP(input);
	189
	190	out_be32(&dev->base->ssr, ssr);
	191
	192	mutex_unlock(&dev->lock);
	193	}
	194
2dc11581	195	void zmii_detach(struct platform_device *ofdev, int input)
1d3bb996	196	{
8513fbd8	197	struct zmii_instance *dev = platform_get_drvdata(ofdev);
1d3bb996 DG	198
	199	BUG_ON(!dev \|\| dev->users == 0);
	200
	201	mutex_lock(&dev->lock);
	202
	203	ZMII_DBG(dev, "detach(%d)" NL, input);
	204
	205	/* Disable this input */
	206	out_be32(&dev->base->fer,
	207	in_be32(&dev->base->fer) & ~zmii_mode_mask(dev->mode, input));
	208
	209	--dev->users;
	210
	211	mutex_unlock(&dev->lock);
	212	}
	213
2dc11581	214	int zmii_get_regs_len(struct platform_device *ofdev)
1d3bb996 DG	215	{
	216	return sizeof(struct emac_ethtool_regs_subhdr) +
	217	sizeof(struct zmii_regs);
	218	}
	219
2dc11581	220	void zmii_dump_regs(struct platform_device ofdev, void *buf)
1d3bb996	221	{
8513fbd8	222	struct zmii_instance *dev = platform_get_drvdata(ofdev);
1d3bb996 DG	223	struct emac_ethtool_regs_subhdr *hdr = buf;
	224	struct zmii_regs regs = (struct zmii_regs )(hdr + 1);
	225
	226	hdr->version = 0;
	227	hdr->index = 0; /* for now, are there chips with more than one
	228	* zmii ? if yes, then we'll add a cell_index
	229	* like we do for emac
	230	*/
	231	memcpy_fromio(regs, dev->base, sizeof(struct zmii_regs));
	232	return regs + 1;
	233	}
	234
fe17dc1e	235	static int zmii_probe(struct platform_device *ofdev)
1d3bb996	236	{
61c7a080	237	struct device_node *np = ofdev->dev.of_node;
1d3bb996 DG	238	struct zmii_instance *dev;
	239	struct resource regs;
	240	int rc;
	241
	242	rc = -ENOMEM;
	243	dev = kzalloc(sizeof(struct zmii_instance), GFP_KERNEL);
e404decb	244	if (dev == NULL)
1d3bb996	245	goto err_gone;
1d3bb996 DG	246
	247	mutex_init(&dev->lock);
	248	dev->ofdev = ofdev;
	249	dev->mode = PHY_MODE_NA;
	250
	251	rc = -ENXIO;
	252	if (of_address_to_resource(np, 0, &regs)) {
	253	printk(KERN_ERR "%s: Can't get registers address\n",
	254	np->full_name);
	255	goto err_free;
	256	}
	257
	258	rc = -ENOMEM;
eb4d84f1	259	dev->base = (struct zmii_regs __iomem *)ioremap(regs.start,
1d3bb996 DG	260	sizeof(struct zmii_regs));
	261	if (dev->base == NULL) {
	262	printk(KERN_ERR "%s: Can't map device registers!\n",
	263	np->full_name);
	264	goto err_free;
	265	}
	266
	267	/* We may need FER value for autodetection later */
	268	dev->fer_save = in_be32(&dev->base->fer);
	269
	270	/* Disable all inputs by default */
	271	out_be32(&dev->base->fer, 0);
	272
	273	printk(KERN_INFO
61c7a080	274	"ZMII %s initialized\n", ofdev->dev.of_node->full_name);
1d3bb996	275	wmb();
8513fbd8	276	platform_set_drvdata(ofdev, dev);
1d3bb996 DG	277
	278	return 0;
	279
	280	err_free:
	281	kfree(dev);
	282	err_gone:
	283	return rc;
	284	}
	285
fe17dc1e	286	static int zmii_remove(struct platform_device *ofdev)
1d3bb996	287	{
8513fbd8	288	struct zmii_instance *dev = platform_get_drvdata(ofdev);
1d3bb996 DG	289
	290	WARN_ON(dev->users != 0);
	291
	292	iounmap(dev->base);
	293	kfree(dev);
	294
	295	return 0;
	296	}
	297
	298	static struct of_device_id zmii_match[] =
	299	{
	300	{
	301	.compatible = "ibm,zmii",
	302	},
	303	/* For backward compat with old DT */
	304	{
	305	.type = "emac-zmii",
	306	},
	307	{},
	308	};
	309
74888760	310	static struct platform_driver zmii_driver = {
4018294b GL	311	.driver = {
	312	.name = "emac-zmii",
	313	.owner = THIS_MODULE,
	314	.of_match_table = zmii_match,
	315	},
1d3bb996 DG	316	.probe = zmii_probe,
	317	.remove = zmii_remove,
	318	};
	319
	320	int __init zmii_init(void)
	321	{
74888760	322	return platform_driver_register(&zmii_driver);
1d3bb996 DG	323	}
	324
	325	void zmii_exit(void)
	326	{
74888760	327	platform_driver_unregister(&zmii_driver);
1d3bb996	328	}