Lines Matching refs:data
9 u16 *data, bool read, bool page_set);
12 u16 *data, bool read);
114 * @data: pointer to the read data
117 * information read to data.
119 s32 e1000e_read_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 *data)
131 * PHY to retrieve the desired data.
163 *data = (u16)mdic;
166 * reading duplicate data in the next MDIC transaction.
178 * @data: data to write to register at offset
180 * Writes data to MDI control register in the PHY at offset.
182 s32 e1000e_write_phy_reg_mdic(struct e1000_hw *hw, u32 offset, u16 data)
194 * PHY to retrieve the desired data.
196 mdic = (((u32)data) |
229 * reading duplicate data in the next MDIC transaction.
241 * @data: pointer to the read data
244 * and storing the retrieved information in data. Release any acquired
247 s32 e1000e_read_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 *data)
256 data);
267 * @data: data to write at register offset
269 * Acquires semaphore, if necessary, then writes the data to PHY register
272 s32 e1000e_write_phy_reg_m88(struct e1000_hw *hw, u32 offset, u16 data)
281 data);
310 * @data: pointer to the read data
314 * and stores the retrieved information in data. Release any acquired
317 static s32 __e1000e_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data,
338 data);
349 * @data: pointer to the read data
352 * retrieved information in data.
355 s32 e1000e_read_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 *data)
357 return __e1000e_read_phy_reg_igp(hw, offset, data, false);
364 * @data: pointer to the read data
367 * in data. Assumes semaphore already acquired.
369 s32 e1000e_read_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 *data)
371 return __e1000e_read_phy_reg_igp(hw, offset, data, true);
378 * @data: data to write at register offset
381 * Acquires semaphore, if necessary, then writes the data to PHY register
384 static s32 __e1000e_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data,
404 offset, data);
415 * @data: data to write at register offset
417 * Acquires semaphore then writes the data to PHY register
420 s32 e1000e_write_phy_reg_igp(struct e1000_hw *hw, u32 offset, u16 data)
422 return __e1000e_write_phy_reg_igp(hw, offset, data, false);
429 * @data: data to write at register offset
431 * Writes the data to PHY register at the offset.
434 s32 e1000e_write_phy_reg_igp_locked(struct e1000_hw *hw, u32 offset, u16 data)
436 return __e1000e_write_phy_reg_igp(hw, offset, data, true);
443 * @data: pointer to the read data
447 * using the kumeran interface. The information retrieved is stored in data.
450 static s32 __e1000_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data,
474 *data = (u16)kmrnctrlsta;
486 * @data: pointer to the read data
489 * kumeran interface. The information retrieved is stored in data.
492 s32 e1000e_read_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 *data)
494 return __e1000_read_kmrn_reg(hw, offset, data, false);
501 * @data: pointer to the read data
504 * information retrieved is stored in data.
507 s32 e1000e_read_kmrn_reg_locked(struct e1000_hw *hw, u32 offset, u16 *data)
509 return __e1000_read_kmrn_reg(hw, offset, data, true);
516 * @data: data to write at register offset
519 * Acquires semaphore, if necessary. Then write the data to PHY register
523 static s32 __e1000_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data,
540 E1000_KMRNCTRLSTA_OFFSET) | data;
556 * @data: data to write at register offset
558 * Acquires semaphore then writes the data to the PHY register at the offset
561 s32 e1000e_write_kmrn_reg(struct e1000_hw *hw, u32 offset, u16 data)
563 return __e1000_write_kmrn_reg(hw, offset, data, false);
570 * @data: data to write at register offset
572 * Write the data to PHY register at the offset using the kumeran interface.
575 s32 e1000e_write_kmrn_reg_locked(struct e1000_hw *hw, u32 offset, u16 data)
577 return __e1000_write_kmrn_reg(hw, offset, data, true);
829 u16 data;
851 ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_CTRL, &data);
855 data &= ~IGP01E1000_PSCR_AUTO_MDIX;
859 data &= ~IGP01E1000_PSCR_FORCE_MDI_MDIX;
862 data |= IGP01E1000_PSCR_FORCE_MDI_MDIX;
866 data |= IGP01E1000_PSCR_AUTO_MDIX;
869 ret_val = e1e_wphy(hw, IGP01E1000_PHY_PORT_CTRL, data);
882 &data);
886 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
888 data);
893 ret_val = e1e_rphy(hw, MII_CTRL1000, &data);
897 data &= ~CTL1000_ENABLE_MASTER;
898 ret_val = e1e_wphy(hw, MII_CTRL1000, data);
1365 u16 data;
1368 ret_val = e1e_rphy(hw, MII_BMCR, &data);
1372 e1000e_phy_force_speed_duplex_setup(hw, &data);
1374 ret_val = e1e_wphy(hw, MII_BMCR, data);
1379 ret_val = e1e_rphy(hw, IFE_PHY_MDIX_CONTROL, &data);
1383 data &= ~IFE_PMC_AUTO_MDIX;
1384 data &= ~IFE_PMC_FORCE_MDIX;
1386 ret_val = e1e_wphy(hw, IFE_PHY_MDIX_CONTROL, data);
1390 e_dbg("IFE PMC: %X\n", data);
1492 u16 data;
1494 ret_val = e1e_rphy(hw, IGP02E1000_PHY_POWER_MGMT, &data);
1499 data &= ~IGP02E1000_PM_D3_LPLU;
1500 ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data);
1510 &data);
1514 data |= IGP01E1000_PSCFR_SMART_SPEED;
1516 data);
1521 &data);
1525 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1527 data);
1534 data |= IGP02E1000_PM_D3_LPLU;
1535 ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data);
1540 ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_CONFIG, &data);
1544 data &= ~IGP01E1000_PSCFR_SMART_SPEED;
1545 ret_val = e1e_wphy(hw, IGP01E1000_PHY_PORT_CONFIG, data);
1604 u16 data;
1606 ret_val = e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &data);
1609 phy->cable_polarity = ((data & M88E1000_PSSR_REV_POLARITY)
1629 u16 data, offset, mask;
1634 ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_STATUS, &data);
1638 if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
1650 ret_val = e1e_rphy(hw, offset, &data);
1653 phy->cable_polarity = ((data & mask)
1964 u16 data;
1982 ret_val = e1e_rphy(hw, IGP01E1000_PHY_PORT_STATUS, &data);
1986 phy->is_mdix = !!(data & IGP01E1000_PSSR_MDIX);
1988 if ((data & IGP01E1000_PSSR_SPEED_MASK) ==
1994 ret_val = e1e_rphy(hw, MII_STAT1000, &data);
1998 phy->local_rx = (data & LPA_1000LOCALRXOK)
2001 phy->remote_rx = (data & LPA_1000REMRXOK)
2022 u16 data;
2034 ret_val = e1e_rphy(hw, IFE_PHY_SPECIAL_CONTROL, &data);
2037 phy->polarity_correction = !(data & IFE_PSC_AUTO_POLARITY_DISABLE);
2045 phy->cable_polarity = ((data & IFE_PSC_FORCE_POLARITY)
2050 ret_val = e1e_rphy(hw, IFE_PHY_MDIX_CONTROL, &data);
2054 phy->is_mdix = !!(data & IFE_PMC_MDIX_STATUS);
2341 * @data: data to write at register offset
2343 * Acquires semaphore, if necessary, then writes the data to PHY register
2346 s32 e1000e_write_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 data)
2357 ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, &data,
2387 data);
2398 * @data: pointer to the read data
2401 * and storing the retrieved information in data. Release any acquired
2404 s32 e1000e_read_phy_reg_bm(struct e1000_hw *hw, u32 offset, u16 *data)
2415 ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, data,
2445 data);
2455 * @data: pointer to the read data
2458 * and storing the retrieved information in data. Release any acquired
2461 s32 e1000e_read_phy_reg_bm2(struct e1000_hw *hw, u32 offset, u16 *data)
2472 ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, data,
2489 data);
2499 * @data: data to write at register offset
2501 * Acquires semaphore, if necessary, then writes the data to PHY register
2504 s32 e1000e_write_phy_reg_bm2(struct e1000_hw *hw, u32 offset, u16 data)
2515 ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, &data,
2532 data);
2624 * @data: pointer to the data to read or write
2629 * data, or write data to PHY register at offset. Note the procedure to
2635 * 4) Read or write the data using the data opcode (0x12)
2646 u16 *data, bool read, bool page_set)
2680 data);
2684 *data);
2749 * @data: pointer to the read data
2754 * and stores the retrieved information in data. Release any acquired
2757 static s32 __e1000_read_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 *data,
2773 ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, data,
2780 data, true);
2803 ret_val = e1000e_read_phy_reg_mdic(hw, MAX_PHY_REG_ADDRESS & reg, data);
2815 * @data: pointer to the read data
2818 * the retrieved information in data. Release the acquired semaphore
2821 s32 e1000_read_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 *data)
2823 return __e1000_read_phy_reg_hv(hw, offset, data, false, false);
2830 * @data: pointer to the read data
2833 * in data. Assumes semaphore already acquired.
2835 s32 e1000_read_phy_reg_hv_locked(struct e1000_hw *hw, u32 offset, u16 *data)
2837 return __e1000_read_phy_reg_hv(hw, offset, data, true, false);
2844 * @data: data to write at register offset
2847 * in data. Assumes semaphore already acquired and page already set.
2849 s32 e1000_read_phy_reg_page_hv(struct e1000_hw *hw, u32 offset, u16 *data)
2851 return __e1000_read_phy_reg_hv(hw, offset, data, true, true);
2858 * @data: data to write at register offset
2862 * Acquires semaphore, if necessary, then writes the data to PHY register
2865 static s32 __e1000_write_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 data,
2881 ret_val = e1000_access_phy_wakeup_reg_bm(hw, offset, &data,
2888 &data, false);
2902 !(MAX_PHY_REG_ADDRESS & reg) && (data & BIT(11))) {
2928 data);
2941 * @data: data to write at register offset
2943 * Acquires semaphore then writes the data to PHY register at the offset.
2946 s32 e1000_write_phy_reg_hv(struct e1000_hw *hw, u32 offset, u16 data)
2948 return __e1000_write_phy_reg_hv(hw, offset, data, false, false);
2955 * @data: data to write at register offset
2957 * Writes the data to PHY register at the offset. Assumes semaphore
2960 s32 e1000_write_phy_reg_hv_locked(struct e1000_hw *hw, u32 offset, u16 data)
2962 return __e1000_write_phy_reg_hv(hw, offset, data, true, false);
2969 * @data: data to write at register offset
2971 * Writes the data to PHY register at the offset. Assumes semaphore
2974 s32 e1000_write_phy_reg_page_hv(struct e1000_hw *hw, u32 offset, u16 data)
2976 return __e1000_write_phy_reg_hv(hw, offset, data, true, true);
2997 * @data: pointer to the data to be read or written
3001 * in data. Assumes semaphore already acquired. Note that the procedure
3002 * to access these regs uses the address port and data port to read/write.
3006 u16 *data, bool read)
3027 /* Read or write the data value next */
3029 ret_val = e1000e_read_phy_reg_mdic(hw, data_reg, data);
3031 ret_val = e1000e_write_phy_reg_mdic(hw, data_reg, *data);
3053 u16 data;
3059 ret_val = e1e_rphy(hw, MII_BMCR, &data);
3064 if (data & BMCR_LOOPBACK)
3068 ret_val = e1e_rphy(hw, BM_CS_STATUS, &data);
3072 data &= (BM_CS_STATUS_LINK_UP | BM_CS_STATUS_RESOLVED |
3075 if (data != (BM_CS_STATUS_LINK_UP | BM_CS_STATUS_RESOLVED |
3103 u16 data;
3105 ret_val = e1e_rphy(hw, I82577_PHY_STATUS_2, &data);
3108 phy->cable_polarity = ((data & I82577_PHY_STATUS2_REV_POLARITY)
3172 u16 data;
3190 ret_val = e1e_rphy(hw, I82577_PHY_STATUS_2, &data);
3194 phy->is_mdix = !!(data & I82577_PHY_STATUS2_MDIX);
3196 if ((data & I82577_PHY_STATUS2_SPEED_MASK) ==
3202 ret_val = e1e_rphy(hw, MII_STAT1000, &data);
3206 phy->local_rx = (data & LPA_1000LOCALRXOK)
3209 phy->remote_rx = (data & LPA_1000REMRXOK)