Skip to content

L
linux
Commit 1210db95 authored by Alan Cox's avatar Alan Cox Committed by Greg Kroah-Hartman
Browse files
Options

Staging: et131x: phy clean up 

Clean up the phy code a bit so we can see what needs doing. This involves
moving blocks around and making stuff static
Signed-off-by: default avatarAlan Cox <alan@linux.intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 57aed3b4
Show whitespace changes
Inline Side-by-side
Showing with 582 additions and 606 deletions
drivers/staging/et131x/et1310_phy.c
View file @ 1210db95
...@@ -109,12 +109,12 @@ static int et131x_xcvr_init(struct et131x_adapter *adapter); ...@@ -109,12 +109,12 @@ static int et131x_xcvr_init(struct et131x_adapter *adapter);
* *
* Returns 0 on success, errno on failure (as defined in errno.h) * Returns 0 on success, errno on failure (as defined in errno.h)
*/ */
int PhyMiRead(struct et131x_adapter *adapter, uint8_t xcvrAddr, int PhyMiRead(struct et131x_adapter *adapter, u8 xcvrAddr,
uint8_t xcvrReg, uint16_t *value) u8 xcvrReg, u16 *value)
{ {
struct _MAC_t __iomem *mac = &adapter->regs->mac; struct _MAC_t __iomem *mac = &adapter->regs->mac;
int status = 0; int status = 0;
uint32_t delay; u32 delay;
u32 miiAddr; u32 miiAddr;
u32 miiCmd; u32 miiCmd;
u32 miiIndicator; u32 miiIndicator;
...@@ -174,14 +174,16 @@ int PhyMiRead(struct et131x_adapter *adapter, uint8_t xcvrAddr, ...@@ -174,14 +174,16 @@ int PhyMiRead(struct et131x_adapter *adapter, uint8_t xcvrAddr,
* @xcvrReg: the register to read * @xcvrReg: the register to read
* @value: 16-bit value to write * @value: 16-bit value to write
* *
* FIXME: one caller in netdev still
*
* Return 0 on success, errno on failure (as defined in errno.h) * Return 0 on success, errno on failure (as defined in errno.h)
*/ */
int MiWrite(struct et131x_adapter *adapter, uint8_t xcvrReg, uint16_t value) int MiWrite(struct et131x_adapter *adapter, u8 xcvrReg, u16 value)
{ {
struct _MAC_t __iomem *mac = &adapter->regs->mac; struct _MAC_t __iomem *mac = &adapter->regs->mac;
int status = 0; int status = 0;
uint8_t xcvrAddr = adapter->Stats.xcvr_addr; u8 xcvrAddr = adapter->Stats.xcvr_addr;
uint32_t delay; u32 delay;
u32 miiAddr; u32 miiAddr;
u32 miiCmd; u32 miiCmd;
u32 miiIndicator; u32 miiIndicator;
...@@ -210,7 +212,7 @@ int MiWrite(struct et131x_adapter *adapter, uint8_t xcvrReg, uint16_t value) ...@@ -210,7 +212,7 @@ int MiWrite(struct et131x_adapter *adapter, uint8_t xcvrReg, uint16_t value)
/* If we hit the max delay, we could not write the register */ /* If we hit the max delay, we could not write the register */
if (delay == 100) { if (delay == 100) {
uint16_t TempValue; u16 TempValue;
dev_warn(&adapter->pdev->dev, dev_warn(&adapter->pdev->dev,
"xcvrReg 0x%08x could not be written", xcvrReg); "xcvrReg 0x%08x could not be written", xcvrReg);
...@@ -244,22 +246,22 @@ int MiWrite(struct et131x_adapter *adapter, uint8_t xcvrReg, uint16_t value) ...@@ -244,22 +246,22 @@ int MiWrite(struct et131x_adapter *adapter, uint8_t xcvrReg, uint16_t value)
int et131x_xcvr_find(struct et131x_adapter *adapter) int et131x_xcvr_find(struct et131x_adapter *adapter)
{ {
int status = -ENODEV; int status = -ENODEV;
uint8_t xcvr_addr; u8 xcvr_addr;
MI_IDR1_t idr1; MI_IDR1_t idr1;
MI_IDR2_t idr2; MI_IDR2_t idr2;
uint32_t xcvr_id; u32 xcvr_id;
/* We need to get xcvr id and address we just get the first one */ /* We need to get xcvr id and address we just get the first one */
for (xcvr_addr = 0; xcvr_addr < 32; xcvr_addr++) { for (xcvr_addr = 0; xcvr_addr < 32; xcvr_addr++) {
/* Read the ID from the PHY */ /* Read the ID from the PHY */
PhyMiRead(adapter, xcvr_addr, PhyMiRead(adapter, xcvr_addr,
(uint8_t) offsetof(MI_REGS_t, idr1), (u8) offsetof(MI_REGS_t, idr1),
&idr1.value); &idr1.value);
PhyMiRead(adapter, xcvr_addr, PhyMiRead(adapter, xcvr_addr,
(uint8_t) offsetof(MI_REGS_t, idr2), (u8) offsetof(MI_REGS_t, idr2),
&idr2.value); &idr2.value);
xcvr_id = (uint32_t) ((idr1.value << 16) | idr2.value); xcvr_id = (u32) ((idr1.value << 16) | idr2.value);
if ((idr1.value != 0) && (idr1.value != 0xffff)) { if ((idr1.value != 0) && (idr1.value != 0xffff)) {
adapter->Stats.xcvr_id = xcvr_id; adapter->Stats.xcvr_id = xcvr_id;
...@@ -290,279 +292,317 @@ int et131x_setphy_normal(struct et131x_adapter *adapter) ...@@ -290,279 +292,317 @@ int et131x_setphy_normal(struct et131x_adapter *adapter)
return status; return status;
} }
/** void ET1310_PhyReset(struct et131x_adapter *etdev)
* et131x_xcvr_init - Init the phy if we are setting it into force mode
* @adapter: pointer to our private adapter structure
*
* Returns 0 on success, errno on failure (as defined in errno.h)
*/
static int et131x_xcvr_init(struct et131x_adapter *adapter)
{ {
int status = 0; MiWrite(etdev, PHY_CONTROL, 0x8000);
MI_IMR_t imr; }
MI_ISR_t isr;
MI_LCR2_t lcr2;
/* Zero out the adapter structure variable representing BMSR */
adapter->Bmsr.value = 0;
MiRead(adapter, (uint8_t) offsetof(MI_REGS_t, isr), &isr.value);
MiRead(adapter, (uint8_t) offsetof(MI_REGS_t, imr), &imr.value);
/* Set the link status interrupt only. Bad behavior when link status
* and auto neg are set, we run into a nested interrupt problem
*/
imr.bits.int_en = 0x1;
imr.bits.link_status = 0x1;
imr.bits.autoneg_status = 0x1;
MiWrite(adapter, (uint8_t) offsetof(MI_REGS_t, imr), imr.value); void ET1310_PhyPowerDown(struct et131x_adapter *etdev, bool down)
{
u16 data;
/* Set the LED behavior such that LED 1 indicates speed (off = MiRead(etdev, PHY_CONTROL, &data);
* 10Mbits, blink = 100Mbits, on = 1000Mbits) and LED 2 indicates
* link and activity (on for link, blink off for activity).
*
* NOTE: Some customizations have been added here for specific
* vendors; The LED behavior is now determined by vendor data in the
* EEPROM. However, the above description is the default.
*/
if ((adapter->eepromData[1] & 0x4) == 0) {
MiRead(adapter, (uint8_t) offsetof(MI_REGS_t, lcr2),
&lcr2.value);
if ((adapter->eepromData[1] & 0x8) == 0)
lcr2.bits.led_tx_rx = 0x3;
else
lcr2.bits.led_tx_rx = 0x4;
lcr2.bits.led_link = 0xa;
MiWrite(adapter, (uint8_t) offsetof(MI_REGS_t, lcr2),
lcr2.value);
}
/* Determine if we need to go into a force mode and set it */ if (down == false) {
if (adapter->AiForceSpeed == 0 && adapter->AiForceDpx == 0) { /* Power UP */
if ((adapter->RegistryFlowControl == TxOnly) || data &= ~0x0800;
(adapter->RegistryFlowControl == Both)) { MiWrite(etdev, PHY_CONTROL, data);
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_SET, 4, 11, NULL);
} else { } else {
ET1310_PhyAccessMiBit(adapter, /* Power DOWN */
TRUEPHY_BIT_CLEAR, 4, 11, NULL); data |= 0x0800;
MiWrite(etdev, PHY_CONTROL, data);
} }
}
if (adapter->RegistryFlowControl == Both) { static void ET1310_PhyAutoNeg(struct et131x_adapter *etdev, bool enable)
ET1310_PhyAccessMiBit(adapter, {
TRUEPHY_BIT_SET, 4, 10, NULL); u16 data;
MiRead(etdev, PHY_CONTROL, &data);
if (enable == true) {
/* Autonegotiation ON */
data |= 0x1000;
MiWrite(etdev, PHY_CONTROL, data);
} else { } else {
ET1310_PhyAccessMiBit(adapter, /* Autonegotiation OFF */
TRUEPHY_BIT_CLEAR, 4, 10, NULL); data &= ~0x1000;
MiWrite(etdev, PHY_CONTROL, data);
} }
}
/* Set the phy to autonegotiation */ static void ET1310_PhyDuplexMode(struct et131x_adapter *etdev, u16 duplex)
ET1310_PhyAutoNeg(adapter, true); {
u16 data;
/* NOTE - Do we need this? */ MiRead(etdev, PHY_CONTROL, &data);
ET1310_PhyAccessMiBit(adapter, TRUEPHY_BIT_SET, 0, 9, NULL);
return status;
} else {
ET1310_PhyAutoNeg(adapter, false);
/* Set to the correct force mode. */ if (duplex == TRUEPHY_DUPLEX_FULL) {
if (adapter->AiForceDpx != 1) { /* Set Full Duplex */
if ((adapter->RegistryFlowControl == TxOnly) || data |= 0x100;
(adapter->RegistryFlowControl == Both)) { MiWrite(etdev, PHY_CONTROL, data);
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_SET, 4, 11,
NULL);
} else { } else {
ET1310_PhyAccessMiBit(adapter, /* Set Half Duplex */
TRUEPHY_BIT_CLEAR, 4, 11, data &= ~0x100;
NULL); MiWrite(etdev, PHY_CONTROL, data);
} }
}
if (adapter->RegistryFlowControl == Both) { static void ET1310_PhySpeedSelect(struct et131x_adapter *etdev, u16 speed)
ET1310_PhyAccessMiBit(adapter, {
TRUEPHY_BIT_SET, 4, 10, u16 data;
NULL);
} else {
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_CLEAR, 4, 10,
NULL);
}
} else {
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_CLEAR, 4, 10, NULL);
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_CLEAR, 4, 11, NULL);
}
switch (adapter->AiForceSpeed) { /* Read the PHY control register */
case 10: MiRead(etdev, PHY_CONTROL, &data);
if (adapter->AiForceDpx == 1)
TPAL_SetPhy10HalfDuplex(adapter); /* Clear all Speed settings (Bits 6, 13) */
else if (adapter->AiForceDpx == 2) data &= ~0x2040;
TPAL_SetPhy10FullDuplex(adapter);
else /* Reset the speed bits based on user selection */
TPAL_SetPhy10Force(adapter); switch (speed) {
case TRUEPHY_SPEED_10MBPS:
/* Bits already cleared above, do nothing */
break; break;
case 100:
if (adapter->AiForceDpx == 1) case TRUEPHY_SPEED_100MBPS:
TPAL_SetPhy100HalfDuplex(adapter); /* 100M == Set bit 13 */
else if (adapter->AiForceDpx == 2) data |= 0x2000;
TPAL_SetPhy100FullDuplex(adapter);
else
TPAL_SetPhy100Force(adapter);
break; break;
case 1000:
TPAL_SetPhy1000FullDuplex(adapter); case TRUEPHY_SPEED_1000MBPS:
default:
data |= 0x0040;
break; break;
} }
return status; /* Write back the new speed */
} MiWrite(etdev, PHY_CONTROL, data);
} }
void et131x_Mii_check(struct et131x_adapter *etdev, static void ET1310_PhyLinkStatus(struct et131x_adapter *etdev,
MI_BMSR_t bmsr, MI_BMSR_t bmsr_ints) u8 *link_status,
u32 *autoneg,
u32 *linkspeed,
u32 *duplex_mode,
u32 *mdi_mdix,
u32 *masterslave, u32 *polarity)
{ {
uint8_t link_status; u16 mistatus = 0;
uint32_t autoneg_status; u16 is1000BaseT = 0;
uint32_t speed; u16 vmi_phystatus = 0;
uint32_t duplex; u16 control = 0;
uint32_t mdi_mdix;
uint32_t masterslave;
uint32_t polarity;
unsigned long flags;
if (bmsr_ints.bits.link_status) { MiRead(etdev, PHY_STATUS, &mistatus);
if (bmsr.bits.link_status) { MiRead(etdev, PHY_1000_STATUS, &is1000BaseT);
etdev->PoMgmt.TransPhyComaModeOnBoot = 20; MiRead(etdev, PHY_PHY_STATUS, &vmi_phystatus);
MiRead(etdev, PHY_CONTROL, &control);
/* Update our state variables and indicate the if (link_status) {
* connected state *link_status =
*/ (unsigned char)((vmi_phystatus & 0x0040) ? 1 : 0);
spin_lock_irqsave(&etdev->Lock, flags); }
etdev->MediaState = NETIF_STATUS_MEDIA_CONNECT; if (autoneg) {
etdev->Flags &= ~fMP_ADAPTER_LINK_DETECTION; *autoneg =
(control & 0x1000) ? ((vmi_phystatus & 0x0020) ?
TRUEPHY_ANEG_COMPLETE :
TRUEPHY_ANEG_NOT_COMPLETE) :
TRUEPHY_ANEG_DISABLED;
}
spin_unlock_irqrestore(&etdev->Lock, flags); if (linkspeed)
*linkspeed = (vmi_phystatus & 0x0300) >> 8;
netif_carrier_on(etdev->netdev); if (duplex_mode)
} else { *duplex_mode = (vmi_phystatus & 0x0080) >> 7;
dev_warn(&etdev->pdev->dev,
"Link down - cable problem ?\n");
if (etdev->linkspeed == TRUEPHY_SPEED_10MBPS) { if (mdi_mdix)
/* NOTE - Is there a way to query this without /* NOTE: Need to complete this */
* TruePHY? *mdi_mdix = 0;
* && TRU_QueryCoreType(etdev->hTruePhy, 0) == EMI_TRUEPHY_A13O) {
*/
uint16_t Register18;
MiRead(etdev, 0x12, &Register18); if (masterslave) {
MiWrite(etdev, 0x12, Register18 | 0x4); *masterslave =
MiWrite(etdev, 0x10, Register18 | 0x8402); (is1000BaseT & 0x4000) ? TRUEPHY_CFG_MASTER :
MiWrite(etdev, 0x11, Register18 | 511); TRUEPHY_CFG_SLAVE;
MiWrite(etdev, 0x12, Register18);
} }
/* For the first N seconds of life, we are in "link if (polarity) {
* detection" When we are in this state, we should *polarity =
* only report "connected". When the LinkDetection (vmi_phystatus & 0x0400) ? TRUEPHY_POLARITY_INVERTED :
* Timer expires, we can report disconnected (handled TRUEPHY_POLARITY_NORMAL;
* in the LinkDetectionDPC).
*/
if (!(etdev->Flags & fMP_ADAPTER_LINK_DETECTION) ||
(etdev->MediaState == NETIF_STATUS_MEDIA_DISCONNECT)) {
spin_lock_irqsave(&etdev->Lock, flags);
etdev->MediaState =
NETIF_STATUS_MEDIA_DISCONNECT;
spin_unlock_irqrestore(&etdev->Lock,
flags);
netif_carrier_off(etdev->netdev);
} }
}
etdev->linkspeed = 0; static void ET1310_PhyAndOrReg(struct et131x_adapter *etdev,
etdev->duplex_mode = 0; u16 regnum, u16 andMask, u16 orMask)
{
u16 reg;
/* Free the packets being actively sent & stopped */ /* Read the requested register */
et131x_free_busy_send_packets(etdev); MiRead(etdev, regnum, &reg);
/* Re-initialize the send structures */ /* Apply the AND mask */
et131x_init_send(etdev); reg &= andMask;
/* Reset the RFD list and re-start RU */ /* Apply the OR mask */
et131x_reset_recv(etdev); reg |= orMask;
/* /* Write the value back to the register */
* Bring the device back to the state it was during MiWrite(etdev, regnum, reg);
* init prior to autonegotiation being complete. This }
* way, when we get the auto-neg complete interrupt,
* we can complete init by calling ConfigMacREGS2.
*/
et131x_soft_reset(etdev);
/* Setup ET1310 as per the documentation */ /* Still used from _mac */
et131x_adapter_setup(etdev); void ET1310_PhyAccessMiBit(struct et131x_adapter *etdev, u16 action,
u16 regnum, u16 bitnum, u8 *value)
{
u16 reg;
u16 mask = 0;
/* Setup the PHY into coma mode until the cable is /* Create a mask to isolate the requested bit */
* plugged back in mask = 0x0001 << bitnum;
*/
if (etdev->RegistryPhyComa == 1) /* Read the requested register */
EnablePhyComa(etdev); MiRead(etdev, regnum, &reg);
}
switch (action) {
case TRUEPHY_BIT_READ:
if (value != NULL)
*value = (reg & mask) >> bitnum;
break;
case TRUEPHY_BIT_SET:
reg |= mask;
MiWrite(etdev, regnum, reg);
break;
case TRUEPHY_BIT_CLEAR:
reg &= ~mask;
MiWrite(etdev, regnum, reg);
break;
default:
break;
} }
}
if (bmsr_ints.bits.auto_neg_complete || void ET1310_PhyAdvertise1000BaseT(struct et131x_adapter *etdev,
(etdev->AiForceDpx == 3 && bmsr_ints.bits.link_status)) { u16 duplex)
if (bmsr.bits.auto_neg_complete || etdev->AiForceDpx == 3) { {
ET1310_PhyLinkStatus(etdev, u16 data;
&link_status, &autoneg_status,
&speed, &duplex, &mdi_mdix,
&masterslave, &polarity);
etdev->linkspeed = speed; /* Read the PHY 1000 Base-T Control Register */
etdev->duplex_mode = duplex; MiRead(etdev, PHY_1000_CONTROL, &data);
etdev->PoMgmt.TransPhyComaModeOnBoot = 20; /* Clear Bits 8,9 */
data &= ~0x0300;
if (etdev->linkspeed == TRUEPHY_SPEED_10MBPS) { switch (duplex) {
/* case TRUEPHY_ADV_DUPLEX_NONE:
* NOTE - Is there a way to query this without /* Duplex already cleared, do nothing */
* TruePHY? break;
* && TRU_QueryCoreType(etdev->hTruePhy, 0)== EMI_TRUEPHY_A13O) {
*/
uint16_t Register18;
MiRead(etdev, 0x12, &Register18); case TRUEPHY_ADV_DUPLEX_FULL:
MiWrite(etdev, 0x12, Register18 | 0x4); /* Set Bit 9 */
MiWrite(etdev, 0x10, Register18 | 0x8402); data |= 0x0200;
MiWrite(etdev, 0x11, Register18 | 511); break;
MiWrite(etdev, 0x12, Register18);
case TRUEPHY_ADV_DUPLEX_HALF:
/* Set Bit 8 */
data |= 0x0100;
break;
case TRUEPHY_ADV_DUPLEX_BOTH:
default:
data |= 0x0300;
break;
} }
ConfigFlowControl(etdev); /* Write back advertisement */
MiWrite(etdev, PHY_1000_CONTROL, data);
}
if (etdev->linkspeed == TRUEPHY_SPEED_1000MBPS && static void ET1310_PhyAdvertise100BaseT(struct et131x_adapter *etdev,
etdev->RegistryJumboPacket > 2048) u16 duplex)
ET1310_PhyAndOrReg(etdev, 0x16, 0xcfff, {
0x2000); u16 data;
SetRxDmaTimer(etdev); /* Read the Autonegotiation Register (10/100) */
ConfigMACRegs2(etdev); MiRead(etdev, PHY_AUTO_ADVERTISEMENT, &data);
/* Clear bits 7,8 */
data &= ~0x0180;
switch (duplex) {
case TRUEPHY_ADV_DUPLEX_NONE:
/* Duplex already cleared, do nothing */
break;
case TRUEPHY_ADV_DUPLEX_FULL:
/* Set Bit 8 */
data |= 0x0100;
break;
case TRUEPHY_ADV_DUPLEX_HALF:
/* Set Bit 7 */
data |= 0x0080;
break;
case TRUEPHY_ADV_DUPLEX_BOTH:
default:
/* Set Bits 7,8 */
data |= 0x0180;
break;
} }
/* Write back advertisement */
MiWrite(etdev, PHY_AUTO_ADVERTISEMENT, data);
}
static void ET1310_PhyAdvertise10BaseT(struct et131x_adapter *etdev,
u16 duplex)
{
u16 data;
/* Read the Autonegotiation Register (10/100) */
MiRead(etdev, PHY_AUTO_ADVERTISEMENT, &data);
/* Clear bits 5,6 */
data &= ~0x0060;
switch (duplex) {
case TRUEPHY_ADV_DUPLEX_NONE:
/* Duplex already cleared, do nothing */
break;
case TRUEPHY_ADV_DUPLEX_FULL:
/* Set Bit 6 */
data |= 0x0040;
break;
case TRUEPHY_ADV_DUPLEX_HALF:
/* Set Bit 5 */
data |= 0x0020;
break;
case TRUEPHY_ADV_DUPLEX_BOTH:
default:
/* Set Bits 5,6 */
data |= 0x0060;
break;
} }
/* Write back advertisement */
MiWrite(etdev, PHY_AUTO_ADVERTISEMENT, data);
} }
/** /**
* TPAL_SetPhy10HalfDuplex - Force the phy into 10 Base T Half Duplex mode. * TPAL_SetPhy10HalfDuplex - Force the phy into 10 Base T Half Duplex mode.
* @etdev: pointer to the adapter structure * @etdev: pointer to the adapter structure
* *
* Also sets the MAC so it is syncd up properly * Also sets the MAC so it is syncd up properly
*/ */
void TPAL_SetPhy10HalfDuplex(struct et131x_adapter *etdev) static void TPAL_SetPhy10HalfDuplex(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -585,7 +625,7 @@ void TPAL_SetPhy10HalfDuplex(struct et131x_adapter *etdev) ...@@ -585,7 +625,7 @@ void TPAL_SetPhy10HalfDuplex(struct et131x_adapter *etdev)
* *
* Also sets the MAC so it is syncd up properly * Also sets the MAC so it is syncd up properly
*/ */
void TPAL_SetPhy10FullDuplex(struct et131x_adapter *etdev) static void TPAL_SetPhy10FullDuplex(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -606,7 +646,7 @@ void TPAL_SetPhy10FullDuplex(struct et131x_adapter *etdev) ...@@ -606,7 +646,7 @@ void TPAL_SetPhy10FullDuplex(struct et131x_adapter *etdev)
* TPAL_SetPhy10Force - Force Base-T FD mode WITHOUT using autonegotiation * TPAL_SetPhy10Force - Force Base-T FD mode WITHOUT using autonegotiation
* @etdev: pointer to the adapter structure * @etdev: pointer to the adapter structure
*/ */
void TPAL_SetPhy10Force(struct et131x_adapter *etdev) static void TPAL_SetPhy10Force(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -635,7 +675,7 @@ void TPAL_SetPhy10Force(struct et131x_adapter *etdev) ...@@ -635,7 +675,7 @@ void TPAL_SetPhy10Force(struct et131x_adapter *etdev)
* *
* Also sets the MAC so it is syncd up properly. * Also sets the MAC so it is syncd up properly.
*/ */
void TPAL_SetPhy100HalfDuplex(struct et131x_adapter *etdev) static void TPAL_SetPhy100HalfDuplex(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -661,7 +701,7 @@ void TPAL_SetPhy100HalfDuplex(struct et131x_adapter *etdev) ...@@ -661,7 +701,7 @@ void TPAL_SetPhy100HalfDuplex(struct et131x_adapter *etdev)
* *
* Also sets the MAC so it is syncd up properly * Also sets the MAC so it is syncd up properly
*/ */
void TPAL_SetPhy100FullDuplex(struct et131x_adapter *etdev) static void TPAL_SetPhy100FullDuplex(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -682,7 +722,7 @@ void TPAL_SetPhy100FullDuplex(struct et131x_adapter *etdev) ...@@ -682,7 +722,7 @@ void TPAL_SetPhy100FullDuplex(struct et131x_adapter *etdev)
* TPAL_SetPhy100Force - Force 100 BaseT FD mode WITHOUT using autonegotiation * TPAL_SetPhy100Force - Force 100 BaseT FD mode WITHOUT using autonegotiation
* @etdev: pointer to the adapter structure * @etdev: pointer to the adapter structure
*/ */
void TPAL_SetPhy100Force(struct et131x_adapter *etdev) static void TPAL_SetPhy100Force(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -711,7 +751,7 @@ void TPAL_SetPhy100Force(struct et131x_adapter *etdev) ...@@ -711,7 +751,7 @@ void TPAL_SetPhy100Force(struct et131x_adapter *etdev)
* *
* Also sets the MAC so it is syncd up properly. * Also sets the MAC so it is syncd up properly.
*/ */
void TPAL_SetPhy1000FullDuplex(struct et131x_adapter *etdev) static void TPAL_SetPhy1000FullDuplex(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -732,7 +772,7 @@ void TPAL_SetPhy1000FullDuplex(struct et131x_adapter *etdev) ...@@ -732,7 +772,7 @@ void TPAL_SetPhy1000FullDuplex(struct et131x_adapter *etdev)
* TPAL_SetPhyAutoNeg - Set phy to autonegotiation mode. * TPAL_SetPhyAutoNeg - Set phy to autonegotiation mode.
* @etdev: pointer to the adapter structure * @etdev: pointer to the adapter structure
*/ */
void TPAL_SetPhyAutoNeg(struct et131x_adapter *etdev) static void TPAL_SetPhyAutoNeg(struct et131x_adapter *etdev)
{ {
/* Power down PHY */ /* Power down PHY */
ET1310_PhyPowerDown(etdev, 1); ET1310_PhyPowerDown(etdev, 1);
...@@ -755,418 +795,380 @@ void TPAL_SetPhyAutoNeg(struct et131x_adapter *etdev) ...@@ -755,418 +795,380 @@ void TPAL_SetPhyAutoNeg(struct et131x_adapter *etdev)
} }
/*
* The routines which follow provide low-level access to the PHY, and are used
* primarily by the routines above (although there are a few places elsewhere
* in the driver where this level of access is required).
*/
static const uint16_t ConfigPhy[25][2] = {
/* Reg Value Register */
/* Addr */
{0x880B, 0x0926}, /* AfeIfCreg4B1000Msbs */
{0x880C, 0x0926}, /* AfeIfCreg4B100Msbs */
{0x880D, 0x0926}, /* AfeIfCreg4B10Msbs */
{0x880E, 0xB4D3}, /* AfeIfCreg4B1000Lsbs */ /**
{0x880F, 0xB4D3}, /* AfeIfCreg4B100Lsbs */ * et131x_xcvr_init - Init the phy if we are setting it into force mode
{0x8810, 0xB4D3}, /* AfeIfCreg4B10Lsbs */ * @adapter: pointer to our private adapter structure
*
* Returns 0 on success, errno on failure (as defined in errno.h)
*/
static int et131x_xcvr_init(struct et131x_adapter *adapter)
{
int status = 0;
MI_IMR_t imr;
MI_ISR_t isr;
MI_LCR2_t lcr2;
{0x8805, 0xB03E}, /* AfeIfCreg3B1000Msbs */ /* Zero out the adapter structure variable representing BMSR */
{0x8806, 0xB03E}, /* AfeIfCreg3B100Msbs */ adapter->Bmsr.value = 0;
{0x8807, 0xFF00}, /* AfeIfCreg3B10Msbs */
{0x8808, 0xE090}, /* AfeIfCreg3B1000Lsbs */ MiRead(adapter, (u8) offsetof(MI_REGS_t, isr), &isr.value);
{0x8809, 0xE110}, /* AfeIfCreg3B100Lsbs */
{0x880A, 0x0000}, /* AfeIfCreg3B10Lsbs */
{0x300D, 1}, /* DisableNorm */ MiRead(adapter, (u8) offsetof(MI_REGS_t, imr), &imr.value);
{0x280C, 0x0180}, /* LinkHoldEnd */ /* Set the link status interrupt only. Bad behavior when link status
* and auto neg are set, we run into a nested interrupt problem
*/
imr.bits.int_en = 0x1;
imr.bits.link_status = 0x1;
imr.bits.autoneg_status = 0x1;
{0x1C21, 0x0002}, /* AlphaM */ MiWrite(adapter, (u8) offsetof(MI_REGS_t, imr), imr.value);
{0x3821, 6}, /* FfeLkgTx0 */ /* Set the LED behavior such that LED 1 indicates speed (off =
{0x381D, 1}, /* FfeLkg1g4 */ * 10Mbits, blink = 100Mbits, on = 1000Mbits) and LED 2 indicates
{0x381E, 1}, /* FfeLkg1g5 */ * link and activity (on for link, blink off for activity).
{0x381F, 1}, /* FfeLkg1g6 */ *
{0x3820, 1}, /* FfeLkg1g7 */ * NOTE: Some customizations have been added here for specific
* vendors; The LED behavior is now determined by vendor data in the
* EEPROM. However, the above description is the default.
*/
if ((adapter->eepromData[1] & 0x4) == 0) {
MiRead(adapter, (u8) offsetof(MI_REGS_t, lcr2),
&lcr2.value);
if ((adapter->eepromData[1] & 0x8) == 0)
lcr2.bits.led_tx_rx = 0x3;
else
lcr2.bits.led_tx_rx = 0x4;
lcr2.bits.led_link = 0xa;
MiWrite(adapter, (u8) offsetof(MI_REGS_t, lcr2),
lcr2.value);
}
{0x8402, 0x01F0}, /* Btinact */ /* Determine if we need to go into a force mode and set it */
{0x800E, 20}, /* LftrainTime */ if (adapter->AiForceSpeed == 0 && adapter->AiForceDpx == 0) {
{0x800F, 24}, /* DvguardTime */ if (adapter->RegistryFlowControl == TxOnly ||
{0x8010, 46}, /* IdlguardTime */ adapter->RegistryFlowControl == Both)
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_SET, 4, 11, NULL);
else
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_CLEAR, 4, 11, NULL);
{0, 0} if (adapter->RegistryFlowControl == Both)
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_SET, 4, 10, NULL);
else
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_CLEAR, 4, 10, NULL);
}; /* Set the phy to autonegotiation */
ET1310_PhyAutoNeg(adapter, true);
/* condensed version of the phy initialization routine */ /* NOTE - Do we need this? */
void ET1310_PhyInit(struct et131x_adapter *etdev) ET1310_PhyAccessMiBit(adapter, TRUEPHY_BIT_SET, 0, 9, NULL);
{ return status;
uint16_t data, index; } else {
ET1310_PhyAutoNeg(adapter, false);
if (etdev == NULL) /* Set to the correct force mode. */
return; if (adapter->AiForceDpx != 1) {
if (adapter->RegistryFlowControl == TxOnly ||
adapter->RegistryFlowControl == Both)
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_SET, 4, 11,
NULL);
else
ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_CLEAR, 4, 11,
NULL);
/* get the identity (again ?) */ if (adapter->RegistryFlowControl == Both)
MiRead(etdev, PHY_ID_1, &data); ET1310_PhyAccessMiBit(adapter,
MiRead(etdev, PHY_ID_2, &data); TRUEPHY_BIT_SET, 4, 10,
NULL);
/* what does this do/achieve ? */ else
MiRead(etdev, PHY_MPHY_CONTROL_REG, &data); /* should read 0002 */ ET1310_PhyAccessMiBit(adapter,
MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0006); TRUEPHY_BIT_CLEAR, 4, 10,
NULL);
/* read modem register 0402, should I do something with the return } else {
data ? */ ET1310_PhyAccessMiBit(adapter,
MiWrite(etdev, PHY_INDEX_REG, 0x0402); TRUEPHY_BIT_CLEAR, 4, 10, NULL);
MiRead(etdev, PHY_DATA_REG, &data); ET1310_PhyAccessMiBit(adapter,
TRUEPHY_BIT_CLEAR, 4, 11, NULL);
/* what does this do/achieve ? */
MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0002);
/* get the identity (again ?) */
MiRead(etdev, PHY_ID_1, &data);
MiRead(etdev, PHY_ID_2, &data);
/* what does this achieve ? */
MiRead(etdev, PHY_MPHY_CONTROL_REG, &data); /* should read 0002 */
MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0006);
/* read modem register 0402, should I do something with
the return data? */
MiWrite(etdev, PHY_INDEX_REG, 0x0402);
MiRead(etdev, PHY_DATA_REG, &data);
MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0002);
/* what does this achieve (should return 0x1040) */
MiRead(etdev, PHY_CONTROL, &data);
MiRead(etdev, PHY_MPHY_CONTROL_REG, &data); /* should read 0002 */
MiWrite(etdev, PHY_CONTROL, 0x1840);
MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0007);
/* here the writing of the array starts.... */
index = 0;
while (ConfigPhy[index][0] != 0x0000) {
/* write value */
MiWrite(etdev, PHY_INDEX_REG, ConfigPhy[index][0]);
MiWrite(etdev, PHY_DATA_REG, ConfigPhy[index][1]);
/* read it back */
MiWrite(etdev, PHY_INDEX_REG, ConfigPhy[index][0]);
MiRead(etdev, PHY_DATA_REG, &data);
/* do a check on the value read back ? */
index++;
} }
/* here the writing of the array ends... */
MiRead(etdev, PHY_CONTROL, &data); /* 0x1840 */
MiRead(etdev, PHY_MPHY_CONTROL_REG, &data);/* should read 0007 */
MiWrite(etdev, PHY_CONTROL, 0x1040);
MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0002);
}
void ET1310_PhyReset(struct et131x_adapter *etdev)
{
MiWrite(etdev, PHY_CONTROL, 0x8000);
}
void ET1310_PhyPowerDown(struct et131x_adapter *etdev, bool down)
{
uint16_t data;
MiRead(etdev, PHY_CONTROL, &data); switch (adapter->AiForceSpeed) {
case 10:
if (adapter->AiForceDpx == 1)
TPAL_SetPhy10HalfDuplex(adapter);
else if (adapter->AiForceDpx == 2)
TPAL_SetPhy10FullDuplex(adapter);
else
TPAL_SetPhy10Force(adapter);
break;
case 100:
if (adapter->AiForceDpx == 1)
TPAL_SetPhy100HalfDuplex(adapter);
else if (adapter->AiForceDpx == 2)
TPAL_SetPhy100FullDuplex(adapter);
else
TPAL_SetPhy100Force(adapter);
break;
case 1000:
TPAL_SetPhy1000FullDuplex(adapter);
break;
}
if (down == false) { return status;
/* Power UP */
data &= ~0x0800;
MiWrite(etdev, PHY_CONTROL, data);
} else {
/* Power DOWN */
data |= 0x0800;
MiWrite(etdev, PHY_CONTROL, data);
} }
} }
void ET1310_PhyAutoNeg(struct et131x_adapter *etdev, bool enable) void et131x_Mii_check(struct et131x_adapter *etdev,
MI_BMSR_t bmsr, MI_BMSR_t bmsr_ints)
{ {
uint16_t data; u8 link_status;
u32 autoneg_status;
u32 speed;
u32 duplex;
u32 mdi_mdix;
u32 masterslave;
u32 polarity;
unsigned long flags;
MiRead(etdev, PHY_CONTROL, &data); if (bmsr_ints.bits.link_status) {
if (bmsr.bits.link_status) {
etdev->PoMgmt.TransPhyComaModeOnBoot = 20;
if (enable == true) { /* Update our state variables and indicate the
/* Autonegotiation ON */ * connected state
data |= 0x1000; */
MiWrite(etdev, PHY_CONTROL, data); spin_lock_irqsave(&etdev->Lock, flags);
} else {
/* Autonegotiation OFF */
data &= ~0x1000;
MiWrite(etdev, PHY_CONTROL, data);
}
}
void ET1310_PhyDuplexMode(struct et131x_adapter *etdev, uint16_t duplex) etdev->MediaState = NETIF_STATUS_MEDIA_CONNECT;
{ etdev->Flags &= ~fMP_ADAPTER_LINK_DETECTION;
uint16_t data;
MiRead(etdev, PHY_CONTROL, &data); spin_unlock_irqrestore(&etdev->Lock, flags);
if (duplex == TRUEPHY_DUPLEX_FULL) { netif_carrier_on(etdev->netdev);
/* Set Full Duplex */
data |= 0x100;
MiWrite(etdev, PHY_CONTROL, data);
} else { } else {
/* Set Half Duplex */ dev_warn(&etdev->pdev->dev,
data &= ~0x100; "Link down - cable problem ?\n");
MiWrite(etdev, PHY_CONTROL, data);
}
}
void ET1310_PhySpeedSelect(struct et131x_adapter *etdev, uint16_t speed)
{
uint16_t data;
/* Read the PHY control register */
MiRead(etdev, PHY_CONTROL, &data);
/* Clear all Speed settings (Bits 6, 13) */ if (etdev->linkspeed == TRUEPHY_SPEED_10MBPS) {
data &= ~0x2040; /* NOTE - Is there a way to query this without
* TruePHY?
* && TRU_QueryCoreType(etdev->hTruePhy, 0) == EMI_TRUEPHY_A13O) {
*/
u16 Register18;
/* Reset the speed bits based on user selection */ MiRead(etdev, 0x12, &Register18);
switch (speed) { MiWrite(etdev, 0x12, Register18 | 0x4);
case TRUEPHY_SPEED_10MBPS: MiWrite(etdev, 0x10, Register18 | 0x8402);
/* Bits already cleared above, do nothing */ MiWrite(etdev, 0x11, Register18 | 511);
break; MiWrite(etdev, 0x12, Register18);
}
case TRUEPHY_SPEED_100MBPS: /* For the first N seconds of life, we are in "link
/* 100M == Set bit 13 */ * detection" When we are in this state, we should
data |= 0x2000; * only report "connected". When the LinkDetection
break; * Timer expires, we can report disconnected (handled
* in the LinkDetectionDPC).
*/
if (!(etdev->Flags & fMP_ADAPTER_LINK_DETECTION) ||
(etdev->MediaState == NETIF_STATUS_MEDIA_DISCONNECT)) {
spin_lock_irqsave(&etdev->Lock, flags);
etdev->MediaState =
NETIF_STATUS_MEDIA_DISCONNECT;
spin_unlock_irqrestore(&etdev->Lock,
flags);
case TRUEPHY_SPEED_1000MBPS: netif_carrier_off(etdev->netdev);
default:
data |= 0x0040;
break;
} }
/* Write back the new speed */ etdev->linkspeed = 0;
MiWrite(etdev, PHY_CONTROL, data); etdev->duplex_mode = 0;
}
void ET1310_PhyAdvertise1000BaseT(struct et131x_adapter *etdev,
uint16_t duplex)
{
uint16_t data;
/* Read the PHY 1000 Base-T Control Register */ /* Free the packets being actively sent & stopped */
MiRead(etdev, PHY_1000_CONTROL, &data); et131x_free_busy_send_packets(etdev);
/* Clear Bits 8,9 */ /* Re-initialize the send structures */
data &= ~0x0300; et131x_init_send(etdev);
switch (duplex) { /* Reset the RFD list and re-start RU */
case TRUEPHY_ADV_DUPLEX_NONE: et131x_reset_recv(etdev);
/* Duplex already cleared, do nothing */
break;
case TRUEPHY_ADV_DUPLEX_FULL: /*
/* Set Bit 9 */ * Bring the device back to the state it was during
data |= 0x0200; * init prior to autonegotiation being complete. This
break; * way, when we get the auto-neg complete interrupt,
* we can complete init by calling ConfigMacREGS2.
*/
et131x_soft_reset(etdev);
case TRUEPHY_ADV_DUPLEX_HALF: /* Setup ET1310 as per the documentation */
/* Set Bit 8 */ et131x_adapter_setup(etdev);
data |= 0x0100;
break;
case TRUEPHY_ADV_DUPLEX_BOTH: /* Setup the PHY into coma mode until the cable is
default: * plugged back in
data |= 0x0300; */
break; if (etdev->RegistryPhyComa == 1)
EnablePhyComa(etdev);
}
} }
/* Write back advertisement */ if (bmsr_ints.bits.auto_neg_complete ||
MiWrite(etdev, PHY_1000_CONTROL, data); (etdev->AiForceDpx == 3 && bmsr_ints.bits.link_status)) {
} if (bmsr.bits.auto_neg_complete || etdev->AiForceDpx == 3) {
ET1310_PhyLinkStatus(etdev,
&link_status, &autoneg_status,
&speed, &duplex, &mdi_mdix,
&masterslave, &polarity);
void ET1310_PhyAdvertise100BaseT(struct et131x_adapter *etdev, etdev->linkspeed = speed;
uint16_t duplex) etdev->duplex_mode = duplex;
{
uint16_t data;
/* Read the Autonegotiation Register (10/100) */ etdev->PoMgmt.TransPhyComaModeOnBoot = 20;
MiRead(etdev, PHY_AUTO_ADVERTISEMENT, &data);
/* Clear bits 7,8 */ if (etdev->linkspeed == TRUEPHY_SPEED_10MBPS) {
data &= ~0x0180; /*
* NOTE - Is there a way to query this without
* TruePHY?
* && TRU_QueryCoreType(etdev->hTruePhy, 0)== EMI_TRUEPHY_A13O) {
*/
u16 Register18;
switch (duplex) { MiRead(etdev, 0x12, &Register18);
case TRUEPHY_ADV_DUPLEX_NONE: MiWrite(etdev, 0x12, Register18 | 0x4);
/* Duplex already cleared, do nothing */ MiWrite(etdev, 0x10, Register18 | 0x8402);
break; MiWrite(etdev, 0x11, Register18 | 511);
MiWrite(etdev, 0x12, Register18);
}
case TRUEPHY_ADV_DUPLEX_FULL: ConfigFlowControl(etdev);
/* Set Bit 8 */
data |= 0x0100;
break;
case TRUEPHY_ADV_DUPLEX_HALF: if (etdev->linkspeed == TRUEPHY_SPEED_1000MBPS &&
/* Set Bit 7 */ etdev->RegistryJumboPacket > 2048)
data |= 0x0080; ET1310_PhyAndOrReg(etdev, 0x16, 0xcfff,
break; 0x2000);
case TRUEPHY_ADV_DUPLEX_BOTH: SetRxDmaTimer(etdev);
default: ConfigMACRegs2(etdev);
/* Set Bits 7,8 */ }
data |= 0x0180;
break;
} }
/* Write back advertisement */
MiWrite(etdev, PHY_AUTO_ADVERTISEMENT, data);
} }
void ET1310_PhyAdvertise10BaseT(struct et131x_adapter *etdev, /*
uint16_t duplex) * The routines which follow provide low-level access to the PHY, and are used
{ * primarily by the routines above (although there are a few places elsewhere
uint16_t data; * in the driver where this level of access is required).
*/
/* Read the Autonegotiation Register (10/100) */
MiRead(etdev, PHY_AUTO_ADVERTISEMENT, &data);
/* Clear bits 5,6 */
data &= ~0x0060;
switch (duplex) { static const u16 ConfigPhy[25][2] = {
case TRUEPHY_ADV_DUPLEX_NONE: /* Reg Value Register */
/* Duplex already cleared, do nothing */ /* Addr */
break; {0x880B, 0x0926}, /* AfeIfCreg4B1000Msbs */
{0x880C, 0x0926}, /* AfeIfCreg4B100Msbs */
{0x880D, 0x0926}, /* AfeIfCreg4B10Msbs */
case TRUEPHY_ADV_DUPLEX_FULL: {0x880E, 0xB4D3}, /* AfeIfCreg4B1000Lsbs */
/* Set Bit 6 */ {0x880F, 0xB4D3}, /* AfeIfCreg4B100Lsbs */
data |= 0x0040; {0x8810, 0xB4D3}, /* AfeIfCreg4B10Lsbs */
break;
case TRUEPHY_ADV_DUPLEX_HALF: {0x8805, 0xB03E}, /* AfeIfCreg3B1000Msbs */
/* Set Bit 5 */ {0x8806, 0xB03E}, /* AfeIfCreg3B100Msbs */
data |= 0x0020; {0x8807, 0xFF00}, /* AfeIfCreg3B10Msbs */
break;
case TRUEPHY_ADV_DUPLEX_BOTH: {0x8808, 0xE090}, /* AfeIfCreg3B1000Lsbs */
default: {0x8809, 0xE110}, /* AfeIfCreg3B100Lsbs */
/* Set Bits 5,6 */ {0x880A, 0x0000}, /* AfeIfCreg3B10Lsbs */
data |= 0x0060;
break;
}
/* Write back advertisement */ {0x300D, 1}, /* DisableNorm */
MiWrite(etdev, PHY_AUTO_ADVERTISEMENT, data);
}
void ET1310_PhyLinkStatus(struct et131x_adapter *etdev, {0x280C, 0x0180}, /* LinkHoldEnd */
uint8_t *link_status,
uint32_t *autoneg,
uint32_t *linkspeed,
uint32_t *duplex_mode,
uint32_t *mdi_mdix,
uint32_t *masterslave, uint32_t *polarity)
{
uint16_t mistatus = 0;
uint16_t is1000BaseT = 0;
uint16_t vmi_phystatus = 0;
uint16_t control = 0;
MiRead(etdev, PHY_STATUS, &mistatus); {0x1C21, 0x0002}, /* AlphaM */
MiRead(etdev, PHY_1000_STATUS, &is1000BaseT);
MiRead(etdev, PHY_PHY_STATUS, &vmi_phystatus);
MiRead(etdev, PHY_CONTROL, &control);
if (link_status) { {0x3821, 6}, /* FfeLkgTx0 */
*link_status = {0x381D, 1}, /* FfeLkg1g4 */
(unsigned char)((vmi_phystatus & 0x0040) ? 1 : 0); {0x381E, 1}, /* FfeLkg1g5 */
} {0x381F, 1}, /* FfeLkg1g6 */
{0x3820, 1}, /* FfeLkg1g7 */
if (autoneg) { {0x8402, 0x01F0}, /* Btinact */
*autoneg = {0x800E, 20}, /* LftrainTime */
(control & 0x1000) ? ((vmi_phystatus & 0x0020) ? {0x800F, 24}, /* DvguardTime */
TRUEPHY_ANEG_COMPLETE : {0x8010, 46}, /* IdlguardTime */
TRUEPHY_ANEG_NOT_COMPLETE) :
TRUEPHY_ANEG_DISABLED;
}
if (linkspeed) {0, 0}
*linkspeed = (vmi_phystatus & 0x0300) >> 8;
if (duplex_mode) };
*duplex_mode = (vmi_phystatus & 0x0080) >> 7;
if (mdi_mdix) /* condensed version of the phy initialization routine */
/* NOTE: Need to complete this */ void ET1310_PhyInit(struct et131x_adapter *etdev)
*mdi_mdix = 0; {
u16 data, index;
if (masterslave) { if (etdev == NULL)
*masterslave = return;
(is1000BaseT & 0x4000) ? TRUEPHY_CFG_MASTER :
TRUEPHY_CFG_SLAVE;
}
if (polarity) { /* get the identity (again ?) */
*polarity = MiRead(etdev, PHY_ID_1, &data);
(vmi_phystatus & 0x0400) ? TRUEPHY_POLARITY_INVERTED : MiRead(etdev, PHY_ID_2, &data);
TRUEPHY_POLARITY_NORMAL;
}
}
void ET1310_PhyAndOrReg(struct et131x_adapter *etdev, /* what does this do/achieve ? */
uint16_t regnum, uint16_t andMask, uint16_t orMask) MiRead(etdev, PHY_MPHY_CONTROL_REG, &data); /* should read 0002 */
{ MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0006);
uint16_t reg;
/* Read the requested register */ /* read modem register 0402, should I do something with the return
MiRead(etdev, regnum, &reg); data ? */
MiWrite(etdev, PHY_INDEX_REG, 0x0402);
MiRead(etdev, PHY_DATA_REG, &data);
/* Apply the AND mask */ /* what does this do/achieve ? */
reg &= andMask; MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0002);
/* Apply the OR mask */ /* get the identity (again ?) */
reg |= orMask; MiRead(etdev, PHY_ID_1, &data);
MiRead(etdev, PHY_ID_2, &data);
/* Write the value back to the register */ /* what does this achieve ? */
MiWrite(etdev, regnum, reg); MiRead(etdev, PHY_MPHY_CONTROL_REG, &data); /* should read 0002 */
} MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0006);
void ET1310_PhyAccessMiBit(struct et131x_adapter *etdev, uint16_t action, /* read modem register 0402, should I do something with
uint16_t regnum, uint16_t bitnum, uint8_t *value) the return data? */
{ MiWrite(etdev, PHY_INDEX_REG, 0x0402);
uint16_t reg; MiRead(etdev, PHY_DATA_REG, &data);
uint16_t mask = 0;
/* Create a mask to isolate the requested bit */ MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0002);
mask = 0x0001 << bitnum;
/* Read the requested register */ /* what does this achieve (should return 0x1040) */
MiRead(etdev, regnum, &reg); MiRead(etdev, PHY_CONTROL, &data);
MiRead(etdev, PHY_MPHY_CONTROL_REG, &data); /* should read 0002 */
MiWrite(etdev, PHY_CONTROL, 0x1840);
switch (action) { MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0007);
case TRUEPHY_BIT_READ:
if (value != NULL)
*value = (reg & mask) >> bitnum;
break;
case TRUEPHY_BIT_SET: /* here the writing of the array starts.... */
reg |= mask; index = 0;
MiWrite(etdev, regnum, reg); while (ConfigPhy[index][0] != 0x0000) {
break; /* write value */
MiWrite(etdev, PHY_INDEX_REG, ConfigPhy[index][0]);
MiWrite(etdev, PHY_DATA_REG, ConfigPhy[index][1]);
case TRUEPHY_BIT_CLEAR: /* read it back */
reg &= ~mask; MiWrite(etdev, PHY_INDEX_REG, ConfigPhy[index][0]);
MiWrite(etdev, regnum, reg); MiRead(etdev, PHY_DATA_REG, &data);
break;
default: /* do a check on the value read back ? */
break; index++;
} }
/* here the writing of the array ends... */
MiRead(etdev, PHY_CONTROL, &data); /* 0x1840 */
MiRead(etdev, PHY_MPHY_CONTROL_REG, &data);/* should read 0007 */
MiWrite(etdev, PHY_CONTROL, 0x1040);
MiWrite(etdev, PHY_MPHY_CONTROL_REG, 0x0002);
} }
drivers/staging/et131x/et1310_phy.h
View file @ 1210db95
...@@ -739,25 +739,15 @@ typedef union _MI_LCR2_t { ...@@ -739,25 +739,15 @@ typedef union _MI_LCR2_t {
/* Forward declaration of the private adapter structure */ /* Forward declaration of the private adapter structure */
struct et131x_adapter; struct et131x_adapter;
/* OS Specific Functions*/
void TPAL_SetPhy10HalfDuplex(struct et131x_adapter *adapter);
void TPAL_SetPhy10FullDuplex(struct et131x_adapter *adapter);
void TPAL_SetPhy10Force(struct et131x_adapter *pAdapter);
void TPAL_SetPhy100HalfDuplex(struct et131x_adapter *adapter);
void TPAL_SetPhy100FullDuplex(struct et131x_adapter *adapter);
void TPAL_SetPhy100Force(struct et131x_adapter *pAdapter);
void TPAL_SetPhy1000FullDuplex(struct et131x_adapter *adapter);
void TPAL_SetPhyAutoNeg(struct et131x_adapter *adapter);
/* Prototypes for ET1310_phy.c */ /* Prototypes for ET1310_phy.c */
int et131x_xcvr_find(struct et131x_adapter *adapter); int et131x_xcvr_find(struct et131x_adapter *adapter);
int et131x_setphy_normal(struct et131x_adapter *adapter); int et131x_setphy_normal(struct et131x_adapter *adapter);
int32_t PhyMiRead(struct et131x_adapter *adapter,
u8 xcvrAddr, u8 xcvrReg, u16 *value);
/* static inline function does not work because et131x_adapter is not always /* static inline function does not work because et131x_adapter is not always
* defined * defined
*/ */
int PhyMiRead(struct et131x_adapter *adapter, u8 xcvrAddr,
u8 xcvrReg, u16 *value);
#define MiRead(adapter, xcvrReg, value) \ #define MiRead(adapter, xcvrReg, value) \
PhyMiRead((adapter), (adapter)->Stats.xcvr_addr, (xcvrReg), (value)) PhyMiRead((adapter), (adapter)->Stats.xcvr_addr, (xcvrReg), (value))
...@@ -857,24 +847,8 @@ void SetPhy_10BaseTHalfDuplex(struct et131x_adapter *adapter); ...@@ -857,24 +847,8 @@ void SetPhy_10BaseTHalfDuplex(struct et131x_adapter *adapter);
void ET1310_PhyInit(struct et131x_adapter *adapter); void ET1310_PhyInit(struct et131x_adapter *adapter);
void ET1310_PhyReset(struct et131x_adapter *adapter); void ET1310_PhyReset(struct et131x_adapter *adapter);
void ET1310_PhyPowerDown(struct et131x_adapter *adapter, bool down); void ET1310_PhyPowerDown(struct et131x_adapter *adapter, bool down);
void ET1310_PhyAutoNeg(struct et131x_adapter *adapter, bool enable);
void ET1310_PhyDuplexMode(struct et131x_adapter *adapter, u16 duplex);
void ET1310_PhySpeedSelect(struct et131x_adapter *adapter, u16 speed);
void ET1310_PhyAdvertise1000BaseT(struct et131x_adapter *adapter, void ET1310_PhyAdvertise1000BaseT(struct et131x_adapter *adapter,
u16 duplex); u16 duplex);
void ET1310_PhyAdvertise100BaseT(struct et131x_adapter *adapter,
u16 duplex);
void ET1310_PhyAdvertise10BaseT(struct et131x_adapter *adapter,
u16 duplex);
void ET1310_PhyLinkStatus(struct et131x_adapter *adapter,
u8 *Link_status,
u32 *autoneg,
u32 *linkspeed,
u32 *duplex_mode,
u32 *mdi_mdix,
u32 *masterslave, u32 *polarity);
void ET1310_PhyAndOrReg(struct et131x_adapter *adapter,
u16 regnum, u16 andMask, u16 orMask);
void ET1310_PhyAccessMiBit(struct et131x_adapter *adapter, void ET1310_PhyAccessMiBit(struct et131x_adapter *adapter,
u16 action, u16 action,
u16 regnum, u16 bitnum, u8 *value); u16 regnum, u16 bitnum, u8 *value);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7