[deliverable/linux.git] / drivers / net / phy / micrel.c

/*
 * drivers/net/phy/micrel.c
 *
 * Driver for Micrel PHYs
 *
 * Author: David J. Choi
 *
 * Copyright (c) 2010 Micrel, 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.
 *
 * Support : ksz9021 1000/100/10 phy from Micrel
 *		ks8001, ks8737, ks8721, ks8041, ks8051 100/10 phy
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/phy.h>

#define	PHY_ID_KSZ9021			0x00221611
#define	PHY_ID_KS8737			0x00221720
#define	PHY_ID_KS8041			0x00221510
#define	PHY_ID_KS8051			0x00221550
/* both for ks8001 Rev. A/B, and for ks8721 Rev 3. */
#define	PHY_ID_KS8001			0x0022161A

/* general Interrupt control/status reg in vendor specific block. */
#define MII_KSZPHY_INTCS			0x1B
#define	KSZPHY_INTCS_JABBER			(1 << 15)
#define	KSZPHY_INTCS_RECEIVE_ERR		(1 << 14)
#define	KSZPHY_INTCS_PAGE_RECEIVE		(1 << 13)
#define	KSZPHY_INTCS_PARELLEL			(1 << 12)
#define	KSZPHY_INTCS_LINK_PARTNER_ACK		(1 << 11)
#define	KSZPHY_INTCS_LINK_DOWN			(1 << 10)
#define	KSZPHY_INTCS_REMOTE_FAULT		(1 << 9)
#define	KSZPHY_INTCS_LINK_UP			(1 << 8)
#define	KSZPHY_INTCS_ALL			(KSZPHY_INTCS_LINK_UP |\
						KSZPHY_INTCS_LINK_DOWN)

/* general PHY control reg in vendor specific block. */
#define	MII_KSZPHY_CTRL			0x1F
/* bitmap of PHY register to set interrupt mode */
#define KSZPHY_CTRL_INT_ACTIVE_HIGH		(1 << 9)
#define KSZ9021_CTRL_INT_ACTIVE_HIGH		(1 << 14)
#define KS8737_CTRL_INT_ACTIVE_HIGH		(1 << 14)

static int kszphy_ack_interrupt(struct phy_device *phydev)
{
	/* bit[7..0] int status, which is a read and clear register. */
	int rc;

	rc = phy_read(phydev, MII_KSZPHY_INTCS);

	return (rc < 0) ? rc : 0;
}

static int kszphy_set_interrupt(struct phy_device *phydev)
{
	int temp;
	temp = (PHY_INTERRUPT_ENABLED == phydev->interrupts) ?
		KSZPHY_INTCS_ALL : 0;
	return phy_write(phydev, MII_KSZPHY_INTCS, temp);
}

static int kszphy_config_intr(struct phy_device *phydev)
{
	int temp, rc;

	/* set the interrupt pin active low */
	temp = phy_read(phydev, MII_KSZPHY_CTRL);
	temp &= ~KSZPHY_CTRL_INT_ACTIVE_HIGH;
	phy_write(phydev, MII_KSZPHY_CTRL, temp);
	rc = kszphy_set_interrupt(phydev);
	return rc < 0 ? rc : 0;
}

static int ksz9021_config_intr(struct phy_device *phydev)
{
	int temp, rc;

	/* set the interrupt pin active low */
	temp = phy_read(phydev, MII_KSZPHY_CTRL);
	temp &= ~KSZ9021_CTRL_INT_ACTIVE_HIGH;
	phy_write(phydev, MII_KSZPHY_CTRL, temp);
	rc = kszphy_set_interrupt(phydev);
	return rc < 0 ? rc : 0;
}

static int ks8737_config_intr(struct phy_device *phydev)
{
	int temp, rc;

	/* set the interrupt pin active low */
	temp = phy_read(phydev, MII_KSZPHY_CTRL);
	temp &= ~KS8737_CTRL_INT_ACTIVE_HIGH;
	phy_write(phydev, MII_KSZPHY_CTRL, temp);
	rc = kszphy_set_interrupt(phydev);
	return rc < 0 ? rc : 0;
}

static int kszphy_config_init(struct phy_device *phydev)
{
	return 0;
}

static struct phy_driver ks8737_driver = {
	.phy_id		= PHY_ID_KS8737,
	.phy_id_mask	= 0x00fffff0,
	.name		= "Micrel KS8737",
	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause),
	.flags		= PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
	.config_init	= kszphy_config_init,
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.ack_interrupt	= kszphy_ack_interrupt,
	.config_intr	= ks8737_config_intr,
	.driver		= { .owner = THIS_MODULE,},
};

static struct phy_driver ks8041_driver = {
	.phy_id		= PHY_ID_KS8041,
	.phy_id_mask	= 0x00fffff0,
	.name		= "Micrel KS8041",
	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
	.config_init	= kszphy_config_init,
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.ack_interrupt	= kszphy_ack_interrupt,
	.config_intr	= kszphy_config_intr,
	.driver		= { .owner = THIS_MODULE,},
};

static struct phy_driver ks8051_driver = {
	.phy_id		= PHY_ID_KS8051,
	.phy_id_mask	= 0x00fffff0,
	.name		= "Micrel KS8051",
	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
	.config_init	= kszphy_config_init,
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.ack_interrupt	= kszphy_ack_interrupt,
	.config_intr	= kszphy_config_intr,
	.driver		= { .owner = THIS_MODULE,},
};

static struct phy_driver ks8001_driver = {
	.phy_id		= PHY_ID_KS8001,
	.name		= "Micrel KS8001 or KS8721",
	.phy_id_mask	= 0x00fffff0,
	.features	= (PHY_BASIC_FEATURES | SUPPORTED_Pause),
	.flags		= PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
	.config_init	= kszphy_config_init,
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.ack_interrupt	= kszphy_ack_interrupt,
	.config_intr	= kszphy_config_intr,
	.driver		= { .owner = THIS_MODULE,},
};

static struct phy_driver ksz9021_driver = {
	.phy_id		= PHY_ID_KSZ9021,
	.phy_id_mask	= 0x000fff10,
	.name		= "Micrel KSZ9021 Gigabit PHY",
	.features	= (PHY_GBIT_FEATURES | SUPPORTED_Pause
				| SUPPORTED_Asym_Pause),
	.flags		= PHY_HAS_MAGICANEG | PHY_HAS_INTERRUPT,
	.config_init	= kszphy_config_init,
	.config_aneg	= genphy_config_aneg,
	.read_status	= genphy_read_status,
	.ack_interrupt	= kszphy_ack_interrupt,
	.config_intr	= ksz9021_config_intr,
	.driver		= { .owner = THIS_MODULE, },
};

static int __init ksphy_init(void)
{
	int ret;

	ret = phy_driver_register(&ks8001_driver);
	if (ret)
		goto err1;

	ret = phy_driver_register(&ksz9021_driver);
	if (ret)
		goto err2;

	ret = phy_driver_register(&ks8737_driver);
	if (ret)
		goto err3;
	ret = phy_driver_register(&ks8041_driver);
	if (ret)
		goto err4;
	ret = phy_driver_register(&ks8051_driver);
	if (ret)
		goto err5;

	return 0;

err5:
	phy_driver_unregister(&ks8041_driver);
err4:
	phy_driver_unregister(&ks8737_driver);
err3:
	phy_driver_unregister(&ksz9021_driver);
err2:
	phy_driver_unregister(&ks8001_driver);
err1:
	return ret;
}

static void __exit ksphy_exit(void)
{
	phy_driver_unregister(&ks8001_driver);
	phy_driver_unregister(&ks8737_driver);
	phy_driver_unregister(&ksz9021_driver);
	phy_driver_unregister(&ks8041_driver);
	phy_driver_unregister(&ks8051_driver);
}

module_init(ksphy_init);
module_exit(ksphy_exit);

MODULE_DESCRIPTION("Micrel PHY driver");
MODULE_AUTHOR("David J. Choi");
MODULE_LICENSE("GPL");

static struct mdio_device_id __maybe_unused micrel_tbl[] = {
	{ PHY_ID_KSZ9021, 0x000fff10 },
	{ PHY_ID_KS8001, 0x00fffff0 },
	{ PHY_ID_KS8737, 0x00fffff0 },
	{ PHY_ID_KS8041, 0x00fffff0 },
	{ PHY_ID_KS8051, 0x00fffff0 },
	{ }
};

MODULE_DEVICE_TABLE(mdio, micrel_tbl);
Commit	Line	Data
d0507009 DC	1	/*
	2	* drivers/net/phy/micrel.c
	3	*
	4	* Driver for Micrel PHYs
	5	*
	6	* Author: David J. Choi
	7	*
	8	* Copyright (c) 2010 Micrel, Inc.
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the
	12	* Free Software Foundation; either version 2 of the License, or (at your
	13	* option) any later version.
	14	*
51f932c4 CD	15	* Support : ksz9021 1000/100/10 phy from Micrel
51f932c4 CD	16	* ks8001, ks8737, ks8721, ks8041, ks8051 100/10 phy
d0507009 DC	17	*/
	18
	19	#include <linux/kernel.h>
	20	#include <linux/module.h>
	21	#include <linux/phy.h>
	22
	23	#define PHY_ID_KSZ9021 0x00221611
51f932c4 CD	24	#define PHY_ID_KS8737 0x00221720
	25	#define PHY_ID_KS8041 0x00221510
	26	#define PHY_ID_KS8051 0x00221550
	27	/* both for ks8001 Rev. A/B, and for ks8721 Rev 3. */
d0507009 DC	28	#define PHY_ID_KS8001 0x0022161A
d0507009 DC	29
51f932c4 CD	30	/* general Interrupt control/status reg in vendor specific block. */
	31	#define MII_KSZPHY_INTCS 0x1B
	32	#define KSZPHY_INTCS_JABBER (1 << 15)
	33	#define KSZPHY_INTCS_RECEIVE_ERR (1 << 14)
	34	#define KSZPHY_INTCS_PAGE_RECEIVE (1 << 13)
	35	#define KSZPHY_INTCS_PARELLEL (1 << 12)
	36	#define KSZPHY_INTCS_LINK_PARTNER_ACK (1 << 11)
	37	#define KSZPHY_INTCS_LINK_DOWN (1 << 10)
	38	#define KSZPHY_INTCS_REMOTE_FAULT (1 << 9)
	39	#define KSZPHY_INTCS_LINK_UP (1 << 8)
	40	#define KSZPHY_INTCS_ALL (KSZPHY_INTCS_LINK_UP \|\
	41	KSZPHY_INTCS_LINK_DOWN)
	42
	43	/* general PHY control reg in vendor specific block. */
	44	#define MII_KSZPHY_CTRL 0x1F
	45	/* bitmap of PHY register to set interrupt mode */
	46	#define KSZPHY_CTRL_INT_ACTIVE_HIGH (1 << 9)
	47	#define KSZ9021_CTRL_INT_ACTIVE_HIGH (1 << 14)
	48	#define KS8737_CTRL_INT_ACTIVE_HIGH (1 << 14)
	49
	50	static int kszphy_ack_interrupt(struct phy_device *phydev)
	51	{
	52	/* bit[7..0] int status, which is a read and clear register. */
	53	int rc;
	54
	55	rc = phy_read(phydev, MII_KSZPHY_INTCS);
	56
	57	return (rc < 0) ? rc : 0;
	58	}
	59
	60	static int kszphy_set_interrupt(struct phy_device *phydev)
	61	{
	62	int temp;
	63	temp = (PHY_INTERRUPT_ENABLED == phydev->interrupts) ?
	64	KSZPHY_INTCS_ALL : 0;
	65	return phy_write(phydev, MII_KSZPHY_INTCS, temp);
	66	}
	67
	68	static int kszphy_config_intr(struct phy_device *phydev)
	69	{
	70	int temp, rc;
	71
	72	/* set the interrupt pin active low */
	73	temp = phy_read(phydev, MII_KSZPHY_CTRL);
	74	temp &= ~KSZPHY_CTRL_INT_ACTIVE_HIGH;
	75	phy_write(phydev, MII_KSZPHY_CTRL, temp);
	76	rc = kszphy_set_interrupt(phydev);
	77	return rc < 0 ? rc : 0;
	78	}
	79
	80	static int ksz9021_config_intr(struct phy_device *phydev)
	81	{
	82	int temp, rc;
	83
	84	/* set the interrupt pin active low */
	85	temp = phy_read(phydev, MII_KSZPHY_CTRL);
	86	temp &= ~KSZ9021_CTRL_INT_ACTIVE_HIGH;
	87	phy_write(phydev, MII_KSZPHY_CTRL, temp);
	88	rc = kszphy_set_interrupt(phydev);
	89	return rc < 0 ? rc : 0;
	90	}
	91
	92	static int ks8737_config_intr(struct phy_device *phydev)
	93	{
94	int temp, rc;
95
96	/* set the interrupt pin active low */
97	temp = phy_read(phydev, MII_KSZPHY_CTRL);
98	temp &= ~KS8737_CTRL_INT_ACTIVE_HIGH;
99	phy_write(phydev, MII_KSZPHY_CTRL, temp);
100	rc = kszphy_set_interrupt(phydev);
101	return rc < 0 ? rc : 0;
102	}
d0507009 DC	103
	104	static int kszphy_config_init(struct phy_device *phydev)
	105	{
	106	return 0;
	107	}
	108
51f932c4 CD	109	static struct phy_driver ks8737_driver = {
	110	.phy_id = PHY_ID_KS8737,
	111	.phy_id_mask = 0x00fffff0,
	112	.name = "Micrel KS8737",
	113	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause),
	114	.flags = PHY_HAS_MAGICANEG \| PHY_HAS_INTERRUPT,
	115	.config_init = kszphy_config_init,
	116	.config_aneg = genphy_config_aneg,
	117	.read_status = genphy_read_status,
	118	.ack_interrupt = kszphy_ack_interrupt,
	119	.config_intr = ks8737_config_intr,
	120	.driver = { .owner = THIS_MODULE,},
	121	};
	122
	123	static struct phy_driver ks8041_driver = {
	124	.phy_id = PHY_ID_KS8041,
	125	.phy_id_mask = 0x00fffff0,
	126	.name = "Micrel KS8041",
	127	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	128	\| SUPPORTED_Asym_Pause),
	129	.flags = PHY_HAS_MAGICANEG \| PHY_HAS_INTERRUPT,
	130	.config_init = kszphy_config_init,
	131	.config_aneg = genphy_config_aneg,
	132	.read_status = genphy_read_status,
	133	.ack_interrupt = kszphy_ack_interrupt,
	134	.config_intr = kszphy_config_intr,
	135	.driver = { .owner = THIS_MODULE,},
	136	};
d0507009	137
51f932c4 CD	138	static struct phy_driver ks8051_driver = {
51f932c4 CD	139	.phy_id = PHY_ID_KS8051,
d0507009	140	.phy_id_mask = 0x00fffff0,
51f932c4 CD	141	.name = "Micrel KS8051",
	142	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause
	143	\| SUPPORTED_Asym_Pause),
	144	.flags = PHY_HAS_MAGICANEG \| PHY_HAS_INTERRUPT,
d0507009 DC	145	.config_init = kszphy_config_init,
	146	.config_aneg = genphy_config_aneg,
	147	.read_status = genphy_read_status,
51f932c4 CD	148	.ack_interrupt = kszphy_ack_interrupt,
51f932c4 CD	149	.config_intr = kszphy_config_intr,
d0507009 DC	150	.driver = { .owner = THIS_MODULE,},
	151	};
	152
51f932c4 CD	153	static struct phy_driver ks8001_driver = {
	154	.phy_id = PHY_ID_KS8001,
	155	.name = "Micrel KS8001 or KS8721",
d0507009	156	.phy_id_mask = 0x00fffff0,
51f932c4 CD	157	.features = (PHY_BASIC_FEATURES \| SUPPORTED_Pause),
51f932c4 CD	158	.flags = PHY_HAS_MAGICANEG \| PHY_HAS_INTERRUPT,
d0507009 DC	159	.config_init = kszphy_config_init,
	160	.config_aneg = genphy_config_aneg,
	161	.read_status = genphy_read_status,
51f932c4 CD	162	.ack_interrupt = kszphy_ack_interrupt,
51f932c4 CD	163	.config_intr = kszphy_config_intr,
d0507009 DC	164	.driver = { .owner = THIS_MODULE,},
	165	};
	166
	167	static struct phy_driver ksz9021_driver = {
	168	.phy_id = PHY_ID_KSZ9021,
	169	.phy_id_mask = 0x000fff10,
	170	.name = "Micrel KSZ9021 Gigabit PHY",
51f932c4 CD	171	.features = (PHY_GBIT_FEATURES \| SUPPORTED_Pause
	172	\| SUPPORTED_Asym_Pause),
	173	.flags = PHY_HAS_MAGICANEG \| PHY_HAS_INTERRUPT,
d0507009 DC	174	.config_init = kszphy_config_init,
	175	.config_aneg = genphy_config_aneg,
	176	.read_status = genphy_read_status,
51f932c4 CD	177	.ack_interrupt = kszphy_ack_interrupt,
51f932c4 CD	178	.config_intr = ksz9021_config_intr,
d0507009 DC	179	.driver = { .owner = THIS_MODULE, },
	180	};
	181
	182	static int __init ksphy_init(void)
	183	{
	184	int ret;
	185
	186	ret = phy_driver_register(&ks8001_driver);
	187	if (ret)
	188	goto err1;
51f932c4 CD	189
51f932c4 CD	190	ret = phy_driver_register(&ksz9021_driver);
d0507009 DC	191	if (ret)
	192	goto err2;
	193
51f932c4	194	ret = phy_driver_register(&ks8737_driver);
d0507009 DC	195	if (ret)
d0507009 DC	196	goto err3;
51f932c4 CD	197	ret = phy_driver_register(&ks8041_driver);
	198	if (ret)
	199	goto err4;
	200	ret = phy_driver_register(&ks8051_driver);
	201	if (ret)
	202	goto err5;
	203
d0507009 DC	204	return 0;
d0507009 DC	205
51f932c4 CD	206	err5:
	207	phy_driver_unregister(&ks8041_driver);
	208	err4:
	209	phy_driver_unregister(&ks8737_driver);
d0507009	210	err3:
51f932c4	211	phy_driver_unregister(&ksz9021_driver);
d0507009 DC	212	err2:
	213	phy_driver_unregister(&ks8001_driver);
	214	err1:
	215	return ret;
	216	}
	217
	218	static void __exit ksphy_exit(void)
	219	{
	220	phy_driver_unregister(&ks8001_driver);
51f932c4	221	phy_driver_unregister(&ks8737_driver);
d0507009	222	phy_driver_unregister(&ksz9021_driver);
51f932c4 CD	223	phy_driver_unregister(&ks8041_driver);
51f932c4 CD	224	phy_driver_unregister(&ks8051_driver);
d0507009 DC	225	}
	226
	227	module_init(ksphy_init);
	228	module_exit(ksphy_exit);
	229
	230	MODULE_DESCRIPTION("Micrel PHY driver");
	231	MODULE_AUTHOR("David J. Choi");
	232	MODULE_LICENSE("GPL");
52a60ed2	233
cf93c945	234	static struct mdio_device_id __maybe_unused micrel_tbl[] = {
52a60ed2	235	{ PHY_ID_KSZ9021, 0x000fff10 },
52a60ed2	236	{ PHY_ID_KS8001, 0x00fffff0 },
51f932c4 CD	237	{ PHY_ID_KS8737, 0x00fffff0 },
	238	{ PHY_ID_KS8041, 0x00fffff0 },
	239	{ PHY_ID_KS8051, 0x00fffff0 },
52a60ed2 DM	240	{ }
	241	};
	242
	243	MODULE_DEVICE_TABLE(mdio, micrel_tbl);