dev/e1000/e1000_phy.c

40 					  u16 *data, bool read, bool page_set);
43 					  u16 *data, bool read);
107  *  @data: dummy variable
110 			u16 E1000_UNUSEDARG data)
120  *  @data: dummy variable
123 			u32 E1000_UNUSEDARG offset, u16 E1000_UNUSEDARG *data)
155  *  @data: dummy variable
158 			 u32 E1000_UNUSEDARG offset, u16 E1000_UNUSEDARG data)
169  *  @data: data value read
175 			     u8 E1000_UNUSEDARG *data)
186  *  @data: data value to write
192 			      u8 E1000_UNUSEDARG data)
286  *  @data: pointer to the read data
289  *  information read to data.
291 s32 e1000_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data)
305 	 * PHY to retrieve the desired data.
337 	*data = (u16) mdic;
340 	 * reading duplicate data in the next MDIC transaction.
352  *  @data: data to write to register at offset
354  *  Writes data to MDI control register in the PHY at offset.
356 s32 e1000_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data)
370 	 * PHY to retrieve the desired data.
372 	mdic = (((u32)data) |
405 	 * reading duplicate data in the next MDIC transaction.
417  *  @data: pointer to the read data
420  *  retrieved information in data.
422 s32 e1000_read_phy_reg_i2c(struct e1000_hw *hw, u32 offset, u16 *data)
431 	 * PHY to retrieve the desired data.
456 	*data = ((i2ccmd >> 8) & 0x00FF) | ((i2ccmd << 8) & 0xFF00);
465  *  @data: data to write at register offset
467  *  Writes the data to PHY register at the offset using the i2c interface.
469 s32 e1000_write_phy_reg_i2c(struct e1000_hw *hw, u32 offset, u16 data)
484 	/* Swap the data bytes for the I2C interface */
485 	phy_data_swapped = ((data >> 8) & 0x00FF) | ((data << 8) & 0xFF00);
489 	 * PHY to retrieve the desired data.
518  *  e1000_read_sfp_data_byte - Reads SFP module data.
521  *  @data: read data buffer pointer
523  *  Reads one byte from SFP module data stored
530 s32 e1000_read_sfp_data_byte(struct e1000_hw *hw, u16 offset, u8 *data)
545 	 * EEPROM to retrieve the desired data.
567 	*data = (u8) data_local & 0xFF;
573  *  e1000_write_sfp_data_byte - Writes SFP module data.
576  *  @data: data to write
578  *  Writes one byte to SFP module data stored
585 s32 e1000_write_sfp_data_byte(struct e1000_hw *hw, u16 offset, u8 data)
604 	 * with an EEPROM to write the data given.
624 				data_local |= (u32)data;
649  *  @data: pointer to the read data
652  *  and storing the retrieved information in data.  Release any acquired
655 s32 e1000_read_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 *data)
669 					  data);
680  *  @data: data to write at register offset
682  *  Acquires semaphore, if necessary, then writes the data to PHY register
685 s32 e1000_write_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 data)
699 					   data);
730  *  @data: pointer to the read data
734  *  and stores the retrieved information in data.  Release any acquired
737 static s32 __e1000_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data,
760 						  data);
771  *  @data: pointer to the read data
774  *  retrieved information in data.
777 s32 e1000_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data)
779 	return __e1000_read_phy_reg_igp(hw, offset, data, false);
786  *  @data: pointer to the read data
789  *  in data.  Assumes semaphore already acquired.
791 s32 e1000_read_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 *data)
793 	return __e1000_read_phy_reg_igp(hw, offset, data, true);
800  *  @data: data to write at register offset
803  *  Acquires semaphore, if necessary, then writes the data to PHY register
806 static s32 __e1000_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data,
829 						   data);
840  *  @data: data to write at register offset
842  *  Acquires semaphore then writes the data to PHY register
845 s32 e1000_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data)
847 	return __e1000_write_phy_reg_igp(hw, offset, data, false);
854  *  @data: data to write at register offset
856  *  Writes the data to PHY register at the offset.
859 s32 e1000_write_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 data)
861 	return __e1000_write_phy_reg_igp(hw, offset, data, true);
868  *  @data: pointer to the read data
872  *  using the kumeran interface.  The information retrieved is stored in data.
875 static s32 __e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data,
901 	*data = (u16)kmrnctrlsta;
913  *  @data: pointer to the read data
916  *  kumeran interface.  The information retrieved is stored in data.
919 s32 e1000_read_kmrn_reg_generic(struct e1000_hw *hw, u32 offset, u16 *data)
921 	return __e1000_read_kmrn_reg(hw, offset, data, false);
928  *  @data: pointer to the read data
931  *  information retrieved is stored in data.
934 s32 e1000_read_kmrn_reg_locked(struct e1000_hw *hw, u32 offset, u16 *data)
936 	return __e1000_read_kmrn_reg(hw, offset, data, true);
943  *  @data: data to write at register offset
946  *  Acquires semaphore, if necessary.  Then write the data to PHY register
950 static s32 __e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data,
969 		       E1000_KMRNCTRLSTA_OFFSET) | data;
985  *  @data: data to write at register offset
987  *  Acquires semaphore then writes the data to the PHY register at the offset
990 s32 e1000_write_kmrn_reg_generic(struct e1000_hw *hw, u32 offset, u16 data)
992 	return __e1000_write_kmrn_reg(hw, offset, data, false);
999  *  @data: data to write at register offset
1001  *  Write the data to PHY register at the offset using the kumeran interface.
1004 s32 e1000_write_kmrn_reg_locked(struct e1000_hw *hw, u32 offset, u16 data)
1006 	return __e1000_write_kmrn_reg(hw, offset, data, true);
1375 	u16 data;
1412 	ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_CTRL, &data);
1416 	data &= ~IGP01E1000_PSCR_AUTO_MDIX;
1420 		data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
1423 		data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
1428 		data |= IGP01E1000_PSCR_AUTO_MDIX;
1431 	ret_val = phy->ops.write_reg(hw, IGP01E1000_PHY_PORT_CTRL, data);
1445 						    &data);
1449 			data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1452 						     data);
1457 			ret_val = phy->ops.read_reg(hw, PHY_1000T_CTRL, &data);
1461 			data &= ~CR_1000T_MS_ENABLE;
1462 			ret_val = phy->ops.write_reg(hw, PHY_1000T_CTRL, data);
1961 	u16 data;
1966 	ret_val = phy->ops.read_reg(hw, PHY_CONTROL, &data);
1970 	e1000_phy_force_speed_duplex_setup(hw, &data);
1972 	ret_val = phy->ops.write_reg(hw, PHY_CONTROL, data);
1977 	ret_val = phy->ops.read_reg(hw, IFE_PHY_MDIX_CONTROL, &data);
1981 	data &= ~IFE_PMC_AUTO_MDIX;
1982 	data &= ~IFE_PMC_FORCE_MDIX;
1984 	ret_val = phy->ops.write_reg(hw, IFE_PHY_MDIX_CONTROL, data);
1988 	DEBUGOUT1("IFE PMC: %X\n", data);
2092 	u16 data;
2099 	ret_val = phy->ops.read_reg(hw, IGP02E1000_PHY_POWER_MGMT, &data);
2104 		data &= ~IGP02E1000_PM_D3_LPLU;
2106 					     data);
2117 						    &data);
2121 			data |= IGP01E1000_PSCFR_SMART_SPEED;
2124 						     data);
2130 						    &data);
2134 			data &= ~IGP01E1000_PSCFR_SMART_SPEED;
2137 						     data);
2144 		data |= IGP02E1000_PM_D3_LPLU;
2146 					     data);
2152 					    &data);
2156 		data &= ~IGP01E1000_PSCFR_SMART_SPEED;
2158 					     data);
2221 	u16 data;
2225 	ret_val = phy->ops.read_reg(hw, M88E1000_PHY_SPEC_STATUS, &data);
2228 		phy->cable_polarity = ((data & M88E1000_PSSR_REV_POLARITY)
2248 	u16 data, offset, mask;
2255 	ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_STATUS, &data);
2259 	if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
2271 	ret_val = phy->ops.read_reg(hw, offset, &data);
2274 		phy->cable_polarity = ((data & mask)
2716 	u16 data;
2736 	ret_val = phy->ops.read_reg(hw, IGP01E1000_PHY_PORT_STATUS, &data);
2740 	phy->is_mdix = !!(data & IGP01E1000_PSSR_MDIX);
2742 	if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
2748 		ret_val = phy->ops.read_reg(hw, PHY_1000T_STATUS, &data);
2752 		phy->local_rx = (data & SR_1000T_LOCAL_RX_STATUS)
2756 		phy->remote_rx = (data & SR_1000T_REMOTE_RX_STATUS)
2778 	u16 data;
2792 	ret_val = phy->ops.read_reg(hw, IFE_PHY_SPECIAL_CONTROL, &data);
2795 	phy->polarity_correction = !(data & IFE_PSC_AUTO_POLARITY_DISABLE);
2803 		phy->cable_polarity = ((data & IFE_PSC_FORCE_POLARITY)
2808 	ret_val = phy->ops.read_reg(hw, IFE_PHY_MDIX_CONTROL, &data);
2812 	phy->is_mdix = !!(data & IFE_PMC_MDIX_STATUS);
3119  *  @data: data to write at register offset
3121  *  Acquires semaphore, if necessary, then writes the data to PHY register
3124 s32 e1000_write_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 data)
3137 		ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, &data,
3167 					   data);
3178  *  @data: pointer to the read data
3181  *  and storing the retrieved information in data.  Release any acquired
3184 s32 e1000_read_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 *data)
3197 		ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, data,
3227 					  data);
3237  *  @data: pointer to the read data
3240  *  and storing the retrieved information in data.  Release any acquired
3243 s32 e1000_read_phy_reg_bm2(struct e1000_hw *hw, u32 offset, u16 *data)
3256 		ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, data,
3273 					  data);
3283  *  @data: data to write at register offset
3285  *  Acquires semaphore, if necessary, then writes the data to PHY register
3288 s32 e1000_write_phy_reg_bm2(struct e1000_hw *hw, u32 offset, u16 data)
3301 		ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, &data,
3318 					   data);
3420  *  @data: pointer to the data to read or write
3425  *  data, or write data to PHY register at offset.  Note the procedure to
3431  *  4) Read or write the data using the data opcode (0x12)
3442 					  u16 *data, bool read, bool page_set)
3478 						  data);
3482 						   *data);
3537  *  @data: pointer to the read data
3542  *  and stores the retrieved information in data.  Release any acquired
3545 static s32 __e1000_read_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 *data,
3562 		ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, data,
3569 							 data, true);
3593 					  data);
3605  *  @data: pointer to the read data
3608  *  the retrieved information in data.  Release the acquired semaphore
3611 s32 e1000_read_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 *data)
3613 	return __e1000_read_phy_reg_hv(hw, offset, data, false, false);
3620  *  @data: pointer to the read data
3623  *  in data.  Assumes semaphore already acquired.
3625 s32 e1000_read_phy_reg_hv_locked(struct e1000_hw *hw, u32 offset, u16 *data)
3627 	return __e1000_read_phy_reg_hv(hw, offset, data, true, false);
3634  *  @data: data to write at register offset
3637  *  in data.  Assumes semaphore already acquired and page already set.
3639 s32 e1000_read_phy_reg_page_hv(struct e1000_hw *hw, u32 offset, u16 *data)
3641 	return __e1000_read_phy_reg_hv(hw, offset, data, true, true);
3648  *  @data: data to write at register offset
3652  *  Acquires semaphore, if necessary, then writes the data to PHY register
3655 static s32 __e1000_write_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 data,
3672 		ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, &data,
3679 							 &data, false);
3694 		    (data & (1 << 11))) {
3719 					   data);
3732  *  @data: data to write at register offset
3734  *  Acquires semaphore then writes the data to PHY register at the offset.
3737 s32 e1000_write_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 data)
3739 	return __e1000_write_phy_reg_hv(hw, offset, data, false, false);
3746  *  @data: data to write at register offset
3748  *  Writes the data to PHY register at the offset.  Assumes semaphore
3751 s32 e1000_write_phy_reg_hv_locked(struct e1000_hw *hw, u32 offset, u16 data)
3753 	return __e1000_write_phy_reg_hv(hw, offset, data, true, false);
3760  *  @data: data to write at register offset
3762  *  Writes the data to PHY register at the offset.  Assumes semaphore
3765 s32 e1000_write_phy_reg_page_hv(struct e1000_hw *hw, u32 offset, u16 data)
3767 	return __e1000_write_phy_reg_hv(hw, offset, data, true, true);
3788  *  @data: pointer to the data to be read or written
3792  *  in data.  Assumes semaphore already acquired.  Note that the procedure
3793  *  to access these regs uses the address port and data port to read/write.
3797 					  u16 *data, bool read)
3820 	/* Read or write the data value next */
3822 		ret_val = e1000_read_phy_reg_mdic(hw, data_reg, data);
3824 		ret_val = e1000_write_phy_reg_mdic(hw, data_reg, *data);
3846 	u16 data;
3854 	hw->phy.ops.read_reg(hw, PHY_CONTROL, &data);
3855 	if (data & PHY_CONTROL_LB)
3859 	ret_val = hw->phy.ops.read_reg(hw, BM_CS_STATUS, &data);
3863 	data &= (BM_CS_STATUS_LINK_UP | BM_CS_STATUS_RESOLVED |
3866 	if (data != (BM_CS_STATUS_LINK_UP | BM_CS_STATUS_RESOLVED |
3895 	u16 data;
3899 	ret_val = phy->ops.read_reg(hw, I82577_PHY_STATUS_2, &data);
3902 		phy->cable_polarity = ((data & I82577_PHY_STATUS2_REV_POLARITY)
3968 	u16 data;
3988 	ret_val = phy->ops.read_reg(hw, I82577_PHY_STATUS_2, &data);
3992 	phy->is_mdix = !!(data & I82577_PHY_STATUS2_MDIX);
3994 	if ((data & I82577_PHY_STATUS2_SPEED_MASK) ==
4000 		ret_val = phy->ops.read_reg(hw, PHY_1000T_STATUS, &data);
4004 		phy->local_rx = (data & SR_1000T_LOCAL_RX_STATUS)
4008 		phy->remote_rx = (data & SR_1000T_REMOTE_RX_STATUS)
4054  *  @data: data to write at register offset
4056  *  Acquires semaphore, if necessary, then writes the data to PHY register
4059 s32 e1000_write_phy_reg_gs40g(struct e1000_hw *hw, u32 offset, u16 data)
4074 	ret_val = e1000_write_phy_reg_mdic(hw, offset, data);
4086  *  @data: data to read at register offset
4088  *  Acquires semaphore, if necessary, then reads the data in the PHY register
4091 s32 e1000_read_phy_reg_gs40g(struct e1000_hw *hw, u32 offset, u16 *data)
4106 	ret_val = e1000_read_phy_reg_mdic(hw, offset, data);
4117  *  @data: pointer to the read data
4120  *  information read to data.
4122 s32 e1000_read_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 *data)
4157 	/* Read data from the address */
4161 	*data = E1000_READ_REG(hw, E1000_MPHY_DATA);
4178  *  @data: data to write to register at offset
4181  *  Writes data to mPHY control register.
4183 s32 e1000_write_phy_reg_mphy(struct e1000_hw *hw, u32 address, u32 data,
4222 	/* Read data from the address */
4226 	E1000_WRITE_REG(hw, E1000_MPHY_DATA, data);
4273  *  @data: pointer to value to read/write from/to the XMDIO address
4277 				    u8 dev_addr, u16 *data, bool read)
4297 		ret_val = hw->phy.ops.read_reg(hw, E1000_MMDAAD, data);
4299 		ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAAD, *data);
4316  *  @data: value to be read from the EMI address
4318 s32 e1000_read_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr, u16 *data)
4322 		return __e1000_access_xmdio_reg(hw, addr, dev_addr, data, true);
4330  *  @data: value to be written to the XMDIO address
4332 s32 e1000_write_xmdio_reg(struct e1000_hw *hw, u16 addr, u8 dev_addr, u16 data)
4336 		return __e1000_access_xmdio_reg(hw, addr, dev_addr, &data,