[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / phy / fixed.c

/*
 * Fixed MDIO bus (MDIO bus emulation with fixed PHYs)
 *
 * Author: Vitaly Bordug <vbordug@ru.mvista.com>
 *         Anton Vorontsov <avorontsov@ru.mvista.com>
 *
 * Copyright (c) 2006-2007 MontaVista Software, 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/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/list.h>
#include <linux/mii.h>
#include <linux/phy.h>
#include <linux/phy_fixed.h>
#include <linux/err.h>
#include <linux/slab.h>

#define MII_REGS_NUM 29

struct fixed_mdio_bus {
	int irqs[PHY_MAX_ADDR];
	struct mii_bus *mii_bus;
	struct list_head phys;
};

struct fixed_phy {
	int id;
	u16 regs[MII_REGS_NUM];
	struct phy_device *phydev;
	struct fixed_phy_status status;
	int (*link_update)(struct net_device *, struct fixed_phy_status *);
	struct list_head node;
};

static struct platform_device *pdev;
static struct fixed_mdio_bus platform_fmb = {
	.phys = LIST_HEAD_INIT(platform_fmb.phys),
};

static int fixed_phy_update_regs(struct fixed_phy *fp)
{
	u16 bmsr = BMSR_ANEGCAPABLE;
	u16 bmcr = 0;
	u16 lpagb = 0;
	u16 lpa = 0;

	if (fp->status.duplex) {
		bmcr |= BMCR_FULLDPLX;

		switch (fp->status.speed) {
		case 1000:
			bmsr |= BMSR_ESTATEN;
			bmcr |= BMCR_SPEED1000;
			lpagb |= LPA_1000FULL;
			break;
		case 100:
			bmsr |= BMSR_100FULL;
			bmcr |= BMCR_SPEED100;
			lpa |= LPA_100FULL;
			break;
		case 10:
			bmsr |= BMSR_10FULL;
			lpa |= LPA_10FULL;
			break;
		default:
			printk(KERN_WARNING "fixed phy: unknown speed\n");
			return -EINVAL;
		}
	} else {
		switch (fp->status.speed) {
		case 1000:
			bmsr |= BMSR_ESTATEN;
			bmcr |= BMCR_SPEED1000;
			lpagb |= LPA_1000HALF;
			break;
		case 100:
			bmsr |= BMSR_100HALF;
			bmcr |= BMCR_SPEED100;
			lpa |= LPA_100HALF;
			break;
		case 10:
			bmsr |= BMSR_10HALF;
			lpa |= LPA_10HALF;
			break;
		default:
			printk(KERN_WARNING "fixed phy: unknown speed\n");
			return -EINVAL;
		}
	}

	if (fp->status.link)
		bmsr |= BMSR_LSTATUS | BMSR_ANEGCOMPLETE;

	if (fp->status.pause)
		lpa |= LPA_PAUSE_CAP;

	if (fp->status.asym_pause)
		lpa |= LPA_PAUSE_ASYM;

	fp->regs[MII_PHYSID1] = fp->id >> 16;
	fp->regs[MII_PHYSID2] = fp->id;

	fp->regs[MII_BMSR] = bmsr;
	fp->regs[MII_BMCR] = bmcr;
	fp->regs[MII_LPA] = lpa;
	fp->regs[MII_STAT1000] = lpagb;

	return 0;
}

static int fixed_mdio_read(struct mii_bus *bus, int phy_id, int reg_num)
{
	struct fixed_mdio_bus *fmb = bus->priv;
	struct fixed_phy *fp;

	if (reg_num >= MII_REGS_NUM)
		return -1;

	list_for_each_entry(fp, &fmb->phys, node) {
		if (fp->id == phy_id) {
			/* Issue callback if user registered it. */
			if (fp->link_update) {
				fp->link_update(fp->phydev->attached_dev,
						&fp->status);
				fixed_phy_update_regs(fp);
			}
			return fp->regs[reg_num];
		}
	}

	return 0xFFFF;
}

static int fixed_mdio_write(struct mii_bus *bus, int phy_id, int reg_num,
			    u16 val)
{
	return 0;
}

/*
 * If something weird is required to be done with link/speed,
 * network driver is able to assign a function to implement this.
 * May be useful for PHY's that need to be software-driven.
 */
int fixed_phy_set_link_update(struct phy_device *phydev,
			      int (*link_update)(struct net_device *,
						 struct fixed_phy_status *))
{
	struct fixed_mdio_bus *fmb = &platform_fmb;
	struct fixed_phy *fp;

	if (!link_update || !phydev || !phydev->bus)
		return -EINVAL;

	list_for_each_entry(fp, &fmb->phys, node) {
		if (fp->id == phydev->phy_id) {
			fp->link_update = link_update;
			fp->phydev = phydev;
			return 0;
		}
	}

	return -ENOENT;
}
EXPORT_SYMBOL_GPL(fixed_phy_set_link_update);

int fixed_phy_add(unsigned int irq, int phy_id,
		  struct fixed_phy_status *status)
{
	int ret;
	struct fixed_mdio_bus *fmb = &platform_fmb;
	struct fixed_phy *fp;

	fp = kzalloc(sizeof(*fp), GFP_KERNEL);
	if (!fp)
		return -ENOMEM;

	memset(fp->regs, 0xFF,  sizeof(fp->regs[0]) * MII_REGS_NUM);

	fmb->irqs[phy_id] = irq;

	fp->id = phy_id;
	fp->status = *status;

	ret = fixed_phy_update_regs(fp);
	if (ret)
		goto err_regs;

	list_add_tail(&fp->node, &fmb->phys);

	return 0;

err_regs:
	kfree(fp);
	return ret;
}
EXPORT_SYMBOL_GPL(fixed_phy_add);

static int __init fixed_mdio_bus_init(void)
{
	struct fixed_mdio_bus *fmb = &platform_fmb;
	int ret;

	pdev = platform_device_register_simple("Fixed MDIO bus", 0, NULL, 0);
	if (IS_ERR(pdev)) {
		ret = PTR_ERR(pdev);
		goto err_pdev;
	}

	fmb->mii_bus = mdiobus_alloc();
	if (fmb->mii_bus == NULL) {
		ret = -ENOMEM;
		goto err_mdiobus_reg;
	}

	snprintf(fmb->mii_bus->id, MII_BUS_ID_SIZE, "0");
	fmb->mii_bus->name = "Fixed MDIO Bus";
	fmb->mii_bus->priv = fmb;
	fmb->mii_bus->parent = &pdev->dev;
	fmb->mii_bus->read = &fixed_mdio_read;
	fmb->mii_bus->write = &fixed_mdio_write;
	fmb->mii_bus->irq = fmb->irqs;

	ret = mdiobus_register(fmb->mii_bus);
	if (ret)
		goto err_mdiobus_alloc;

	return 0;

err_mdiobus_alloc:
	mdiobus_free(fmb->mii_bus);
err_mdiobus_reg:
	platform_device_unregister(pdev);
err_pdev:
	return ret;
}
module_init(fixed_mdio_bus_init);

static void __exit fixed_mdio_bus_exit(void)
{
	struct fixed_mdio_bus *fmb = &platform_fmb;
	struct fixed_phy *fp, *tmp;

	mdiobus_unregister(fmb->mii_bus);
	mdiobus_free(fmb->mii_bus);
	platform_device_unregister(pdev);

	list_for_each_entry_safe(fp, tmp, &fmb->phys, node) {
		list_del(&fp->node);
		kfree(fp);
	}
}
module_exit(fixed_mdio_bus_exit);

MODULE_DESCRIPTION("Fixed MDIO bus (MDIO bus emulation with fixed PHYs)");
MODULE_AUTHOR("Vitaly Bordug");
MODULE_LICENSE("GPL");
Commit	Line	Data
	1	/*
	2	* Fixed MDIO bus (MDIO bus emulation with fixed PHYs)
	3	*
	4	* Author: Vitaly Bordug <vbordug@ru.mvista.com>
	5	* Anton Vorontsov <avorontsov@ru.mvista.com>
	6	*
	7	* Copyright (c) 2006-2007 MontaVista Software, Inc.
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2 of the License, or (at your
	12	* option) any later version.
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/list.h>
	19	#include <linux/mii.h>
	20	#include <linux/phy.h>
	21	#include <linux/phy_fixed.h>
	22	#include <linux/err.h>
	23	#include <linux/slab.h>
	24
	25	#define MII_REGS_NUM 29
	26
	27	struct fixed_mdio_bus {
	28	int irqs[PHY_MAX_ADDR];
	29	struct mii_bus *mii_bus;
	30	struct list_head phys;
	31	};
	32
	33	struct fixed_phy {
	34	int id;
	35	u16 regs[MII_REGS_NUM];
	36	struct phy_device *phydev;
	37	struct fixed_phy_status status;
	38	int (link_update)(struct net_device , struct fixed_phy_status *);
	39	struct list_head node;
	40	};
	41
	42	static struct platform_device *pdev;
	43	static struct fixed_mdio_bus platform_fmb = {
	44	.phys = LIST_HEAD_INIT(platform_fmb.phys),
	45	};
	46
	47	static int fixed_phy_update_regs(struct fixed_phy *fp)
	48	{
	49	u16 bmsr = BMSR_ANEGCAPABLE;
	50	u16 bmcr = 0;
	51	u16 lpagb = 0;
	52	u16 lpa = 0;
	53
	54	if (fp->status.duplex) {
	55	bmcr \|= BMCR_FULLDPLX;
	56
	57	switch (fp->status.speed) {
	58	case 1000:
	59	bmsr \|= BMSR_ESTATEN;
	60	bmcr \|= BMCR_SPEED1000;
	61	lpagb \|= LPA_1000FULL;
	62	break;
	63	case 100:
	64	bmsr \|= BMSR_100FULL;
	65	bmcr \|= BMCR_SPEED100;
	66	lpa \|= LPA_100FULL;
	67	break;
	68	case 10:
	69	bmsr \|= BMSR_10FULL;
	70	lpa \|= LPA_10FULL;
	71	break;
	72	default:
	73	printk(KERN_WARNING "fixed phy: unknown speed\n");
	74	return -EINVAL;
	75	}
	76	} else {
	77	switch (fp->status.speed) {
	78	case 1000:
	79	bmsr \|= BMSR_ESTATEN;
	80	bmcr \|= BMCR_SPEED1000;
	81	lpagb \|= LPA_1000HALF;
	82	break;
	83	case 100:
	84	bmsr \|= BMSR_100HALF;
	85	bmcr \|= BMCR_SPEED100;
	86	lpa \|= LPA_100HALF;
	87	break;
	88	case 10:
	89	bmsr \|= BMSR_10HALF;
	90	lpa \|= LPA_10HALF;
	91	break;
	92	default:
	93	printk(KERN_WARNING "fixed phy: unknown speed\n");
	94	return -EINVAL;
	95	}
	96	}
	97
	98	if (fp->status.link)
	99	bmsr \|= BMSR_LSTATUS \| BMSR_ANEGCOMPLETE;
	100
	101	if (fp->status.pause)
	102	lpa \|= LPA_PAUSE_CAP;
	103
	104	if (fp->status.asym_pause)
	105	lpa \|= LPA_PAUSE_ASYM;
	106
	107	fp->regs[MII_PHYSID1] = fp->id >> 16;
	108	fp->regs[MII_PHYSID2] = fp->id;
	109
	110	fp->regs[MII_BMSR] = bmsr;
	111	fp->regs[MII_BMCR] = bmcr;
	112	fp->regs[MII_LPA] = lpa;
	113	fp->regs[MII_STAT1000] = lpagb;
	114
	115	return 0;
	116	}
	117
	118	static int fixed_mdio_read(struct mii_bus *bus, int phy_id, int reg_num)
	119	{
	120	struct fixed_mdio_bus *fmb = bus->priv;
	121	struct fixed_phy *fp;
	122
	123	if (reg_num >= MII_REGS_NUM)
	124	return -1;
	125
	126	list_for_each_entry(fp, &fmb->phys, node) {
	127	if (fp->id == phy_id) {
	128	/* Issue callback if user registered it. */
	129	if (fp->link_update) {
	130	fp->link_update(fp->phydev->attached_dev,
	131	&fp->status);
	132	fixed_phy_update_regs(fp);
	133	}
	134	return fp->regs[reg_num];
	135	}
	136	}
	137
	138	return 0xFFFF;
	139	}
	140
	141	static int fixed_mdio_write(struct mii_bus *bus, int phy_id, int reg_num,
	142	u16 val)
	143	{
	144	return 0;
	145	}
	146
	147	/*
	148	* If something weird is required to be done with link/speed,
	149	* network driver is able to assign a function to implement this.
	150	* May be useful for PHY's that need to be software-driven.
	151	*/
	152	int fixed_phy_set_link_update(struct phy_device *phydev,
	153	int (link_update)(struct net_device ,
	154	struct fixed_phy_status *))
	155	{
	156	struct fixed_mdio_bus *fmb = &platform_fmb;
	157	struct fixed_phy *fp;
	158
	159	if (!link_update \|\| !phydev \|\| !phydev->bus)
	160	return -EINVAL;
	161
	162	list_for_each_entry(fp, &fmb->phys, node) {
	163	if (fp->id == phydev->phy_id) {
	164	fp->link_update = link_update;
	165	fp->phydev = phydev;
	166	return 0;
	167	}
	168	}
	169
	170	return -ENOENT;
	171	}
	172	EXPORT_SYMBOL_GPL(fixed_phy_set_link_update);
	173
	174	int fixed_phy_add(unsigned int irq, int phy_id,
	175	struct fixed_phy_status *status)
	176	{
	177	int ret;
	178	struct fixed_mdio_bus *fmb = &platform_fmb;
	179	struct fixed_phy *fp;
	180
	181	fp = kzalloc(sizeof(*fp), GFP_KERNEL);
	182	if (!fp)
	183	return -ENOMEM;
	184
	185	memset(fp->regs, 0xFF, sizeof(fp->regs[0]) * MII_REGS_NUM);
	186
	187	fmb->irqs[phy_id] = irq;
	188
	189	fp->id = phy_id;
	190	fp->status = *status;
	191
	192	ret = fixed_phy_update_regs(fp);
	193	if (ret)
	194	goto err_regs;
	195
	196	list_add_tail(&fp->node, &fmb->phys);
	197
	198	return 0;
	199
	200	err_regs:
	201	kfree(fp);
	202	return ret;
	203	}
	204	EXPORT_SYMBOL_GPL(fixed_phy_add);
	205
	206	static int __init fixed_mdio_bus_init(void)
	207	{
	208	struct fixed_mdio_bus *fmb = &platform_fmb;
	209	int ret;
	210
	211	pdev = platform_device_register_simple("Fixed MDIO bus", 0, NULL, 0);
	212	if (IS_ERR(pdev)) {
	213	ret = PTR_ERR(pdev);
	214	goto err_pdev;
	215	}
	216
	217	fmb->mii_bus = mdiobus_alloc();
	218	if (fmb->mii_bus == NULL) {
	219	ret = -ENOMEM;
	220	goto err_mdiobus_reg;
	221	}
	222
	223	snprintf(fmb->mii_bus->id, MII_BUS_ID_SIZE, "0");
	224	fmb->mii_bus->name = "Fixed MDIO Bus";
	225	fmb->mii_bus->priv = fmb;
	226	fmb->mii_bus->parent = &pdev->dev;
	227	fmb->mii_bus->read = &fixed_mdio_read;
	228	fmb->mii_bus->write = &fixed_mdio_write;
	229	fmb->mii_bus->irq = fmb->irqs;
	230
	231	ret = mdiobus_register(fmb->mii_bus);
	232	if (ret)
	233	goto err_mdiobus_alloc;
	234
	235	return 0;
	236
	237	err_mdiobus_alloc:
	238	mdiobus_free(fmb->mii_bus);
	239	err_mdiobus_reg:
	240	platform_device_unregister(pdev);
	241	err_pdev:
	242	return ret;
	243	}
	244	module_init(fixed_mdio_bus_init);
	245
	246	static void __exit fixed_mdio_bus_exit(void)
	247	{
	248	struct fixed_mdio_bus *fmb = &platform_fmb;
	249	struct fixed_phy fp, tmp;
	250
	251	mdiobus_unregister(fmb->mii_bus);
	252	mdiobus_free(fmb->mii_bus);
	253	platform_device_unregister(pdev);
	254
	255	list_for_each_entry_safe(fp, tmp, &fmb->phys, node) {
	256	list_del(&fp->node);
	257	kfree(fp);
	258	}
	259	}
	260	module_exit(fixed_mdio_bus_exit);
	261
	262	MODULE_DESCRIPTION("Fixed MDIO bus (MDIO bus emulation with fixed PHYs)");
	263	MODULE_AUTHOR("Vitaly Bordug");
	264	MODULE_LICENSE("GPL");