mirror of https://gitee.com/openkylin/linux.git
Merge branch 'net-phy-add-support-for-shared-interrupts-part-1'
Ioana Ciornei says:
====================
net: phy: add support for shared interrupts (part 1)
This patch set aims to actually add support for shared interrupts in
phylib and not only for multi-PHY devices. While we are at it,
streamline the interrupt handling in phylib.
For a bit of context, at the moment, there are multiple phy_driver ops
that deal with this subject:
- .config_intr() - Enable/disable the interrupt line.
- .ack_interrupt() - Should quiesce any interrupts that may have been
fired. It's also used by phylib in conjunction with .config_intr() to
clear any pending interrupts after the line was disabled, and before
it is going to be enabled.
- .did_interrupt() - Intended for multi-PHY devices with a shared IRQ
line and used by phylib to discern which PHY from the package was the
one that actually fired the interrupt.
- .handle_interrupt() - Completely overrides the default interrupt
handling logic from phylib. The PHY driver is responsible for checking
if any interrupt was fired by the respective PHY and choose
accordingly if it's the one that should trigger the link state machine.
From my point of view, the interrupt handling in phylib has become
somewhat confusing with all these callbacks that actually read the same
PHY register - the interrupt status. A more streamlined approach would
be to just move the responsibility to write an interrupt handler to the
driver (as any other device driver does) and make .handle_interrupt()
the only way to deal with interrupts.
Another advantage with this approach would be that phylib would gain
support for shared IRQs between different PHY (not just multi-PHY
devices), something which at the moment would require extending every
PHY driver anyway in order to implement their .did_interrupt() callback
and duplicate the same logic as in .ack_interrupt(). The disadvantage
of making .did_interrupt() mandatory would be that we are slightly
changing the semantics of the phylib API and that would increase
confusion instead of reducing it.
What I am proposing is the following:
- As a first step, make the .ack_interrupt() callback optional so that
we do not break any PHY driver amid the transition.
- Every PHY driver gains a .handle_interrupt() implementation that, for
the most part, would look like below:
irq_status = phy_read(phydev, INTR_STATUS);
if (irq_status < 0) {
phy_error(phydev);
return IRQ_NONE;
}
if (!(irq_status & irq_mask))
return IRQ_NONE;
phy_trigger_machine(phydev);
return IRQ_HANDLED;
- Remove each PHY driver's implementation of the .ack_interrupt() by
actually taking care of quiescing any pending interrupts before
enabling/after disabling the interrupt line.
- Finally, after all drivers have been ported, remove the
.ack_interrupt() and .did_interrupt() callbacks from phy_driver.
This patch set is part 1 and it addresses the changes needed in phylib
and 7 PHY drivers. The rest can be found on my Github branch here:
https://github.com/IoanaCiornei/linux/commits/phylib-shared-irq
I do not have access to most of these PHY's, therefore I Cc-ed the
latest contributors to the individual PHY drivers in order to have
access, hopefully, to more regression testing.
Changes in v2:
- Rework the .handle_interrupt() implementation for each driver so that
only the enabled interrupts are taken into account when
IRQ_NONE/IRQ_HANDLED it returned. The main idea is so that we avoid
falsely blaming a device for triggering an interrupt when this is not
the case.
The only devices for which I was unable to make this adjustment were
the BCM8706, BCM8727, BCMAC131 and BCM5241 since I do not have access
to their datasheets.
- I also updated the pseudo-code added in the cover-letter so that it's
more clear how a .handle_interrupt() callback should look like.
====================
Tested-by: Andrew Lunn <andrew@lunn.ch>
Link: https://lore.kernel.org/r/20201101125114.1316879-1-ciorneiioana@gmail.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski
commit
5aee9484df
|
|
@ -52,6 +52,7 @@
|
|||
#define MDIO_AN_TX_VEND_INT_STATUS1_DOWNSHIFT BIT(1)
|
||||
|
||||
#define MDIO_AN_TX_VEND_INT_STATUS2 0xcc01
|
||||
#define MDIO_AN_TX_VEND_INT_STATUS2_MASK BIT(0)
|
||||
|
||||
#define MDIO_AN_TX_VEND_INT_MASK2 0xd401
|
||||
#define MDIO_AN_TX_VEND_INT_MASK2_LINK BIT(0)
|
||||
|
|
@ -246,6 +247,13 @@ static int aqr_config_intr(struct phy_device *phydev)
|
|||
bool en = phydev->interrupts == PHY_INTERRUPT_ENABLED;
|
||||
int err;
|
||||
|
||||
if (en) {
|
||||
/* Clear any pending interrupts before enabling them */
|
||||
err = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_TX_VEND_INT_STATUS2);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
err = phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_TX_VEND_INT_MASK2,
|
||||
en ? MDIO_AN_TX_VEND_INT_MASK2_LINK : 0);
|
||||
if (err < 0)
|
||||
|
|
@ -256,18 +264,39 @@ static int aqr_config_intr(struct phy_device *phydev)
|
|||
if (err < 0)
|
||||
return err;
|
||||
|
||||
return phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_GLOBAL_INT_VEND_MASK,
|
||||
en ? VEND1_GLOBAL_INT_VEND_MASK_GLOBAL3 |
|
||||
VEND1_GLOBAL_INT_VEND_MASK_AN : 0);
|
||||
err = phy_write_mmd(phydev, MDIO_MMD_VEND1, VEND1_GLOBAL_INT_VEND_MASK,
|
||||
en ? VEND1_GLOBAL_INT_VEND_MASK_GLOBAL3 |
|
||||
VEND1_GLOBAL_INT_VEND_MASK_AN : 0);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
if (!en) {
|
||||
/* Clear any pending interrupts after we have disabled them */
|
||||
err = phy_read_mmd(phydev, MDIO_MMD_AN, MDIO_AN_TX_VEND_INT_STATUS2);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int aqr_ack_interrupt(struct phy_device *phydev)
|
||||
static irqreturn_t aqr_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int reg;
|
||||
int irq_status;
|
||||
|
||||
reg = phy_read_mmd(phydev, MDIO_MMD_AN,
|
||||
MDIO_AN_TX_VEND_INT_STATUS2);
|
||||
return (reg < 0) ? reg : 0;
|
||||
irq_status = phy_read_mmd(phydev, MDIO_MMD_AN,
|
||||
MDIO_AN_TX_VEND_INT_STATUS2);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (!(irq_status & MDIO_AN_TX_VEND_INT_STATUS2_MASK))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int aqr_read_status(struct phy_device *phydev)
|
||||
|
|
@ -584,7 +613,7 @@ static struct phy_driver aqr_driver[] = {
|
|||
.name = "Aquantia AQ1202",
|
||||
.config_aneg = aqr_config_aneg,
|
||||
.config_intr = aqr_config_intr,
|
||||
.ack_interrupt = aqr_ack_interrupt,
|
||||
.handle_interrupt = aqr_handle_interrupt,
|
||||
.read_status = aqr_read_status,
|
||||
},
|
||||
{
|
||||
|
|
@ -592,7 +621,7 @@ static struct phy_driver aqr_driver[] = {
|
|||
.name = "Aquantia AQ2104",
|
||||
.config_aneg = aqr_config_aneg,
|
||||
.config_intr = aqr_config_intr,
|
||||
.ack_interrupt = aqr_ack_interrupt,
|
||||
.handle_interrupt = aqr_handle_interrupt,
|
||||
.read_status = aqr_read_status,
|
||||
},
|
||||
{
|
||||
|
|
@ -600,7 +629,7 @@ static struct phy_driver aqr_driver[] = {
|
|||
.name = "Aquantia AQR105",
|
||||
.config_aneg = aqr_config_aneg,
|
||||
.config_intr = aqr_config_intr,
|
||||
.ack_interrupt = aqr_ack_interrupt,
|
||||
.handle_interrupt = aqr_handle_interrupt,
|
||||
.read_status = aqr_read_status,
|
||||
.suspend = aqr107_suspend,
|
||||
.resume = aqr107_resume,
|
||||
|
|
@ -610,7 +639,7 @@ static struct phy_driver aqr_driver[] = {
|
|||
.name = "Aquantia AQR106",
|
||||
.config_aneg = aqr_config_aneg,
|
||||
.config_intr = aqr_config_intr,
|
||||
.ack_interrupt = aqr_ack_interrupt,
|
||||
.handle_interrupt = aqr_handle_interrupt,
|
||||
.read_status = aqr_read_status,
|
||||
},
|
||||
{
|
||||
|
|
@ -620,7 +649,7 @@ static struct phy_driver aqr_driver[] = {
|
|||
.config_init = aqr107_config_init,
|
||||
.config_aneg = aqr_config_aneg,
|
||||
.config_intr = aqr_config_intr,
|
||||
.ack_interrupt = aqr_ack_interrupt,
|
||||
.handle_interrupt = aqr_handle_interrupt,
|
||||
.read_status = aqr107_read_status,
|
||||
.get_tunable = aqr107_get_tunable,
|
||||
.set_tunable = aqr107_set_tunable,
|
||||
|
|
@ -638,7 +667,7 @@ static struct phy_driver aqr_driver[] = {
|
|||
.config_init = aqcs109_config_init,
|
||||
.config_aneg = aqr_config_aneg,
|
||||
.config_intr = aqr_config_intr,
|
||||
.ack_interrupt = aqr_ack_interrupt,
|
||||
.handle_interrupt = aqr_handle_interrupt,
|
||||
.read_status = aqr107_read_status,
|
||||
.get_tunable = aqr107_get_tunable,
|
||||
.set_tunable = aqr107_set_tunable,
|
||||
|
|
@ -654,7 +683,7 @@ static struct phy_driver aqr_driver[] = {
|
|||
.name = "Aquantia AQR405",
|
||||
.config_aneg = aqr_config_aneg,
|
||||
.config_intr = aqr_config_intr,
|
||||
.ack_interrupt = aqr_ack_interrupt,
|
||||
.handle_interrupt = aqr_handle_interrupt,
|
||||
.read_status = aqr_read_status,
|
||||
},
|
||||
};
|
||||
|
|
|
|||
|
|
@ -614,6 +614,11 @@ static int at803x_config_intr(struct phy_device *phydev)
|
|||
value = phy_read(phydev, AT803X_INTR_ENABLE);
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
/* Clear any pending interrupts */
|
||||
err = at803x_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
value |= AT803X_INTR_ENABLE_AUTONEG_ERR;
|
||||
value |= AT803X_INTR_ENABLE_SPEED_CHANGED;
|
||||
value |= AT803X_INTR_ENABLE_DUPLEX_CHANGED;
|
||||
|
|
@ -621,13 +626,44 @@ static int at803x_config_intr(struct phy_device *phydev)
|
|||
value |= AT803X_INTR_ENABLE_LINK_SUCCESS;
|
||||
|
||||
err = phy_write(phydev, AT803X_INTR_ENABLE, value);
|
||||
}
|
||||
else
|
||||
} else {
|
||||
err = phy_write(phydev, AT803X_INTR_ENABLE, 0);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Clear any pending interrupts */
|
||||
err = at803x_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static irqreturn_t at803x_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status, int_enabled;
|
||||
|
||||
irq_status = phy_read(phydev, AT803X_INTR_STATUS);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
/* Read the current enabled interrupts */
|
||||
int_enabled = phy_read(phydev, AT803X_INTR_ENABLE);
|
||||
if (int_enabled < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
/* See if this was one of our enabled interrupts */
|
||||
if (!(irq_status & int_enabled))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static void at803x_link_change_notify(struct phy_device *phydev)
|
||||
{
|
||||
/*
|
||||
|
|
@ -1062,8 +1098,8 @@ static struct phy_driver at803x_driver[] = {
|
|||
.resume = at803x_resume,
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.read_status = at803x_read_status,
|
||||
.ack_interrupt = at803x_ack_interrupt,
|
||||
.config_intr = at803x_config_intr,
|
||||
.handle_interrupt = at803x_handle_interrupt,
|
||||
.get_tunable = at803x_get_tunable,
|
||||
.set_tunable = at803x_set_tunable,
|
||||
.cable_test_start = at803x_cable_test_start,
|
||||
|
|
@ -1082,8 +1118,8 @@ static struct phy_driver at803x_driver[] = {
|
|||
.suspend = at803x_suspend,
|
||||
.resume = at803x_resume,
|
||||
/* PHY_BASIC_FEATURES */
|
||||
.ack_interrupt = at803x_ack_interrupt,
|
||||
.config_intr = at803x_config_intr,
|
||||
.handle_interrupt = at803x_handle_interrupt,
|
||||
}, {
|
||||
/* Qualcomm Atheros AR8031/AR8033 */
|
||||
PHY_ID_MATCH_EXACT(ATH8031_PHY_ID),
|
||||
|
|
@ -1100,8 +1136,8 @@ static struct phy_driver at803x_driver[] = {
|
|||
/* PHY_GBIT_FEATURES */
|
||||
.read_status = at803x_read_status,
|
||||
.aneg_done = at803x_aneg_done,
|
||||
.ack_interrupt = &at803x_ack_interrupt,
|
||||
.config_intr = &at803x_config_intr,
|
||||
.handle_interrupt = at803x_handle_interrupt,
|
||||
.get_tunable = at803x_get_tunable,
|
||||
.set_tunable = at803x_set_tunable,
|
||||
.cable_test_start = at803x_cable_test_start,
|
||||
|
|
@ -1120,8 +1156,8 @@ static struct phy_driver at803x_driver[] = {
|
|||
.suspend = at803x_suspend,
|
||||
.resume = at803x_resume,
|
||||
/* PHY_BASIC_FEATURES */
|
||||
.ack_interrupt = at803x_ack_interrupt,
|
||||
.config_intr = at803x_config_intr,
|
||||
.handle_interrupt = at803x_handle_interrupt,
|
||||
.cable_test_start = at803x_cable_test_start,
|
||||
.cable_test_get_status = at803x_cable_test_get_status,
|
||||
}, {
|
||||
|
|
@ -1132,8 +1168,8 @@ static struct phy_driver at803x_driver[] = {
|
|||
.resume = at803x_resume,
|
||||
.flags = PHY_POLL_CABLE_TEST,
|
||||
/* PHY_BASIC_FEATURES */
|
||||
.ack_interrupt = &at803x_ack_interrupt,
|
||||
.config_intr = &at803x_config_intr,
|
||||
.handle_interrupt = at803x_handle_interrupt,
|
||||
.cable_test_start = at803x_cable_test_start,
|
||||
.cable_test_get_status = at803x_cable_test_get_status,
|
||||
.read_status = at803x_read_status,
|
||||
|
|
|
|||
|
|
@ -256,8 +256,8 @@ static struct phy_driver bcm_cygnus_phy_driver[] = {
|
|||
.name = "Broadcom Cygnus PHY",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm_cygnus_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = bcm_cygnus_resume,
|
||||
}, {
|
||||
|
|
|
|||
|
|
@ -181,21 +181,62 @@ EXPORT_SYMBOL_GPL(bcm_phy_ack_intr);
|
|||
|
||||
int bcm_phy_config_intr(struct phy_device *phydev)
|
||||
{
|
||||
int reg;
|
||||
int reg, err;
|
||||
|
||||
reg = phy_read(phydev, MII_BCM54XX_ECR);
|
||||
if (reg < 0)
|
||||
return reg;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
reg &= ~MII_BCM54XX_ECR_IM;
|
||||
else
|
||||
reg |= MII_BCM54XX_ECR_IM;
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = bcm_phy_ack_intr(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return phy_write(phydev, MII_BCM54XX_ECR, reg);
|
||||
reg &= ~MII_BCM54XX_ECR_IM;
|
||||
err = phy_write(phydev, MII_BCM54XX_ECR, reg);
|
||||
} else {
|
||||
reg |= MII_BCM54XX_ECR_IM;
|
||||
err = phy_write(phydev, MII_BCM54XX_ECR, reg);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = bcm_phy_ack_intr(phydev);
|
||||
}
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(bcm_phy_config_intr);
|
||||
|
||||
irqreturn_t bcm_phy_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status, irq_mask;
|
||||
|
||||
irq_status = phy_read(phydev, MII_BCM54XX_ISR);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
/* If a bit from the Interrupt Mask register is set, the corresponding
|
||||
* bit from the Interrupt Status register is masked. So read the IMR
|
||||
* and then flip the bits to get the list of possible interrupt
|
||||
* sources.
|
||||
*/
|
||||
irq_mask = phy_read(phydev, MII_BCM54XX_IMR);
|
||||
if (irq_mask < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
irq_mask = ~irq_mask;
|
||||
|
||||
if (!(irq_status & irq_mask))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(bcm_phy_handle_interrupt);
|
||||
|
||||
int bcm_phy_read_shadow(struct phy_device *phydev, u16 shadow)
|
||||
{
|
||||
phy_write(phydev, MII_BCM54XX_SHD, MII_BCM54XX_SHD_VAL(shadow));
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@ int bcm_phy_modify_rdb(struct phy_device *phydev, u16 rdb, u16 mask,
|
|||
|
||||
int bcm_phy_ack_intr(struct phy_device *phydev);
|
||||
int bcm_phy_config_intr(struct phy_device *phydev);
|
||||
irqreturn_t bcm_phy_handle_interrupt(struct phy_device *phydev);
|
||||
|
||||
int bcm_phy_enable_apd(struct phy_device *phydev, bool dll_pwr_down);
|
||||
|
||||
|
|
|
|||
|
|
@ -637,13 +637,29 @@ static int bcm54140_config_init(struct phy_device *phydev)
|
|||
BCM54140_RDB_C_PWR_ISOLATE, 0);
|
||||
}
|
||||
|
||||
static int bcm54140_did_interrupt(struct phy_device *phydev)
|
||||
static irqreturn_t bcm54140_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int ret;
|
||||
int irq_status, irq_mask;
|
||||
|
||||
ret = bcm_phy_read_rdb(phydev, BCM54140_RDB_ISR);
|
||||
irq_status = bcm_phy_read_rdb(phydev, BCM54140_RDB_ISR);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
return (ret < 0) ? 0 : ret;
|
||||
irq_mask = bcm_phy_read_rdb(phydev, BCM54140_RDB_IMR);
|
||||
if (irq_mask < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
irq_mask = ~irq_mask;
|
||||
|
||||
if (!(irq_status & irq_mask))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int bcm54140_ack_intr(struct phy_device *phydev)
|
||||
|
|
@ -665,7 +681,7 @@ static int bcm54140_config_intr(struct phy_device *phydev)
|
|||
BCM54140_RDB_TOP_IMR_PORT0, BCM54140_RDB_TOP_IMR_PORT1,
|
||||
BCM54140_RDB_TOP_IMR_PORT2, BCM54140_RDB_TOP_IMR_PORT3,
|
||||
};
|
||||
int reg;
|
||||
int reg, err;
|
||||
|
||||
if (priv->port >= ARRAY_SIZE(port_to_imr_bit))
|
||||
return -EINVAL;
|
||||
|
|
@ -674,12 +690,23 @@ static int bcm54140_config_intr(struct phy_device *phydev)
|
|||
if (reg < 0)
|
||||
return reg;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
reg &= ~port_to_imr_bit[priv->port];
|
||||
else
|
||||
reg |= port_to_imr_bit[priv->port];
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = bcm54140_ack_intr(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return bcm54140_base_write_rdb(phydev, BCM54140_RDB_TOP_IMR, reg);
|
||||
reg &= ~port_to_imr_bit[priv->port];
|
||||
err = bcm54140_base_write_rdb(phydev, BCM54140_RDB_TOP_IMR, reg);
|
||||
} else {
|
||||
reg |= port_to_imr_bit[priv->port];
|
||||
err = bcm54140_base_write_rdb(phydev, BCM54140_RDB_TOP_IMR, reg);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = bcm54140_ack_intr(phydev);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int bcm54140_get_downshift(struct phy_device *phydev, u8 *data)
|
||||
|
|
@ -834,8 +861,7 @@ static struct phy_driver bcm54140_drivers[] = {
|
|||
.flags = PHY_POLL_CABLE_TEST,
|
||||
.features = PHY_GBIT_FEATURES,
|
||||
.config_init = bcm54140_config_init,
|
||||
.did_interrupt = bcm54140_did_interrupt,
|
||||
.ack_interrupt = bcm54140_ack_intr,
|
||||
.handle_interrupt = bcm54140_handle_interrupt,
|
||||
.config_intr = bcm54140_config_intr,
|
||||
.probe = bcm54140_probe,
|
||||
.suspend = genphy_suspend,
|
||||
|
|
|
|||
|
|
@ -25,12 +25,22 @@ static int bcm63xx_config_intr(struct phy_device *phydev)
|
|||
if (reg < 0)
|
||||
return reg;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
reg &= ~MII_BCM63XX_IR_GMASK;
|
||||
else
|
||||
reg |= MII_BCM63XX_IR_GMASK;
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = bcm_phy_ack_intr(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
reg &= ~MII_BCM63XX_IR_GMASK;
|
||||
err = phy_write(phydev, MII_BCM63XX_IR, reg);
|
||||
} else {
|
||||
reg |= MII_BCM63XX_IR_GMASK;
|
||||
err = phy_write(phydev, MII_BCM63XX_IR, reg);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = bcm_phy_ack_intr(phydev);
|
||||
}
|
||||
|
||||
err = phy_write(phydev, MII_BCM63XX_IR, reg);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
|
@ -67,8 +77,8 @@ static struct phy_driver bcm63xx_driver[] = {
|
|||
/* PHY_BASIC_FEATURES */
|
||||
.flags = PHY_IS_INTERNAL,
|
||||
.config_init = bcm63xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm63xx_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
/* same phy as above, with just a different OUI */
|
||||
.phy_id = 0x002bdc00,
|
||||
|
|
@ -77,8 +87,8 @@ static struct phy_driver bcm63xx_driver[] = {
|
|||
/* PHY_BASIC_FEATURES */
|
||||
.flags = PHY_IS_INTERNAL,
|
||||
.config_init = bcm63xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm63xx_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
} };
|
||||
|
||||
module_phy_driver(bcm63xx_driver);
|
||||
|
|
|
|||
|
|
@ -144,35 +144,41 @@ static int bcm87xx_config_intr(struct phy_device *phydev)
|
|||
if (reg < 0)
|
||||
return reg;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
reg |= 1;
|
||||
else
|
||||
reg &= ~1;
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = phy_read(phydev, BCM87XX_LASI_STATUS);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
reg |= 1;
|
||||
err = phy_write(phydev, BCM87XX_LASI_CONTROL, reg);
|
||||
} else {
|
||||
reg &= ~1;
|
||||
err = phy_write(phydev, BCM87XX_LASI_CONTROL, reg);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = phy_read(phydev, BCM87XX_LASI_STATUS);
|
||||
}
|
||||
|
||||
err = phy_write(phydev, BCM87XX_LASI_CONTROL, reg);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int bcm87xx_did_interrupt(struct phy_device *phydev)
|
||||
static irqreturn_t bcm87xx_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int reg;
|
||||
int irq_status;
|
||||
|
||||
reg = phy_read(phydev, BCM87XX_LASI_STATUS);
|
||||
|
||||
if (reg < 0) {
|
||||
phydev_err(phydev,
|
||||
"Error: Read of BCM87XX_LASI_STATUS failed: %d\n",
|
||||
reg);
|
||||
return 0;
|
||||
irq_status = phy_read(phydev, BCM87XX_LASI_STATUS);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
return (reg & 1) != 0;
|
||||
}
|
||||
|
||||
static int bcm87xx_ack_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
/* Reading the LASI status clears it. */
|
||||
bcm87xx_did_interrupt(phydev);
|
||||
return 0;
|
||||
if (irq_status == 0)
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int bcm8706_match_phy_device(struct phy_device *phydev)
|
||||
|
|
@ -194,9 +200,8 @@ static struct phy_driver bcm87xx_driver[] = {
|
|||
.config_init = bcm87xx_config_init,
|
||||
.config_aneg = bcm87xx_config_aneg,
|
||||
.read_status = bcm87xx_read_status,
|
||||
.ack_interrupt = bcm87xx_ack_interrupt,
|
||||
.config_intr = bcm87xx_config_intr,
|
||||
.did_interrupt = bcm87xx_did_interrupt,
|
||||
.handle_interrupt = bcm87xx_handle_interrupt,
|
||||
.match_phy_device = bcm8706_match_phy_device,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM8727,
|
||||
|
|
@ -206,9 +211,8 @@ static struct phy_driver bcm87xx_driver[] = {
|
|||
.config_init = bcm87xx_config_init,
|
||||
.config_aneg = bcm87xx_config_aneg,
|
||||
.read_status = bcm87xx_read_status,
|
||||
.ack_interrupt = bcm87xx_ack_interrupt,
|
||||
.config_intr = bcm87xx_config_intr,
|
||||
.did_interrupt = bcm87xx_did_interrupt,
|
||||
.handle_interrupt = bcm87xx_handle_interrupt,
|
||||
.match_phy_device = bcm8727_match_phy_device,
|
||||
} };
|
||||
|
||||
|
|
|
|||
|
|
@ -634,15 +634,43 @@ static int brcm_fet_config_intr(struct phy_device *phydev)
|
|||
if (reg < 0)
|
||||
return reg;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
reg &= ~MII_BRCM_FET_IR_MASK;
|
||||
else
|
||||
reg |= MII_BRCM_FET_IR_MASK;
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = brcm_fet_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
reg &= ~MII_BRCM_FET_IR_MASK;
|
||||
err = phy_write(phydev, MII_BRCM_FET_INTREG, reg);
|
||||
} else {
|
||||
reg |= MII_BRCM_FET_IR_MASK;
|
||||
err = phy_write(phydev, MII_BRCM_FET_INTREG, reg);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = brcm_fet_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
err = phy_write(phydev, MII_BRCM_FET_INTREG, reg);
|
||||
return err;
|
||||
}
|
||||
|
||||
static irqreturn_t brcm_fet_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status;
|
||||
|
||||
irq_status = phy_read(phydev, MII_BRCM_FET_INTREG);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (irq_status == 0)
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
struct bcm53xx_phy_priv {
|
||||
u64 *stats;
|
||||
};
|
||||
|
|
@ -681,40 +709,40 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
.name = "Broadcom BCM5411",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM5421,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM5421",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM54210E,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM54210E",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM5461,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM5461",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM54612E,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM54612E",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM54616S,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
|
|
@ -722,8 +750,8 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.config_aneg = bcm54616s_config_aneg,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
.read_status = bcm54616s_read_status,
|
||||
.probe = bcm54616s_probe,
|
||||
}, {
|
||||
|
|
@ -732,8 +760,8 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
.name = "Broadcom BCM5464",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = genphy_resume,
|
||||
}, {
|
||||
|
|
@ -743,8 +771,8 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.config_aneg = bcm5481_config_aneg,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM54810,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
|
|
@ -752,8 +780,8 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.config_aneg = bcm5481_config_aneg,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = bcm54xx_resume,
|
||||
}, {
|
||||
|
|
@ -763,8 +791,8 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54811_config_init,
|
||||
.config_aneg = bcm5481_config_aneg,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = bcm54xx_resume,
|
||||
}, {
|
||||
|
|
@ -774,48 +802,48 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm5482_config_init,
|
||||
.read_status = bcm5482_read_status,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM50610,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM50610",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM50610M,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM50610M",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM57780,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM57780",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCMAC131,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCMAC131",
|
||||
/* PHY_BASIC_FEATURES */
|
||||
.config_init = brcm_fet_config_init,
|
||||
.ack_interrupt = brcm_fet_ack_interrupt,
|
||||
.config_intr = brcm_fet_config_intr,
|
||||
.handle_interrupt = brcm_fet_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM5241,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM5241",
|
||||
/* PHY_BASIC_FEATURES */
|
||||
.config_init = brcm_fet_config_init,
|
||||
.ack_interrupt = brcm_fet_ack_interrupt,
|
||||
.config_intr = brcm_fet_config_intr,
|
||||
.handle_interrupt = brcm_fet_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM5395,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
|
|
@ -837,16 +865,16 @@ static struct phy_driver broadcom_drivers[] = {
|
|||
.get_stats = bcm53xx_phy_get_stats,
|
||||
.probe = bcm53xx_phy_probe,
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = PHY_ID_BCM89610,
|
||||
.phy_id_mask = 0xfffffff0,
|
||||
.name = "Broadcom BCM89610",
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = bcm54xx_config_init,
|
||||
.ack_interrupt = bcm_phy_ack_intr,
|
||||
.config_intr = bcm_phy_config_intr,
|
||||
.handle_interrupt = bcm_phy_handle_interrupt,
|
||||
} };
|
||||
|
||||
module_phy_driver(broadcom_drivers);
|
||||
|
|
|
|||
|
|
@ -87,15 +87,42 @@ static int cis820x_config_intr(struct phy_device *phydev)
|
|||
{
|
||||
int err;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = cis820x_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = phy_write(phydev, MII_CIS8201_IMASK,
|
||||
MII_CIS8201_IMASK_MASK);
|
||||
else
|
||||
} else {
|
||||
err = phy_write(phydev, MII_CIS8201_IMASK, 0);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = cis820x_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static irqreturn_t cis820x_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status;
|
||||
|
||||
irq_status = phy_read(phydev, MII_CIS8201_ISTAT);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (!(irq_status & MII_CIS8201_IMASK_MASK))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
/* Cicada 8201, a.k.a Vitesse VSC8201 */
|
||||
static struct phy_driver cis820x_driver[] = {
|
||||
{
|
||||
|
|
@ -104,16 +131,16 @@ static struct phy_driver cis820x_driver[] = {
|
|||
.phy_id_mask = 0x000ffff0,
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = &cis820x_config_init,
|
||||
.ack_interrupt = &cis820x_ack_interrupt,
|
||||
.config_intr = &cis820x_config_intr,
|
||||
.handle_interrupt = &cis820x_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = 0x000fc440,
|
||||
.name = "Cicada Cis8204",
|
||||
.phy_id_mask = 0x000fffc0,
|
||||
/* PHY_GBIT_FEATURES */
|
||||
.config_init = &cis820x_config_init,
|
||||
.ack_interrupt = &cis820x_ack_interrupt,
|
||||
.config_intr = &cis820x_config_intr,
|
||||
.handle_interrupt = &cis820x_handle_interrupt,
|
||||
} };
|
||||
|
||||
module_phy_driver(cis820x_driver);
|
||||
|
|
|
|||
|
|
@ -47,6 +47,10 @@
|
|||
#define MII_DM9161_INTR_STOP \
|
||||
(MII_DM9161_INTR_DPLX_MASK | MII_DM9161_INTR_SPD_MASK \
|
||||
| MII_DM9161_INTR_LINK_MASK | MII_DM9161_INTR_MASK)
|
||||
#define MII_DM9161_INTR_CHANGE \
|
||||
(MII_DM9161_INTR_DPLX_CHANGE | \
|
||||
MII_DM9161_INTR_SPD_CHANGE | \
|
||||
MII_DM9161_INTR_LINK_CHANGE)
|
||||
|
||||
/* DM9161 10BT Configuration/Status */
|
||||
#define MII_DM9161_10BTCSR 0x12
|
||||
|
|
@ -57,24 +61,58 @@ MODULE_AUTHOR("Andy Fleming");
|
|||
MODULE_LICENSE("GPL");
|
||||
|
||||
|
||||
static int dm9161_ack_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int err = phy_read(phydev, MII_DM9161_INTR);
|
||||
|
||||
return (err < 0) ? err : 0;
|
||||
}
|
||||
|
||||
#define DM9161_DELAY 1
|
||||
static int dm9161_config_intr(struct phy_device *phydev)
|
||||
{
|
||||
int temp;
|
||||
int temp, err;
|
||||
|
||||
temp = phy_read(phydev, MII_DM9161_INTR);
|
||||
|
||||
if (temp < 0)
|
||||
return temp;
|
||||
|
||||
if (PHY_INTERRUPT_ENABLED == phydev->interrupts)
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = dm9161_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
temp &= ~(MII_DM9161_INTR_STOP);
|
||||
else
|
||||
err = phy_write(phydev, MII_DM9161_INTR, temp);
|
||||
} else {
|
||||
temp |= MII_DM9161_INTR_STOP;
|
||||
err = phy_write(phydev, MII_DM9161_INTR, temp);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
temp = phy_write(phydev, MII_DM9161_INTR, temp);
|
||||
err = dm9161_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return temp;
|
||||
return err;
|
||||
}
|
||||
|
||||
static irqreturn_t dm9161_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status;
|
||||
|
||||
irq_status = phy_read(phydev, MII_DM9161_INTR);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (!(irq_status & MII_DM9161_INTR_CHANGE))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int dm9161_config_aneg(struct phy_device *phydev)
|
||||
|
|
@ -132,13 +170,6 @@ static int dm9161_config_init(struct phy_device *phydev)
|
|||
return phy_write(phydev, MII_BMCR, BMCR_ANENABLE);
|
||||
}
|
||||
|
||||
static int dm9161_ack_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int err = phy_read(phydev, MII_DM9161_INTR);
|
||||
|
||||
return (err < 0) ? err : 0;
|
||||
}
|
||||
|
||||
static struct phy_driver dm91xx_driver[] = {
|
||||
{
|
||||
.phy_id = 0x0181b880,
|
||||
|
|
@ -147,8 +178,8 @@ static struct phy_driver dm91xx_driver[] = {
|
|||
/* PHY_BASIC_FEATURES */
|
||||
.config_init = dm9161_config_init,
|
||||
.config_aneg = dm9161_config_aneg,
|
||||
.ack_interrupt = dm9161_ack_interrupt,
|
||||
.config_intr = dm9161_config_intr,
|
||||
.handle_interrupt = dm9161_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = 0x0181b8b0,
|
||||
.name = "Davicom DM9161B/C",
|
||||
|
|
@ -156,8 +187,8 @@ static struct phy_driver dm91xx_driver[] = {
|
|||
/* PHY_BASIC_FEATURES */
|
||||
.config_init = dm9161_config_init,
|
||||
.config_aneg = dm9161_config_aneg,
|
||||
.ack_interrupt = dm9161_ack_interrupt,
|
||||
.config_intr = dm9161_config_intr,
|
||||
.handle_interrupt = dm9161_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = 0x0181b8a0,
|
||||
.name = "Davicom DM9161A",
|
||||
|
|
@ -165,15 +196,15 @@ static struct phy_driver dm91xx_driver[] = {
|
|||
/* PHY_BASIC_FEATURES */
|
||||
.config_init = dm9161_config_init,
|
||||
.config_aneg = dm9161_config_aneg,
|
||||
.ack_interrupt = dm9161_ack_interrupt,
|
||||
.config_intr = dm9161_config_intr,
|
||||
.handle_interrupt = dm9161_handle_interrupt,
|
||||
}, {
|
||||
.phy_id = 0x00181b80,
|
||||
.name = "Davicom DM9131",
|
||||
.phy_id_mask = 0x0ffffff0,
|
||||
/* PHY_BASIC_FEATURES */
|
||||
.ack_interrupt = dm9161_ack_interrupt,
|
||||
.config_intr = dm9161_config_intr,
|
||||
.handle_interrupt = dm9161_handle_interrupt,
|
||||
} };
|
||||
|
||||
module_phy_driver(dm91xx_driver);
|
||||
|
|
|
|||
|
|
@ -1498,7 +1498,7 @@ static irqreturn_t vsc8584_handle_interrupt(struct phy_device *phydev)
|
|||
vsc8584_handle_macsec_interrupt(phydev);
|
||||
|
||||
if (irq_status & MII_VSC85XX_INT_MASK_LINK_CHG)
|
||||
phy_mac_interrupt(phydev);
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
|
@ -1541,16 +1541,6 @@ static int vsc85xx_config_init(struct phy_device *phydev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int vsc8584_did_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int rc = 0;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
rc = phy_read(phydev, MII_VSC85XX_INT_STATUS);
|
||||
|
||||
return (rc < 0) ? 0 : rc & MII_VSC85XX_INT_MASK_MASK;
|
||||
}
|
||||
|
||||
static int vsc8514_config_pre_init(struct phy_device *phydev)
|
||||
{
|
||||
/* These are the settings to override the silicon default
|
||||
|
|
@ -1933,6 +1923,10 @@ static int vsc85xx_config_intr(struct phy_device *phydev)
|
|||
int rc;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
rc = vsc85xx_ack_interrupt(phydev);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
vsc8584_config_macsec_intr(phydev);
|
||||
vsc8584_config_ts_intr(phydev);
|
||||
|
||||
|
|
@ -1943,11 +1937,33 @@ static int vsc85xx_config_intr(struct phy_device *phydev)
|
|||
if (rc < 0)
|
||||
return rc;
|
||||
rc = phy_read(phydev, MII_VSC85XX_INT_STATUS);
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
|
||||
rc = vsc85xx_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
static irqreturn_t vsc85xx_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status;
|
||||
|
||||
irq_status = phy_read(phydev, MII_VSC85XX_INT_STATUS);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (!(irq_status & MII_VSC85XX_INT_MASK_MASK))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int vsc85xx_config_aneg(struct phy_device *phydev)
|
||||
{
|
||||
int rc;
|
||||
|
|
@ -2114,7 +2130,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc85xx_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
|
|
@ -2139,9 +2155,8 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.aneg_done = &genphy_aneg_done,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8574_probe,
|
||||
|
|
@ -2163,7 +2178,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc8514_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
|
|
@ -2187,7 +2202,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc85xx_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
|
|
@ -2211,7 +2226,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc85xx_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
|
|
@ -2235,7 +2250,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc85xx_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
|
|
@ -2259,7 +2274,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc85xx_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
|
|
@ -2283,9 +2298,8 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc8584_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8574_probe,
|
||||
|
|
@ -2308,9 +2322,8 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_init = &vsc8584_config_init,
|
||||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8584_probe,
|
||||
|
|
@ -2333,9 +2346,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.aneg_done = &genphy_aneg_done,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.handle_interrupt = &vsc8584_handle_interrupt,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8574_probe,
|
||||
|
|
@ -2359,9 +2370,8 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.config_aneg = &vsc85xx_config_aneg,
|
||||
.aneg_done = &genphy_aneg_done,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.handle_interrupt = vsc85xx_handle_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8574_probe,
|
||||
|
|
@ -2386,9 +2396,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.aneg_done = &genphy_aneg_done,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.handle_interrupt = &vsc8584_handle_interrupt,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8584_probe,
|
||||
|
|
@ -2411,9 +2419,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.aneg_done = &genphy_aneg_done,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.handle_interrupt = &vsc8584_handle_interrupt,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8584_probe,
|
||||
|
|
@ -2436,9 +2442,7 @@ static struct phy_driver vsc85xx_driver[] = {
|
|||
.aneg_done = &genphy_aneg_done,
|
||||
.read_status = &vsc85xx_read_status,
|
||||
.handle_interrupt = &vsc8584_handle_interrupt,
|
||||
.ack_interrupt = &vsc85xx_ack_interrupt,
|
||||
.config_intr = &vsc85xx_config_intr,
|
||||
.did_interrupt = &vsc8584_did_interrupt,
|
||||
.suspend = &genphy_suspend,
|
||||
.resume = &genphy_resume,
|
||||
.probe = &vsc8584_probe,
|
||||
|
|
|
|||
|
|
@ -493,10 +493,11 @@ EXPORT_SYMBOL(phy_queue_state_machine);
|
|||
*
|
||||
* @phydev: the phy_device struct
|
||||
*/
|
||||
static void phy_trigger_machine(struct phy_device *phydev)
|
||||
void phy_trigger_machine(struct phy_device *phydev)
|
||||
{
|
||||
phy_queue_state_machine(phydev, 0);
|
||||
}
|
||||
EXPORT_SYMBOL(phy_trigger_machine);
|
||||
|
||||
static void phy_abort_cable_test(struct phy_device *phydev)
|
||||
{
|
||||
|
|
@ -924,7 +925,7 @@ void phy_stop_machine(struct phy_device *phydev)
|
|||
* Must not be called from interrupt context, or while the
|
||||
* phydev->lock is held.
|
||||
*/
|
||||
static void phy_error(struct phy_device *phydev)
|
||||
void phy_error(struct phy_device *phydev)
|
||||
{
|
||||
WARN_ON(1);
|
||||
|
||||
|
|
@ -934,6 +935,7 @@ static void phy_error(struct phy_device *phydev)
|
|||
|
||||
phy_trigger_machine(phydev);
|
||||
}
|
||||
EXPORT_SYMBOL(phy_error);
|
||||
|
||||
/**
|
||||
* phy_disable_interrupts - Disable the PHY interrupts from the PHY side
|
||||
|
|
|
|||
|
|
@ -2463,6 +2463,19 @@ int genphy_soft_reset(struct phy_device *phydev)
|
|||
}
|
||||
EXPORT_SYMBOL(genphy_soft_reset);
|
||||
|
||||
irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev)
|
||||
{
|
||||
/* It seems there are cases where the interrupts are handled by another
|
||||
* entity (ie an IRQ controller embedded inside the PHY) and do not
|
||||
* need any other interraction from phylib. In this case, just trigger
|
||||
* the state machine directly.
|
||||
*/
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL(genphy_handle_interrupt_no_ack);
|
||||
|
||||
/**
|
||||
* genphy_read_abilities - read PHY abilities from Clause 22 registers
|
||||
* @phydev: target phy_device struct
|
||||
|
|
@ -2815,7 +2828,7 @@ EXPORT_SYMBOL(phy_get_internal_delay);
|
|||
|
||||
static bool phy_drv_supports_irq(struct phy_driver *phydrv)
|
||||
{
|
||||
return phydrv->config_intr && phydrv->ack_interrupt;
|
||||
return phydrv->config_intr && (phydrv->ack_interrupt || phydrv->handle_interrupt);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -2947,6 +2960,13 @@ static int phy_remove(struct device *dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void phy_shutdown(struct device *dev)
|
||||
{
|
||||
struct phy_device *phydev = to_phy_device(dev);
|
||||
|
||||
phy_disable_interrupts(phydev);
|
||||
}
|
||||
|
||||
/**
|
||||
* phy_driver_register - register a phy_driver with the PHY layer
|
||||
* @new_driver: new phy_driver to register
|
||||
|
|
@ -2970,6 +2990,7 @@ int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
|
|||
new_driver->mdiodrv.driver.bus = &mdio_bus_type;
|
||||
new_driver->mdiodrv.driver.probe = phy_probe;
|
||||
new_driver->mdiodrv.driver.remove = phy_remove;
|
||||
new_driver->mdiodrv.driver.shutdown = phy_shutdown;
|
||||
new_driver->mdiodrv.driver.owner = owner;
|
||||
new_driver->mdiodrv.driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
|
||||
|
||||
|
|
|
|||
|
|
@ -41,6 +41,12 @@
|
|||
#define RTL8211E_RX_DELAY BIT(11)
|
||||
|
||||
#define RTL8201F_ISR 0x1e
|
||||
#define RTL8201F_ISR_ANERR BIT(15)
|
||||
#define RTL8201F_ISR_DUPLEX BIT(13)
|
||||
#define RTL8201F_ISR_LINK BIT(11)
|
||||
#define RTL8201F_ISR_MASK (RTL8201F_ISR_ANERR | \
|
||||
RTL8201F_ISR_DUPLEX | \
|
||||
RTL8201F_ISR_LINK)
|
||||
#define RTL8201F_IER 0x13
|
||||
|
||||
#define RTL8366RB_POWER_SAVE 0x15
|
||||
|
|
@ -102,24 +108,45 @@ static int rtl8211f_ack_interrupt(struct phy_device *phydev)
|
|||
static int rtl8201_config_intr(struct phy_device *phydev)
|
||||
{
|
||||
u16 val;
|
||||
int err;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = rtl8201_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
val = BIT(13) | BIT(12) | BIT(11);
|
||||
else
|
||||
err = phy_write_paged(phydev, 0x7, RTL8201F_IER, val);
|
||||
} else {
|
||||
val = 0;
|
||||
err = phy_write_paged(phydev, 0x7, RTL8201F_IER, val);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return phy_write_paged(phydev, 0x7, RTL8201F_IER, val);
|
||||
err = rtl8201_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int rtl8211b_config_intr(struct phy_device *phydev)
|
||||
{
|
||||
int err;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = rtl821x_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = phy_write(phydev, RTL821x_INER,
|
||||
RTL8211B_INER_INIT);
|
||||
else
|
||||
} else {
|
||||
err = phy_write(phydev, RTL821x_INER, 0);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = rtl821x_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -128,11 +155,20 @@ static int rtl8211e_config_intr(struct phy_device *phydev)
|
|||
{
|
||||
int err;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = rtl821x_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = phy_write(phydev, RTL821x_INER,
|
||||
RTL8211E_INER_LINK_STATUS);
|
||||
else
|
||||
} else {
|
||||
err = phy_write(phydev, RTL821x_INER, 0);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = rtl821x_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -140,13 +176,85 @@ static int rtl8211e_config_intr(struct phy_device *phydev)
|
|||
static int rtl8211f_config_intr(struct phy_device *phydev)
|
||||
{
|
||||
u16 val;
|
||||
int err;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED) {
|
||||
err = rtl8211f_ack_interrupt(phydev);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (phydev->interrupts == PHY_INTERRUPT_ENABLED)
|
||||
val = RTL8211F_INER_LINK_STATUS;
|
||||
else
|
||||
err = phy_write_paged(phydev, 0xa42, RTL821x_INER, val);
|
||||
} else {
|
||||
val = 0;
|
||||
err = phy_write_paged(phydev, 0xa42, RTL821x_INER, val);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return phy_write_paged(phydev, 0xa42, RTL821x_INER, val);
|
||||
err = rtl8211f_ack_interrupt(phydev);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static irqreturn_t rtl8201_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status;
|
||||
|
||||
irq_status = phy_read(phydev, RTL8201F_ISR);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (!(irq_status & RTL8201F_ISR_MASK))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static irqreturn_t rtl821x_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status, irq_enabled;
|
||||
|
||||
irq_status = phy_read(phydev, RTL821x_INSR);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
irq_enabled = phy_read(phydev, RTL821x_INER);
|
||||
if (irq_enabled < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (!(irq_status & irq_enabled))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static irqreturn_t rtl8211f_handle_interrupt(struct phy_device *phydev)
|
||||
{
|
||||
int irq_status;
|
||||
|
||||
irq_status = phy_read_paged(phydev, 0xa43, RTL8211F_INSR);
|
||||
if (irq_status < 0) {
|
||||
phy_error(phydev);
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
if (!(irq_status & RTL8211F_INER_LINK_STATUS))
|
||||
return IRQ_NONE;
|
||||
|
||||
phy_trigger_machine(phydev);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int rtl8211_config_aneg(struct phy_device *phydev)
|
||||
|
|
@ -554,8 +662,8 @@ static struct phy_driver realtek_drvs[] = {
|
|||
}, {
|
||||
PHY_ID_MATCH_EXACT(0x001cc816),
|
||||
.name = "RTL8201F Fast Ethernet",
|
||||
.ack_interrupt = &rtl8201_ack_interrupt,
|
||||
.config_intr = &rtl8201_config_intr,
|
||||
.handle_interrupt = rtl8201_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = genphy_resume,
|
||||
.read_page = rtl821x_read_page,
|
||||
|
|
@ -580,8 +688,8 @@ static struct phy_driver realtek_drvs[] = {
|
|||
}, {
|
||||
PHY_ID_MATCH_EXACT(0x001cc912),
|
||||
.name = "RTL8211B Gigabit Ethernet",
|
||||
.ack_interrupt = &rtl821x_ack_interrupt,
|
||||
.config_intr = &rtl8211b_config_intr,
|
||||
.handle_interrupt = rtl821x_handle_interrupt,
|
||||
.read_mmd = &genphy_read_mmd_unsupported,
|
||||
.write_mmd = &genphy_write_mmd_unsupported,
|
||||
.suspend = rtl8211b_suspend,
|
||||
|
|
@ -599,8 +707,8 @@ static struct phy_driver realtek_drvs[] = {
|
|||
}, {
|
||||
PHY_ID_MATCH_EXACT(0x001cc914),
|
||||
.name = "RTL8211DN Gigabit Ethernet",
|
||||
.ack_interrupt = rtl821x_ack_interrupt,
|
||||
.config_intr = rtl8211e_config_intr,
|
||||
.handle_interrupt = rtl821x_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = genphy_resume,
|
||||
.read_page = rtl821x_read_page,
|
||||
|
|
@ -609,8 +717,8 @@ static struct phy_driver realtek_drvs[] = {
|
|||
PHY_ID_MATCH_EXACT(0x001cc915),
|
||||
.name = "RTL8211E Gigabit Ethernet",
|
||||
.config_init = &rtl8211e_config_init,
|
||||
.ack_interrupt = &rtl821x_ack_interrupt,
|
||||
.config_intr = &rtl8211e_config_intr,
|
||||
.handle_interrupt = rtl821x_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = genphy_resume,
|
||||
.read_page = rtl821x_read_page,
|
||||
|
|
@ -619,8 +727,8 @@ static struct phy_driver realtek_drvs[] = {
|
|||
PHY_ID_MATCH_EXACT(0x001cc916),
|
||||
.name = "RTL8211F Gigabit Ethernet",
|
||||
.config_init = &rtl8211f_config_init,
|
||||
.ack_interrupt = &rtl8211f_ack_interrupt,
|
||||
.config_intr = &rtl8211f_config_intr,
|
||||
.handle_interrupt = rtl8211f_handle_interrupt,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = genphy_resume,
|
||||
.read_page = rtl821x_read_page,
|
||||
|
|
@ -708,8 +816,8 @@ static struct phy_driver realtek_drvs[] = {
|
|||
* irq is requested and ACKed by reading the status register,
|
||||
* which is done by the irqchip code.
|
||||
*/
|
||||
.ack_interrupt = genphy_no_ack_interrupt,
|
||||
.config_intr = genphy_no_config_intr,
|
||||
.handle_interrupt = genphy_handle_interrupt_no_ack,
|
||||
.suspend = genphy_suspend,
|
||||
.resume = genphy_resume,
|
||||
},
|
||||
|
|
|
|||
|
|
@ -1510,6 +1510,7 @@ int genphy_suspend(struct phy_device *phydev);
|
|||
int genphy_resume(struct phy_device *phydev);
|
||||
int genphy_loopback(struct phy_device *phydev, bool enable);
|
||||
int genphy_soft_reset(struct phy_device *phydev);
|
||||
irqreturn_t genphy_handle_interrupt_no_ack(struct phy_device *phydev);
|
||||
|
||||
static inline int genphy_config_aneg(struct phy_device *phydev)
|
||||
{
|
||||
|
|
@ -1570,8 +1571,10 @@ void phy_drivers_unregister(struct phy_driver *drv, int n);
|
|||
int phy_driver_register(struct phy_driver *new_driver, struct module *owner);
|
||||
int phy_drivers_register(struct phy_driver *new_driver, int n,
|
||||
struct module *owner);
|
||||
void phy_error(struct phy_device *phydev);
|
||||
void phy_state_machine(struct work_struct *work);
|
||||
void phy_queue_state_machine(struct phy_device *phydev, unsigned long jiffies);
|
||||
void phy_trigger_machine(struct phy_device *phydev);
|
||||
void phy_mac_interrupt(struct phy_device *phydev);
|
||||
void phy_start_machine(struct phy_device *phydev);
|
||||
void phy_stop_machine(struct phy_device *phydev);
|
||||
|
|
|
|||
Loading…
Reference in New Issue