hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

net: phy: replace phy_drivers_register calls 

Replace module init/exit which only calls phy_drivers_register with
module_phy_driver macro.

Tested using Micrel driver, and otherwise compile-tested only.

Signed-off-by: Johan Hovold <johan@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Johan Hovold 2014-11-11 19:45:59 +01:00 committed by David S. Miller
parent 116dffa0b5
commit 50fd71507e
16 changed files with 16 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
drivers/net/phy/amd-xgbe-phy.c
View File

@ -1468,20 +1468,7 @@ static struct phy_driver amd_xgbe_phy_driver[] = {
},
};
static int __init amd_xgbe_phy_init(void)
{
return phy_drivers_register(amd_xgbe_phy_driver,
ARRAY_SIZE(amd_xgbe_phy_driver));
}
static void __exit amd_xgbe_phy_exit(void)
{
phy_drivers_unregister(amd_xgbe_phy_driver,
ARRAY_SIZE(amd_xgbe_phy_driver));
}
module_init(amd_xgbe_phy_init);
module_exit(amd_xgbe_phy_exit);
module_phy_driver(amd_xgbe_phy_driver);
static struct mdio_device_id __maybe_unused amd_xgbe_phy_ids[] = {
{ XGBE_PHY_ID, XGBE_PHY_MASK },

14
drivers/net/phy/at803x.c
View File

@ -352,19 +352,7 @@ static struct phy_driver at803x_driver[] = {
},
} };
static int __init atheros_init(void)
{
return phy_drivers_register(at803x_driver,
ARRAY_SIZE(at803x_driver));
}
static void __exit atheros_exit(void)
{
phy_drivers_unregister(at803x_driver, ARRAY_SIZE(at803x_driver));
}
module_init(atheros_init);
module_exit(atheros_exit);
module_phy_driver(at803x_driver);
static struct mdio_device_id __maybe_unused atheros_tbl[] = {
{ ATH8030_PHY_ID, 0xffffffef },

15
drivers/net/phy/bcm63xx.c
View File

@ -100,20 +100,7 @@ static struct phy_driver bcm63xx_driver[] = {
.driver = { .owner = THIS_MODULE },
} };
static int __init bcm63xx_phy_init(void)
{
return phy_drivers_register(bcm63xx_driver,
ARRAY_SIZE(bcm63xx_driver));
}
static void __exit bcm63xx_phy_exit(void)
{
phy_drivers_unregister(bcm63xx_driver,
ARRAY_SIZE(bcm63xx_driver));
}
module_init(bcm63xx_phy_init);
module_exit(bcm63xx_phy_exit);
module_phy_driver(bcm63xx_driver);
static struct mdio_device_id __maybe_unused bcm63xx_tbl[] = {
{ 0x00406000, 0xfffffc00 },

15
drivers/net/phy/bcm7xxx.c
View File

@ -416,20 +416,7 @@ static struct mdio_device_id __maybe_unused bcm7xxx_tbl[] = {
{ }
};
static int __init bcm7xxx_phy_init(void)
{
return phy_drivers_register(bcm7xxx_driver,
ARRAY_SIZE(bcm7xxx_driver));
}
static void __exit bcm7xxx_phy_exit(void)
{
phy_drivers_unregister(bcm7xxx_driver,
ARRAY_SIZE(bcm7xxx_driver));
}
module_init(bcm7xxx_phy_init);
module_exit(bcm7xxx_phy_exit);
module_phy_driver(bcm7xxx_driver);
MODULE_DEVICE_TABLE(mdio, bcm7xxx_tbl);

14
drivers/net/phy/bcm87xx.c
View File

@ -216,18 +216,6 @@ static struct phy_driver bcm87xx_driver[] = {
.driver = { .owner = THIS_MODULE },
} };
static int __init bcm87xx_init(void)
{
return phy_drivers_register(bcm87xx_driver,
ARRAY_SIZE(bcm87xx_driver));
}
module_init(bcm87xx_init);
static void __exit bcm87xx_exit(void)
{
phy_drivers_unregister(bcm87xx_driver,
ARRAY_SIZE(bcm87xx_driver));
}
module_exit(bcm87xx_exit);
module_phy_driver(bcm87xx_driver);
MODULE_LICENSE("GPL");

15
drivers/net/phy/broadcom.c
View File

@ -654,20 +654,7 @@ static struct phy_driver broadcom_drivers[] = {
.driver = { .owner = THIS_MODULE },
} };
static int __init broadcom_init(void)
{
return phy_drivers_register(broadcom_drivers,
ARRAY_SIZE(broadcom_drivers));
}
static void __exit broadcom_exit(void)
{
phy_drivers_unregister(broadcom_drivers,
ARRAY_SIZE(broadcom_drivers));
}
module_init(broadcom_init);
module_exit(broadcom_exit);
module_phy_driver(broadcom_drivers);
static struct mdio_device_id __maybe_unused broadcom_tbl[] = {
{ PHY_ID_BCM5411, 0xfffffff0 },

15
drivers/net/phy/cicada.c
View File

@ -129,20 +129,7 @@ static struct phy_driver cis820x_driver[] = {
.driver = { .owner = THIS_MODULE,},
} };
static int __init cicada_init(void)
{
return phy_drivers_register(cis820x_driver,
ARRAY_SIZE(cis820x_driver));
}
static void __exit cicada_exit(void)
{
phy_drivers_unregister(cis820x_driver,
ARRAY_SIZE(cis820x_driver));
}
module_init(cicada_init);
module_exit(cicada_exit);
module_phy_driver(cis820x_driver);
static struct mdio_device_id __maybe_unused cicada_tbl[] = {
{ 0x000fc410, 0x000ffff0 },

15
drivers/net/phy/davicom.c
View File

@ -182,20 +182,7 @@ static struct phy_driver dm91xx_driver[] = {
.driver = { .owner = THIS_MODULE,},
} };
static int __init davicom_init(void)
{
return phy_drivers_register(dm91xx_driver,
ARRAY_SIZE(dm91xx_driver));
}
static void __exit davicom_exit(void)
{
phy_drivers_unregister(dm91xx_driver,
ARRAY_SIZE(dm91xx_driver));
}
module_init(davicom_init);
module_exit(davicom_exit);
module_phy_driver(dm91xx_driver);
static struct mdio_device_id __maybe_unused davicom_tbl[] = {
{ 0x0181b880, 0x0ffffff0 },

15
drivers/net/phy/icplus.c
View File

@ -253,20 +253,7 @@ static struct phy_driver icplus_driver[] = {
.driver = { .owner = THIS_MODULE,},
} };
static int __init icplus_init(void)
{
return phy_drivers_register(icplus_driver,
ARRAY_SIZE(icplus_driver));
}
static void __exit icplus_exit(void)
{
phy_drivers_unregister(icplus_driver,
ARRAY_SIZE(icplus_driver));
}
module_init(icplus_init);
module_exit(icplus_exit);
module_phy_driver(icplus_driver);
static struct mdio_device_id __maybe_unused icplus_tbl[] = {
{ 0x02430d80, 0x0ffffff0 },

15
drivers/net/phy/lxt.c
View File

@ -312,20 +312,7 @@ static struct phy_driver lxt97x_driver[] = {
.driver = { .owner = THIS_MODULE,},
} };
static int __init lxt_init(void)
{
return phy_drivers_register(lxt97x_driver,
ARRAY_SIZE(lxt97x_driver));
}
static void __exit lxt_exit(void)
{
phy_drivers_unregister(lxt97x_driver,
ARRAY_SIZE(lxt97x_driver));
}
module_init(lxt_init);
module_exit(lxt_exit);
module_phy_driver(lxt97x_driver);
static struct mdio_device_id __maybe_unused lxt_tbl[] = {
{ 0x78100000, 0xfffffff0 },

15
drivers/net/phy/marvell.c
View File

@ -1120,20 +1120,7 @@ static struct phy_driver marvell_drivers[] = {
},
};
static int __init marvell_init(void)
{
return phy_drivers_register(marvell_drivers,
ARRAY_SIZE(marvell_drivers));
}
static void __exit marvell_exit(void)
{
phy_drivers_unregister(marvell_drivers,
ARRAY_SIZE(marvell_drivers));
}
module_init(marvell_init);
module_exit(marvell_exit);
module_phy_driver(marvell_drivers);
static struct mdio_device_id __maybe_unused marvell_tbl[] = {
{ MARVELL_PHY_ID_88E1101, MARVELL_PHY_ID_MASK },

15
drivers/net/phy/micrel.c
View File

@ -657,20 +657,7 @@ static struct phy_driver ksphy_driver[] = {
.driver = { .owner = THIS_MODULE, },
} };
static int __init ksphy_init(void)
{
return phy_drivers_register(ksphy_driver,
ARRAY_SIZE(ksphy_driver));
}
static void __exit ksphy_exit(void)
{
phy_drivers_unregister(ksphy_driver,
ARRAY_SIZE(ksphy_driver));
}
module_init(ksphy_init);
module_exit(ksphy_exit);
module_phy_driver(ksphy_driver);
MODULE_DESCRIPTION("Micrel PHY driver");
MODULE_AUTHOR("David J. Choi");

13
drivers/net/phy/realtek.c
View File

@ -101,18 +101,7 @@ static struct phy_driver realtek_drvs[] = {
},
};
static int __init realtek_init(void)
{
return phy_drivers_register(realtek_drvs, ARRAY_SIZE(realtek_drvs));
}
static void __exit realtek_exit(void)
{
phy_drivers_unregister(realtek_drvs, ARRAY_SIZE(realtek_drvs));
}
module_init(realtek_init);
module_exit(realtek_exit);
module_phy_driver(realtek_drvs);
static struct mdio_device_id __maybe_unused realtek_tbl[] = {
{ 0x001cc912, 0x001fffff },

14
drivers/net/phy/smsc.c
View File

@ -250,24 +250,12 @@ static struct phy_driver smsc_phy_driver[] = {
.driver = { .owner = THIS_MODULE, }
} };
static int __init smsc_init(void)
{
return phy_drivers_register(smsc_phy_driver,
ARRAY_SIZE(smsc_phy_driver));
}
static void __exit smsc_exit(void)
{
phy_drivers_unregister(smsc_phy_driver, ARRAY_SIZE(smsc_phy_driver));
}
module_phy_driver(smsc_phy_driver);
MODULE_DESCRIPTION("SMSC PHY driver");
MODULE_AUTHOR("Herbert Valerio Riedel");
MODULE_LICENSE("GPL");
module_init(smsc_init);
module_exit(smsc_exit);
static struct mdio_device_id __maybe_unused smsc_tbl[] = {
{ 0x0007c0a0, 0xfffffff0 },
{ 0x0007c0b0, 0xfffffff0 },

15
drivers/net/phy/ste10Xp.c
View File

@ -112,20 +112,7 @@ static struct phy_driver ste10xp_pdriver[] = {
.driver = {.owner = THIS_MODULE,}
} };
static int __init ste10Xp_init(void)
{
return phy_drivers_register(ste10xp_pdriver,
ARRAY_SIZE(ste10xp_pdriver));
}
static void __exit ste10Xp_exit(void)
{
phy_drivers_unregister(ste10xp_pdriver,
ARRAY_SIZE(ste10xp_pdriver));
}
module_init(ste10Xp_init);
module_exit(ste10Xp_exit);
module_phy_driver(ste10xp_pdriver);
static struct mdio_device_id __maybe_unused ste10Xp_tbl[] = {
{ STE101P_PHY_ID, 0xfffffff0 },

14
drivers/net/phy/vitesse.c
View File

@ -311,19 +311,7 @@ static struct phy_driver vsc82xx_driver[] = {
.driver = { .owner = THIS_MODULE,},
} };
static int __init vsc82xx_init(void)
{
return phy_drivers_register(vsc82xx_driver,
ARRAY_SIZE(vsc82xx_driver));
}
static void __exit vsc82xx_exit(void)
{
phy_drivers_unregister(vsc82xx_driver, ARRAY_SIZE(vsc82xx_driver));
}
module_init(vsc82xx_init);
module_exit(vsc82xx_exit);
module_phy_driver(vsc82xx_driver);
static struct mdio_device_id __maybe_unused vitesse_tbl[] = {
{ PHY_ID_VSC8234, 0x000ffff0 },