Esempio n. 1
0
static int __init smsc_init(void)
{
	int ret;

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

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

	ret = phy_driver_register (&lan8700_driver);
	if (ret)
		goto err3;

	ret = phy_driver_register (&lan911x_int_driver);
	if (ret)
		goto err4;

	return 0;

err4:
	phy_driver_unregister (&lan8700_driver);
err3:
	phy_driver_unregister (&lan8187_driver);
err2:
	phy_driver_unregister (&lan83c185_driver);
err1:
	return ret;
}
Esempio n. 2
0
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;
}
Esempio n. 3
0
static int __init broadcom_init(void)
{
    int ret;

    ret = phy_driver_register(&bcm5411_driver);
    if (ret)
        goto out_5411;
    ret = phy_driver_register(&bcm5421_driver);
    if (ret)
        goto out_5421;
    ret = phy_driver_register(&bcm5461_driver);
    if (ret)
        goto out_5461;
    ret = phy_driver_register(&bcm5481_driver);
    if (ret)
        goto out_5481;
    return ret;

out_5481:
    phy_driver_unregister(&bcm5461_driver);
out_5461:
    phy_driver_unregister(&bcm5421_driver);
out_5421:
    phy_driver_unregister(&bcm5411_driver);
out_5411:
    return ret;
}
Esempio n. 4
0
static int __init broadcom_init(void)
{
	int ret;

	ret = phy_driver_register(&bcm5411_driver);
	if (ret)
		goto out_5411;
	ret = phy_driver_register(&bcm5421_driver);
	if (ret)
		goto out_5421;
	ret = phy_driver_register(&bcm5461_driver);
	if (ret)
		goto out_5461;
	ret = phy_driver_register(&bcm5464_driver);
	if (ret)
		goto out_5464;
	ret = phy_driver_register(&bcm5481_driver);
	if (ret)
		goto out_5481;
	ret = phy_driver_register(&bcm5482_driver);
	if (ret)
		goto out_5482;
	ret = phy_driver_register(&bcm50610_driver);
	if (ret)
		goto out_50610;
	ret = phy_driver_register(&bcm50610m_driver);
	if (ret)
		goto out_50610m;
	ret = phy_driver_register(&bcm57780_driver);
	if (ret)
		goto out_57780;
	ret = phy_driver_register(&bcmac131_driver);
	if (ret)
		goto out_ac131;
	return ret;

out_ac131:
	phy_driver_unregister(&bcm57780_driver);
out_57780:
	phy_driver_unregister(&bcm50610m_driver);
out_50610m:
	phy_driver_unregister(&bcm50610_driver);
out_50610:
	phy_driver_unregister(&bcm5482_driver);
out_5482:
	phy_driver_unregister(&bcm5481_driver);
out_5481:
	phy_driver_unregister(&bcm5464_driver);
out_5464:
	phy_driver_unregister(&bcm5461_driver);
out_5461:
	phy_driver_unregister(&bcm5421_driver);
out_5421:
	phy_driver_unregister(&bcm5411_driver);
out_5411:
	return ret;
}
static int __init ste10Xp_init(void)
{
	int retval;

	retval = phy_driver_register(&ste100p_pdriver);
	if (retval < 0)
		return retval;
	return phy_driver_register(&ste101p_pdriver);
}
static int __init realtek_init(void)
{
	int ret;

	ret = phy_driver_register(&rtl8211b_driver);
	if (ret < 0)
		return -ENODEV;
	return phy_driver_register(&rtl8211e_driver);
}
Esempio n. 7
0
static int __init icplus_init(void)
{
	int ret = 0;

	ret = phy_driver_register(&ip1001_driver);
	if (ret < 0)
		return -ENODEV;

	return phy_driver_register(&ip175c_driver);
}
static int __init vsc82xx_init(void)
{
	int err;

	err = phy_driver_register(&vsc8244_driver);
	if (err < 0)
		return err;
	err = phy_driver_register(&vsc8221_driver);
	if (err < 0)
		phy_driver_unregister(&vsc8244_driver);
	return err;
}
Esempio n. 9
0
static int __init realtek_init(void)
{
	int ret;

	ret = phy_driver_register(&rtl821x_driver);

	return ret;
}
Esempio n. 10
0
static int __init bcm63xx_phy_init(void)
{
	int ret;

	ret = phy_driver_register(&bcm63xx_1_driver);
	if (ret)
		goto out_63xx_1;
	ret = phy_driver_register(&bcm63xx_2_driver);
	if (ret)
		goto out_63xx_2;
	return ret;

out_63xx_2:
	phy_driver_unregister(&bcm63xx_1_driver);
out_63xx_1:
	return ret;
}
static int __init micrel_phy_init(void)
{
	int ret;

	ret = phy_driver_register(&ksz8041_phy_driver);

	return ret;
}
Esempio n. 12
0
static int __init lxt_init(void)
{
	int ret;

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

	ret = phy_driver_register(&lxt971_driver);
	if (ret)
		goto err2;
	return 0;

 err2:	
	phy_driver_unregister(&lxt970_driver);
 err1:
	return ret;
}
Esempio n. 13
0
static int __init cicada_init(void)
{
	int ret;

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

	ret = phy_driver_register(&cis8201_driver);
	if (ret)
		goto err2;
	return 0;

err2:
	phy_driver_unregister(&cis8204_driver);
err1:
	return ret;
}
Esempio n. 14
0
static int __init atheros_init(void)
{
	int ret;

	ret = phy_driver_register(&ar8035_driver);
	if (ret < 0)
		pr_warn("AR8035: phy_driver_register is error\n");

	return ret;
}
Esempio n. 15
0
static int __init am79c_init(void)
{
	int ret;

	ret = phy_driver_register(&am79c_driver);
	if (ret)
		return ret;

	return 0;
}
Esempio n. 16
0
static int __init atheros_init(void)
{
	int ret;

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

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

	return 0;

err2:
	phy_driver_unregister(&at8035_driver);
err1:
	return ret;
}
Esempio n. 17
0
static int __init ns8384x_init(void)
{
	int ret;

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

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

	return 0;
err2:
	printk(KERN_INFO "register dp83849 PHY driver fail\n");
	phy_driver_unregister(&dp83848_driver);
err1:
	printk(KERN_INFO "register dp83848 PHY driver fail\n");
	return ret;
}
Esempio n. 18
0
static int __init vsc848x_mod_init(void)
{
	int rv;

	rv = platform_driver_register(&mdio_mux_gpio_driver);
	if (rv)
		return rv;

	rv = phy_driver_register(&vsc848x_phy_driver);

	return rv;
}
Esempio n. 19
0
int __init b53_phy_driver_register(void)
{
	int ret;

	ret = phy_driver_register(&b53_phy_driver_id1);
	if (ret)
		return ret;

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

	ret = phy_driver_register(&b53_phy_driver_id3);
	if (!ret)
		return 0;

	phy_driver_unregister(&b53_phy_driver_id2);
err1:
	phy_driver_unregister(&b53_phy_driver_id1);
	return ret;
}
Esempio n. 20
0
static int __init phy_init(void)
{
	int rc;

	rc = mdio_bus_init();
	if (rc)
		return rc;

	rc = phy_driver_register(&genphy_driver);
	if (rc)
		mdio_bus_exit();

	return rc;
}
Esempio n. 21
0
static int __init davicom_init(void)
{
	int ret;

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

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

	ret = phy_driver_register(&dm9131_driver);
	if (ret)
		goto err3;
	return 0;

 err3:
	phy_driver_unregister(&dm9161a_driver);
 err2:
	phy_driver_unregister(&dm9161e_driver);
 err1:
	return ret;
}
Esempio n. 22
0
static int __init marvell_init(void)
{
	int ret;

	ret = phy_driver_register(&m88e1101_driver);
	if (ret)
		return ret;

	ret = phy_driver_register(&m88e1111s_driver);
	if (ret)
		goto err1111s;

	ret = phy_driver_register(&m88e1145_driver);
	if (ret)
		goto err1145;

	return 0;

      err1145:
	phy_driver_unregister(&m88e1111s_driver);
      err1111s:
	phy_driver_unregister(&m88e1101_driver);
	return ret;
}
Esempio n. 23
0
static int __init marvell_init(void)
{
	int ret;
	int i;

	for (i = 0; i < ARRAY_SIZE(marvell_drivers); i++) {
		ret = phy_driver_register(&marvell_drivers[i]);

		if (ret) {
			while (i-- > 0)
				phy_driver_unregister(&marvell_drivers[i]);
			return ret;
		}
	}

	return 0;
}
Esempio n. 24
0
static int __init fixed_init(void)
{
	int ret;
	int duplex = 0;

	/* register on the bus... Not expected to be matched with anything there... */
	phy_driver_register(&fixed_mdio_driver);

	/* So let the fun begin...
	   We will create several mdio devices here, and will bound the upper
	   driver to them.

	   Then the external software can lookup the phy bus by searching
	   fixed@speed:duplex, e.g. fixed@100:1, to be connected to the
	   virtual 100M Fdx phy.

	   In case several virtual PHYs required, the bus_id will be in form
	   fixed_<num>@<speed>:<duplex>, which make it able even to define
	   driver-specific link control callback, if for instance PHY is completely
	   SW-driven.

	*/

#ifdef CONFIG_FIXED_MII_DUPLEX
	duplex = 1;
#endif

#ifdef CONFIG_FIXED_MII_100_FDX
	fixed_mdio_register_device(0, 100, 1);
#endif

#ifdef CONFIX_FIXED_MII_10_FDX
	fixed_mdio_register_device(0, 10, 1);
#endif
	return 0;
}
Esempio n. 25
0
static int __init tlk106_init(void)
{
	int ret;

	ret = phy_driver_register(&tlk106_0_driver);
	if (ret)
		goto err0;
	ret = phy_driver_register(&tlk106_1_driver);
	if (ret)
		goto err1;
	ret = phy_driver_register(&tlk106_2_driver);
	if (ret)
		goto err2;
	ret = phy_driver_register(&tlk106_3_driver);
	if (ret)
		goto err3;
	ret = phy_driver_register(&tlk106_4_driver);
	if (ret)
		goto err4;
	ret = phy_driver_register(&tlk106_5_driver);
	if (ret)
		goto err5;

	return 0;

err5:
	phy_driver_unregister(&tlk106_4_driver);
err4:
	phy_driver_unregister(&tlk106_3_driver);
err3:
	phy_driver_unregister(&tlk106_2_driver);
err2:
	phy_driver_unregister(&tlk106_1_driver);
err1:
	phy_driver_unregister(&tlk106_0_driver);
err0:
	return ret;
}
Esempio n. 26
0
static int ns_phy_init(void)
{
	return phy_driver_register(&dp83865_driver);
}
Esempio n. 27
0
File: micrel.c Progetto: whble/trunk
static int __init micrel_phy_init(void)
{
	return phy_driver_register(&ksz8041_phy_driver);
}
Esempio n. 28
0
static int __init mcs814x_phy_init(void)
{
	return phy_driver_register(&mcs8140_driver);
}
Esempio n. 29
0
static int __init adm6996_init(void)
{
	phy_register_fixup_for_id(PHY_ANY_ID, adm6996_fixup);
	return phy_driver_register(&adm6996_driver);
}
Esempio n. 30
0
static int __init realtek_init(void)
{

	return phy_driver_register(&rtl8211e_driver);
}