| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Gabriel Fernandez | 5340 | 98.20% | 5 | 29.41% |
| Alain Volmat | 33 | 0.61% | 1 | 5.88% |
| Julia Lawall | 30 | 0.55% | 1 | 5.88% |
| Axel Lin | 25 | 0.46% | 5 | 29.41% |
| Dan Carpenter | 4 | 0.07% | 1 | 5.88% |
| Thomas Gleixner | 2 | 0.04% | 1 | 5.88% |
| Felipe Balbi | 2 | 0.04% | 1 | 5.88% |
| Krzysztof Kozlowski | 1 | 0.02% | 1 | 5.88% |
| Lee Jones | 1 | 0.02% | 1 | 5.88% |
| Total | 5438 | 17 |
// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) 2014 STMicroelectronics * * STMicroelectronics PHY driver MiPHY28lp (for SoC STiH407). * * Author: Alexandre Torgue <alexandre.torgue@st.com> */ #include <linux/platform_device.h> #include <linux/io.h> #include <linux/iopoll.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/of.h> #include <linux/of_platform.h> #include <linux/of_address.h> #include <linux/clk.h> #include <linux/phy/phy.h> #include <linux/delay.h> #include <linux/mfd/syscon.h> #include <linux/regmap.h> #include <linux/reset.h> #include <dt-bindings/phy/phy.h> /* MiPHY registers */ #define MIPHY_CONF_RESET 0x00 #define RST_APPLI_SW BIT(0) #define RST_CONF_SW BIT(1) #define RST_MACRO_SW BIT(2) #define MIPHY_RESET 0x01 #define RST_PLL_SW BIT(0) #define RST_COMP_SW BIT(2) #define MIPHY_STATUS_1 0x02 #define PHY_RDY BIT(0) #define HFC_RDY BIT(1) #define HFC_PLL BIT(2) #define MIPHY_CONTROL 0x04 #define TERM_EN_SW BIT(2) #define DIS_LINK_RST BIT(3) #define AUTO_RST_RX BIT(4) #define PX_RX_POL BIT(5) #define MIPHY_BOUNDARY_SEL 0x0a #define TX_SEL BIT(6) #define SSC_SEL BIT(4) #define GENSEL_SEL BIT(0) #define MIPHY_BOUNDARY_1 0x0b #define MIPHY_BOUNDARY_2 0x0c #define SSC_EN_SW BIT(2) #define MIPHY_PLL_CLKREF_FREQ 0x0d #define MIPHY_SPEED 0x0e #define TX_SPDSEL_80DEC 0 #define TX_SPDSEL_40DEC 1 #define TX_SPDSEL_20DEC 2 #define RX_SPDSEL_80DEC 0 #define RX_SPDSEL_40DEC (1 << 2) #define RX_SPDSEL_20DEC (2 << 2) #define MIPHY_CONF 0x0f #define MIPHY_CTRL_TEST_SEL 0x20 #define MIPHY_CTRL_TEST_1 0x21 #define MIPHY_CTRL_TEST_2 0x22 #define MIPHY_CTRL_TEST_3 0x23 #define MIPHY_CTRL_TEST_4 0x24 #define MIPHY_FEEDBACK_TEST 0x25 #define MIPHY_DEBUG_BUS 0x26 #define MIPHY_DEBUG_STATUS_MSB 0x27 #define MIPHY_DEBUG_STATUS_LSB 0x28 #define MIPHY_PWR_RAIL_1 0x29 #define MIPHY_PWR_RAIL_2 0x2a #define MIPHY_SYNCHAR_CONTROL 0x30 #define MIPHY_COMP_FSM_1 0x3a #define COMP_START BIT(6) #define MIPHY_COMP_FSM_6 0x3f #define COMP_DONE BIT(7) #define MIPHY_COMP_POSTP 0x42 #define MIPHY_TX_CTRL_1 0x49 #define TX_REG_STEP_0V 0 #define TX_REG_STEP_P_25MV 1 #define TX_REG_STEP_P_50MV 2 #define TX_REG_STEP_N_25MV 7 #define TX_REG_STEP_N_50MV 6 #define TX_REG_STEP_N_75MV 5 #define MIPHY_TX_CTRL_2 0x4a #define TX_SLEW_SW_40_PS 0 #define TX_SLEW_SW_80_PS 1 #define TX_SLEW_SW_120_PS 2 #define MIPHY_TX_CTRL_3 0x4b #define MIPHY_TX_CAL_MAN 0x4e #define TX_SLEW_CAL_MAN_EN BIT(0) #define MIPHY_TST_BIAS_BOOST_2 0x62 #define MIPHY_BIAS_BOOST_1 0x63 #define MIPHY_BIAS_BOOST_2 0x64 #define MIPHY_RX_DESBUFF_FDB_2 0x67 #define MIPHY_RX_DESBUFF_FDB_3 0x68 #define MIPHY_SIGDET_COMPENS1 0x69 #define MIPHY_SIGDET_COMPENS2 0x6a #define MIPHY_JITTER_PERIOD 0x6b #define MIPHY_JITTER_AMPLITUDE_1 0x6c #define MIPHY_JITTER_AMPLITUDE_2 0x6d #define MIPHY_JITTER_AMPLITUDE_3 0x6e #define MIPHY_RX_K_GAIN 0x78 #define MIPHY_RX_BUFFER_CTRL 0x7a #define VGA_GAIN BIT(0) #define EQ_DC_GAIN BIT(2) #define EQ_BOOST_GAIN BIT(3) #define MIPHY_RX_VGA_GAIN 0x7b #define MIPHY_RX_EQU_GAIN_1 0x7f #define MIPHY_RX_EQU_GAIN_2 0x80 #define MIPHY_RX_EQU_GAIN_3 0x81 #define MIPHY_RX_CAL_CTRL_1 0x97 #define MIPHY_RX_CAL_CTRL_2 0x98 #define MIPHY_RX_CAL_OFFSET_CTRL 0x99 #define CAL_OFFSET_VGA_64 (0x03 << 0) #define CAL_OFFSET_THRESHOLD_64 (0x03 << 2) #define VGA_OFFSET_POLARITY BIT(4) #define OFFSET_COMPENSATION_EN BIT(6) #define MIPHY_RX_CAL_VGA_STEP 0x9a #define MIPHY_RX_CAL_EYE_MIN 0x9d #define MIPHY_RX_CAL_OPT_LENGTH 0x9f #define MIPHY_RX_LOCK_CTRL_1 0xc1 #define MIPHY_RX_LOCK_SETTINGS_OPT 0xc2 #define MIPHY_RX_LOCK_STEP 0xc4 #define MIPHY_RX_SIGDET_SLEEP_OA 0xc9 #define MIPHY_RX_SIGDET_SLEEP_SEL 0xca #define MIPHY_RX_SIGDET_WAIT_SEL 0xcb #define MIPHY_RX_SIGDET_DATA_SEL 0xcc #define EN_ULTRA_LOW_POWER BIT(0) #define EN_FIRST_HALF BIT(1) #define EN_SECOND_HALF BIT(2) #define EN_DIGIT_SIGNAL_CHECK BIT(3) #define MIPHY_RX_POWER_CTRL_1 0xcd #define MIPHY_RX_POWER_CTRL_2 0xce #define MIPHY_PLL_CALSET_CTRL 0xd3 #define MIPHY_PLL_CALSET_1 0xd4 #define MIPHY_PLL_CALSET_2 0xd5 #define MIPHY_PLL_CALSET_3 0xd6 #define MIPHY_PLL_CALSET_4 0xd7 #define MIPHY_PLL_SBR_1 0xe3 #define SET_NEW_CHANGE BIT(1) #define MIPHY_PLL_SBR_2 0xe4 #define MIPHY_PLL_SBR_3 0xe5 #define MIPHY_PLL_SBR_4 0xe6 #define MIPHY_PLL_COMMON_MISC_2 0xe9 #define START_ACT_FILT BIT(6) #define MIPHY_PLL_SPAREIN 0xeb /* * On STiH407 the glue logic can be different among MiPHY devices; for example: * MiPHY0: OSC_FORCE_EXT means: * 0: 30MHz crystal clk - 1: 100MHz ext clk routed through MiPHY1 * MiPHY1: OSC_FORCE_EXT means: * 1: 30MHz crystal clk - 0: 100MHz ext clk routed through MiPHY1 * Some devices have not the possibility to check if the osc is ready. */ #define MIPHY_OSC_FORCE_EXT BIT(3) #define MIPHY_OSC_RDY BIT(5) #define MIPHY_CTRL_MASK 0x0f #define MIPHY_CTRL_DEFAULT 0 #define MIPHY_CTRL_SYNC_D_EN BIT(2) /* SATA / PCIe defines */ #define SATA_CTRL_MASK 0x07 #define PCIE_CTRL_MASK 0xff #define SATA_CTRL_SELECT_SATA 1 #define SATA_CTRL_SELECT_PCIE 0 #define SYSCFG_PCIE_PCIE_VAL 0x80 #define SATA_SPDMODE 1 #define MIPHY_SATA_BANK_NB 3 #define MIPHY_PCIE_BANK_NB 2 enum { SYSCFG_CTRL, SYSCFG_STATUS, SYSCFG_PCI, SYSCFG_SATA, SYSCFG_REG_MAX, }; struct miphy28lp_phy { struct phy *phy; struct miphy28lp_dev *phydev; void __iomem *base; void __iomem *pipebase; bool osc_force_ext; bool osc_rdy; bool px_rx_pol_inv; bool ssc; bool tx_impedance; struct reset_control *miphy_rst; u32 sata_gen; /* Sysconfig registers offsets needed to configure the device */ u32 syscfg_reg[SYSCFG_REG_MAX]; u8 type; }; struct miphy28lp_dev { struct device *dev; struct regmap *regmap; struct mutex miphy_mutex; struct miphy28lp_phy **phys; int nphys; }; struct miphy_initval { u16 reg; u16 val; }; enum miphy_sata_gen { SATA_GEN1, SATA_GEN2, SATA_GEN3 }; static char *PHY_TYPE_name[] = { "sata-up", "pcie-up", "", "usb3-up" }; struct pll_ratio { int clk_ref; int calset_1; int calset_2; int calset_3; int calset_4; int cal_ctrl; }; static struct pll_ratio sata_pll_ratio = { .clk_ref = 0x1e, .calset_1 = 0xc8, .calset_2 = 0x00, .calset_3 = 0x00, .calset_4 = 0x00, .cal_ctrl = 0x00, }; static struct pll_ratio pcie_pll_ratio = { .clk_ref = 0x1e, .calset_1 = 0xa6, .calset_2 = 0xaa, .calset_3 = 0xaa, .calset_4 = 0x00, .cal_ctrl = 0x00, }; static struct pll_ratio usb3_pll_ratio = { .clk_ref = 0x1e, .calset_1 = 0xa6, .calset_2 = 0xaa, .calset_3 = 0xaa, .calset_4 = 0x04, .cal_ctrl = 0x00, }; struct miphy28lp_pll_gen { int bank; int speed; int bias_boost_1; int bias_boost_2; int tx_ctrl_1; int tx_ctrl_2; int tx_ctrl_3; int rx_k_gain; int rx_vga_gain; int rx_equ_gain_1; int rx_equ_gain_2; int rx_equ_gain_3; int rx_buff_ctrl; }; static struct miphy28lp_pll_gen sata_pll_gen[] = { { .bank = 0x00, .speed = TX_SPDSEL_80DEC | RX_SPDSEL_80DEC, .bias_boost_1 = 0x00, .bias_boost_2 = 0xae, .tx_ctrl_2 = 0x53, .tx_ctrl_3 = 0x00, .rx_buff_ctrl = EQ_BOOST_GAIN | EQ_DC_GAIN | VGA_GAIN, .rx_vga_gain = 0x00, .rx_equ_gain_1 = 0x7d, .rx_equ_gain_2 = 0x56, .rx_equ_gain_3 = 0x00, }, { .bank = 0x01, .speed = TX_SPDSEL_40DEC | RX_SPDSEL_40DEC, .bias_boost_1 = 0x00, .bias_boost_2 = 0xae, .tx_ctrl_2 = 0x72, .tx_ctrl_3 = 0x20, .rx_buff_ctrl = EQ_BOOST_GAIN | EQ_DC_GAIN | VGA_GAIN, .rx_vga_gain = 0x00, .rx_equ_gain_1 = 0x7d, .rx_equ_gain_2 = 0x56, .rx_equ_gain_3 = 0x00, }, { .bank = 0x02, .speed = TX_SPDSEL_20DEC | RX_SPDSEL_20DEC, .bias_boost_1 = 0x00, .bias_boost_2 = 0xae, .tx_ctrl_2 = 0xc0, .tx_ctrl_3 = 0x20, .rx_buff_ctrl = EQ_BOOST_GAIN | EQ_DC_GAIN | VGA_GAIN, .rx_vga_gain = 0x00, .rx_equ_gain_1 = 0x7d, .rx_equ_gain_2 = 0x56, .rx_equ_gain_3 = 0x00, }, }; static struct miphy28lp_pll_gen pcie_pll_gen[] = { { .bank = 0x00, .speed = TX_SPDSEL_40DEC | RX_SPDSEL_40DEC, .bias_boost_1 = 0x00, .bias_boost_2 = 0xa5, .tx_ctrl_1 = TX_REG_STEP_N_25MV, .tx_ctrl_2 = 0x71, .tx_ctrl_3 = 0x60, .rx_k_gain = 0x98, .rx_buff_ctrl = EQ_BOOST_GAIN | EQ_DC_GAIN | VGA_GAIN, .rx_vga_gain = 0x00, .rx_equ_gain_1 = 0x79, .rx_equ_gain_2 = 0x56, }, { .bank = 0x01, .speed = TX_SPDSEL_20DEC | RX_SPDSEL_20DEC, .bias_boost_1 = 0x00, .bias_boost_2 = 0xa5, .tx_ctrl_1 = TX_REG_STEP_N_25MV, .tx_ctrl_2 = 0x70, .tx_ctrl_3 = 0x60, .rx_k_gain = 0xcc, .rx_buff_ctrl = EQ_BOOST_GAIN | EQ_DC_GAIN | VGA_GAIN, .rx_vga_gain = 0x00, .rx_equ_gain_1 = 0x78, .rx_equ_gain_2 = 0x07, }, }; static inline void miphy28lp_set_reset(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; u8 val; /* Putting Macro in reset */ writeb_relaxed(RST_APPLI_SW, base + MIPHY_CONF_RESET); val = RST_APPLI_SW | RST_CONF_SW; writeb_relaxed(val, base + MIPHY_CONF_RESET); writeb_relaxed(RST_APPLI_SW, base + MIPHY_CONF_RESET); /* Bringing the MIPHY-CPU registers out of reset */ if (miphy_phy->type == PHY_TYPE_PCIE) { val = AUTO_RST_RX | TERM_EN_SW; writeb_relaxed(val, base + MIPHY_CONTROL); } else { val = AUTO_RST_RX | TERM_EN_SW | DIS_LINK_RST; writeb_relaxed(val, base + MIPHY_CONTROL); } } static inline void miphy28lp_pll_calibration(struct miphy28lp_phy *miphy_phy, struct pll_ratio *pll_ratio) { void __iomem *base = miphy_phy->base; u8 val; /* Applying PLL Settings */ writeb_relaxed(0x1d, base + MIPHY_PLL_SPAREIN); writeb_relaxed(pll_ratio->clk_ref, base + MIPHY_PLL_CLKREF_FREQ); /* PLL Ratio */ writeb_relaxed(pll_ratio->calset_1, base + MIPHY_PLL_CALSET_1); writeb_relaxed(pll_ratio->calset_2, base + MIPHY_PLL_CALSET_2); writeb_relaxed(pll_ratio->calset_3, base + MIPHY_PLL_CALSET_3); writeb_relaxed(pll_ratio->calset_4, base + MIPHY_PLL_CALSET_4); writeb_relaxed(pll_ratio->cal_ctrl, base + MIPHY_PLL_CALSET_CTRL); writeb_relaxed(TX_SEL, base + MIPHY_BOUNDARY_SEL); val = (0x68 << 1) | TX_SLEW_CAL_MAN_EN; writeb_relaxed(val, base + MIPHY_TX_CAL_MAN); val = VGA_OFFSET_POLARITY | CAL_OFFSET_THRESHOLD_64 | CAL_OFFSET_VGA_64; if (miphy_phy->type != PHY_TYPE_SATA) val |= OFFSET_COMPENSATION_EN; writeb_relaxed(val, base + MIPHY_RX_CAL_OFFSET_CTRL); if (miphy_phy->type == PHY_TYPE_USB3) { writeb_relaxed(0x00, base + MIPHY_CONF); writeb_relaxed(0x70, base + MIPHY_RX_LOCK_STEP); writeb_relaxed(EN_FIRST_HALF, base + MIPHY_RX_SIGDET_SLEEP_OA); writeb_relaxed(EN_FIRST_HALF, base + MIPHY_RX_SIGDET_SLEEP_SEL); writeb_relaxed(EN_FIRST_HALF, base + MIPHY_RX_SIGDET_WAIT_SEL); val = EN_DIGIT_SIGNAL_CHECK | EN_FIRST_HALF; writeb_relaxed(val, base + MIPHY_RX_SIGDET_DATA_SEL); } } static inline void miphy28lp_sata_config_gen(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; int i; for (i = 0; i < ARRAY_SIZE(sata_pll_gen); i++) { struct miphy28lp_pll_gen *gen = &sata_pll_gen[i]; /* Banked settings */ writeb_relaxed(gen->bank, base + MIPHY_CONF); writeb_relaxed(gen->speed, base + MIPHY_SPEED); writeb_relaxed(gen->bias_boost_1, base + MIPHY_BIAS_BOOST_1); writeb_relaxed(gen->bias_boost_2, base + MIPHY_BIAS_BOOST_2); /* TX buffer Settings */ writeb_relaxed(gen->tx_ctrl_2, base + MIPHY_TX_CTRL_2); writeb_relaxed(gen->tx_ctrl_3, base + MIPHY_TX_CTRL_3); /* RX Buffer Settings */ writeb_relaxed(gen->rx_buff_ctrl, base + MIPHY_RX_BUFFER_CTRL); writeb_relaxed(gen->rx_vga_gain, base + MIPHY_RX_VGA_GAIN); writeb_relaxed(gen->rx_equ_gain_1, base + MIPHY_RX_EQU_GAIN_1); writeb_relaxed(gen->rx_equ_gain_2, base + MIPHY_RX_EQU_GAIN_2); writeb_relaxed(gen->rx_equ_gain_3, base + MIPHY_RX_EQU_GAIN_3); } } static inline void miphy28lp_pcie_config_gen(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; int i; for (i = 0; i < ARRAY_SIZE(pcie_pll_gen); i++) { struct miphy28lp_pll_gen *gen = &pcie_pll_gen[i]; /* Banked settings */ writeb_relaxed(gen->bank, base + MIPHY_CONF); writeb_relaxed(gen->speed, base + MIPHY_SPEED); writeb_relaxed(gen->bias_boost_1, base + MIPHY_BIAS_BOOST_1); writeb_relaxed(gen->bias_boost_2, base + MIPHY_BIAS_BOOST_2); /* TX buffer Settings */ writeb_relaxed(gen->tx_ctrl_1, base + MIPHY_TX_CTRL_1); writeb_relaxed(gen->tx_ctrl_2, base + MIPHY_TX_CTRL_2); writeb_relaxed(gen->tx_ctrl_3, base + MIPHY_TX_CTRL_3); writeb_relaxed(gen->rx_k_gain, base + MIPHY_RX_K_GAIN); /* RX Buffer Settings */ writeb_relaxed(gen->rx_buff_ctrl, base + MIPHY_RX_BUFFER_CTRL); writeb_relaxed(gen->rx_vga_gain, base + MIPHY_RX_VGA_GAIN); writeb_relaxed(gen->rx_equ_gain_1, base + MIPHY_RX_EQU_GAIN_1); writeb_relaxed(gen->rx_equ_gain_2, base + MIPHY_RX_EQU_GAIN_2); } } static inline int miphy28lp_wait_compensation(struct miphy28lp_phy *miphy_phy) { u8 val; /* Waiting for Compensation to complete */ return readb_relaxed_poll_timeout(miphy_phy->base + MIPHY_COMP_FSM_6, val, val & COMP_DONE, 1, 5 * USEC_PER_SEC); } static inline int miphy28lp_compensation(struct miphy28lp_phy *miphy_phy, struct pll_ratio *pll_ratio) { void __iomem *base = miphy_phy->base; /* Poll for HFC ready after reset release */ /* Compensation measurement */ writeb_relaxed(RST_PLL_SW | RST_COMP_SW, base + MIPHY_RESET); writeb_relaxed(0x00, base + MIPHY_PLL_COMMON_MISC_2); writeb_relaxed(pll_ratio->clk_ref, base + MIPHY_PLL_CLKREF_FREQ); writeb_relaxed(COMP_START, base + MIPHY_COMP_FSM_1); if (miphy_phy->type == PHY_TYPE_PCIE) writeb_relaxed(RST_PLL_SW, base + MIPHY_RESET); writeb_relaxed(0x00, base + MIPHY_RESET); writeb_relaxed(START_ACT_FILT, base + MIPHY_PLL_COMMON_MISC_2); writeb_relaxed(SET_NEW_CHANGE, base + MIPHY_PLL_SBR_1); /* TX compensation offset to re-center TX impedance */ writeb_relaxed(0x00, base + MIPHY_COMP_POSTP); if (miphy_phy->type == PHY_TYPE_PCIE) return miphy28lp_wait_compensation(miphy_phy); return 0; } static inline void miphy28_usb3_miphy_reset(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; u8 val; /* MIPHY Reset */ writeb_relaxed(RST_APPLI_SW, base + MIPHY_CONF_RESET); writeb_relaxed(0x00, base + MIPHY_CONF_RESET); writeb_relaxed(RST_COMP_SW, base + MIPHY_RESET); val = RST_COMP_SW | RST_PLL_SW; writeb_relaxed(val, base + MIPHY_RESET); writeb_relaxed(0x00, base + MIPHY_PLL_COMMON_MISC_2); writeb_relaxed(0x1e, base + MIPHY_PLL_CLKREF_FREQ); writeb_relaxed(COMP_START, base + MIPHY_COMP_FSM_1); writeb_relaxed(RST_PLL_SW, base + MIPHY_RESET); writeb_relaxed(0x00, base + MIPHY_RESET); writeb_relaxed(START_ACT_FILT, base + MIPHY_PLL_COMMON_MISC_2); writeb_relaxed(0x00, base + MIPHY_CONF); writeb_relaxed(0x00, base + MIPHY_BOUNDARY_1); writeb_relaxed(0x00, base + MIPHY_TST_BIAS_BOOST_2); writeb_relaxed(0x00, base + MIPHY_CONF); writeb_relaxed(SET_NEW_CHANGE, base + MIPHY_PLL_SBR_1); writeb_relaxed(0xa5, base + MIPHY_DEBUG_BUS); writeb_relaxed(0x00, base + MIPHY_CONF); } static void miphy_sata_tune_ssc(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; u8 val; /* Compensate Tx impedance to avoid out of range values */ /* * Enable the SSC on PLL for all banks * SSC Modulation @ 31 KHz and 4000 ppm modulation amp */ val = readb_relaxed(base + MIPHY_BOUNDARY_2); val |= SSC_EN_SW; writeb_relaxed(val, base + MIPHY_BOUNDARY_2); val = readb_relaxed(base + MIPHY_BOUNDARY_SEL); val |= SSC_SEL; writeb_relaxed(val, base + MIPHY_BOUNDARY_SEL); for (val = 0; val < MIPHY_SATA_BANK_NB; val++) { writeb_relaxed(val, base + MIPHY_CONF); /* Add value to each reference clock cycle */ /* and define the period length of the SSC */ writeb_relaxed(0x3c, base + MIPHY_PLL_SBR_2); writeb_relaxed(0x6c, base + MIPHY_PLL_SBR_3); writeb_relaxed(0x81, base + MIPHY_PLL_SBR_4); /* Clear any previous request */ writeb_relaxed(0x00, base + MIPHY_PLL_SBR_1); /* requests the PLL to take in account new parameters */ writeb_relaxed(SET_NEW_CHANGE, base + MIPHY_PLL_SBR_1); /* To be sure there is no other pending requests */ writeb_relaxed(0x00, base + MIPHY_PLL_SBR_1); } } static void miphy_pcie_tune_ssc(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; u8 val; /* Compensate Tx impedance to avoid out of range values */ /* * Enable the SSC on PLL for all banks * SSC Modulation @ 31 KHz and 4000 ppm modulation amp */ val = readb_relaxed(base + MIPHY_BOUNDARY_2); val |= SSC_EN_SW; writeb_relaxed(val, base + MIPHY_BOUNDARY_2); val = readb_relaxed(base + MIPHY_BOUNDARY_SEL); val |= SSC_SEL; writeb_relaxed(val, base + MIPHY_BOUNDARY_SEL); for (val = 0; val < MIPHY_PCIE_BANK_NB; val++) { writeb_relaxed(val, base + MIPHY_CONF); /* Validate Step component */ writeb_relaxed(0x69, base + MIPHY_PLL_SBR_3); writeb_relaxed(0x21, base + MIPHY_PLL_SBR_4); /* Validate Period component */ writeb_relaxed(0x3c, base + MIPHY_PLL_SBR_2); writeb_relaxed(0x21, base + MIPHY_PLL_SBR_4); /* Clear any previous request */ writeb_relaxed(0x00, base + MIPHY_PLL_SBR_1); /* requests the PLL to take in account new parameters */ writeb_relaxed(SET_NEW_CHANGE, base + MIPHY_PLL_SBR_1); /* To be sure there is no other pending requests */ writeb_relaxed(0x00, base + MIPHY_PLL_SBR_1); } } static inline void miphy_tune_tx_impedance(struct miphy28lp_phy *miphy_phy) { /* Compensate Tx impedance to avoid out of range values */ writeb_relaxed(0x02, miphy_phy->base + MIPHY_COMP_POSTP); } static inline int miphy28lp_configure_sata(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; int err; u8 val; /* Putting Macro in reset */ miphy28lp_set_reset(miphy_phy); /* PLL calibration */ miphy28lp_pll_calibration(miphy_phy, &sata_pll_ratio); /* Banked settings Gen1/Gen2/Gen3 */ miphy28lp_sata_config_gen(miphy_phy); /* Power control */ /* Input bridge enable, manual input bridge control */ writeb_relaxed(0x21, base + MIPHY_RX_POWER_CTRL_1); /* Macro out of reset */ writeb_relaxed(0x00, base + MIPHY_CONF_RESET); /* Poll for HFC ready after reset release */ /* Compensation measurement */ err = miphy28lp_compensation(miphy_phy, &sata_pll_ratio); if (err) return err; if (miphy_phy->px_rx_pol_inv) { /* Invert Rx polarity */ val = readb_relaxed(miphy_phy->base + MIPHY_CONTROL); val |= PX_RX_POL; writeb_relaxed(val, miphy_phy->base + MIPHY_CONTROL); } if (miphy_phy->ssc) miphy_sata_tune_ssc(miphy_phy); if (miphy_phy->tx_impedance) miphy_tune_tx_impedance(miphy_phy); return 0; } static inline int miphy28lp_configure_pcie(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; int err; /* Putting Macro in reset */ miphy28lp_set_reset(miphy_phy); /* PLL calibration */ miphy28lp_pll_calibration(miphy_phy, &pcie_pll_ratio); /* Banked settings Gen1/Gen2 */ miphy28lp_pcie_config_gen(miphy_phy); /* Power control */ /* Input bridge enable, manual input bridge control */ writeb_relaxed(0x21, base + MIPHY_RX_POWER_CTRL_1); /* Macro out of reset */ writeb_relaxed(0x00, base + MIPHY_CONF_RESET); /* Poll for HFC ready after reset release */ /* Compensation measurement */ err = miphy28lp_compensation(miphy_phy, &pcie_pll_ratio); if (err) return err; if (miphy_phy->ssc) miphy_pcie_tune_ssc(miphy_phy); if (miphy_phy->tx_impedance) miphy_tune_tx_impedance(miphy_phy); return 0; } static inline void miphy28lp_configure_usb3(struct miphy28lp_phy *miphy_phy) { void __iomem *base = miphy_phy->base; u8 val; /* Putting Macro in reset */ miphy28lp_set_reset(miphy_phy); /* PLL calibration */ miphy28lp_pll_calibration(miphy_phy, &usb3_pll_ratio); /* Writing The Speed Rate */ writeb_relaxed(0x00, base + MIPHY_CONF); val = RX_SPDSEL_20DEC | TX_SPDSEL_20DEC; writeb_relaxed(val, base + MIPHY_SPEED); /* RX Channel compensation and calibration */ writeb_relaxed(0x1c, base + MIPHY_RX_LOCK_SETTINGS_OPT); writeb_relaxed(0x51, base + MIPHY_RX_CAL_CTRL_1); writeb_relaxed(0x70, base + MIPHY_RX_CAL_CTRL_2); val = OFFSET_COMPENSATION_EN | VGA_OFFSET_POLARITY | CAL_OFFSET_THRESHOLD_64 | CAL_OFFSET_VGA_64; writeb_relaxed(val, base + MIPHY_RX_CAL_OFFSET_CTRL); writeb_relaxed(0x22, base + MIPHY_RX_CAL_VGA_STEP); writeb_relaxed(0x0e, base + MIPHY_RX_CAL_OPT_LENGTH); val = EQ_DC_GAIN | VGA_GAIN; writeb_relaxed(val, base + MIPHY_RX_BUFFER_CTRL); writeb_relaxed(0x78, base + MIPHY_RX_EQU_GAIN_1); writeb_relaxed(0x1b, base + MIPHY_SYNCHAR_CONTROL); /* TX compensation offset to re-center TX impedance */ writeb_relaxed(0x02, base + MIPHY_COMP_POSTP); /* Enable GENSEL_SEL and SSC */ /* TX_SEL=0 swing preemp forced by pipe registres */ val = SSC_SEL | GENSEL_SEL; writeb_relaxed(val, base + MIPHY_BOUNDARY_SEL); /* MIPHY Bias boost */ writeb_relaxed(0x00, base + MIPHY_BIAS_BOOST_1); writeb_relaxed(0xa7, base + MIPHY_BIAS_BOOST_2); /* SSC modulation */ writeb_relaxed(SSC_EN_SW, base + MIPHY_BOUNDARY_2); /* MIPHY TX control */ writeb_relaxed(0x00, base + MIPHY_CONF); /* Validate Step component */ writeb_relaxed(0x5a, base + MIPHY_PLL_SBR_3); writeb_relaxed(0xa0, base + MIPHY_PLL_SBR_4); /* Validate Period component */ writeb_relaxed(0x3c, base + MIPHY_PLL_SBR_2); writeb_relaxed(0xa1, base + MIPHY_PLL_SBR_4); /* Clear any previous request */ writeb_relaxed(0x00, base + MIPHY_PLL_SBR_1); /* requests the PLL to take in account new parameters */ writeb_relaxed(0x02, base + MIPHY_PLL_SBR_1); /* To be sure there is no other pending requests */ writeb_relaxed(0x00, base + MIPHY_PLL_SBR_1); /* Rx PI controller settings */ writeb_relaxed(0xca, base + MIPHY_RX_K_GAIN); /* MIPHY RX input bridge control */ /* INPUT_BRIDGE_EN_SW=1, manual input bridge control[0]=1 */ writeb_relaxed(0x21, base + MIPHY_RX_POWER_CTRL_1); writeb_relaxed(0x29, base + MIPHY_RX_POWER_CTRL_1); writeb_relaxed(0x1a, base + MIPHY_RX_POWER_CTRL_2); /* MIPHY Reset for usb3 */ miphy28_usb3_miphy_reset(miphy_phy); } static inline int miphy_is_ready(struct miphy28lp_phy *miphy_phy) { u8 mask = HFC_PLL | HFC_RDY; u8 val; /* * For PCIe and USB3 check only that PLL and HFC are ready * For SATA check also that phy is ready! */ if (miphy_phy->type == PHY_TYPE_SATA) mask |= PHY_RDY; return readb_relaxed_poll_timeout(miphy_phy->base + MIPHY_STATUS_1, val, (val & mask) == mask, 1, 5 * USEC_PER_SEC); } static int miphy_osc_is_ready(struct miphy28lp_phy *miphy_phy) { struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; u32 val; if (!miphy_phy->osc_rdy) return 0; if (!miphy_phy->syscfg_reg[SYSCFG_STATUS]) return -EINVAL; return regmap_read_poll_timeout(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_STATUS], val, val & MIPHY_OSC_RDY, 1, 5 * USEC_PER_SEC); } static int miphy28lp_get_resource_byname(struct device_node *child, char *rname, struct resource *res) { int index; index = of_property_match_string(child, "reg-names", rname); if (index < 0) return -ENODEV; return of_address_to_resource(child, index, res); } static int miphy28lp_get_one_addr(struct device *dev, struct device_node *child, char *rname, void __iomem **base) { struct resource res; int ret; ret = miphy28lp_get_resource_byname(child, rname, &res); if (!ret) { *base = devm_ioremap(dev, res.start, resource_size(&res)); if (!*base) { dev_err(dev, "failed to ioremap %s address region\n" , rname); return -ENOENT; } } return 0; } /* MiPHY reset and sysconf setup */ static int miphy28lp_setup(struct miphy28lp_phy *miphy_phy, u32 miphy_val) { int err; struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; if (!miphy_phy->syscfg_reg[SYSCFG_CTRL]) return -EINVAL; err = reset_control_assert(miphy_phy->miphy_rst); if (err) { dev_err(miphy_dev->dev, "unable to bring out of miphy reset\n"); return err; } if (miphy_phy->osc_force_ext) miphy_val |= MIPHY_OSC_FORCE_EXT; regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_CTRL], MIPHY_CTRL_MASK, miphy_val); err = reset_control_deassert(miphy_phy->miphy_rst); if (err) { dev_err(miphy_dev->dev, "unable to bring out of miphy reset\n"); return err; } return miphy_osc_is_ready(miphy_phy); } static int miphy28lp_init_sata(struct miphy28lp_phy *miphy_phy) { struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; int err, sata_conf = SATA_CTRL_SELECT_SATA; if ((!miphy_phy->syscfg_reg[SYSCFG_SATA]) || (!miphy_phy->syscfg_reg[SYSCFG_PCI]) || (!miphy_phy->base)) return -EINVAL; dev_info(miphy_dev->dev, "sata-up mode, addr 0x%p\n", miphy_phy->base); /* Configure the glue-logic */ sata_conf |= ((miphy_phy->sata_gen - SATA_GEN1) << SATA_SPDMODE); regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_SATA], SATA_CTRL_MASK, sata_conf); regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_PCI], PCIE_CTRL_MASK, SATA_CTRL_SELECT_PCIE); /* MiPHY path and clocking init */ err = miphy28lp_setup(miphy_phy, MIPHY_CTRL_DEFAULT); if (err) { dev_err(miphy_dev->dev, "SATA phy setup failed\n"); return err; } /* initialize miphy */ miphy28lp_configure_sata(miphy_phy); return miphy_is_ready(miphy_phy); } static int miphy28lp_init_pcie(struct miphy28lp_phy *miphy_phy) { struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; int err; if ((!miphy_phy->syscfg_reg[SYSCFG_SATA]) || (!miphy_phy->syscfg_reg[SYSCFG_PCI]) || (!miphy_phy->base) || (!miphy_phy->pipebase)) return -EINVAL; dev_info(miphy_dev->dev, "pcie-up mode, addr 0x%p\n", miphy_phy->base); /* Configure the glue-logic */ regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_SATA], SATA_CTRL_MASK, SATA_CTRL_SELECT_PCIE); regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_PCI], PCIE_CTRL_MASK, SYSCFG_PCIE_PCIE_VAL); /* MiPHY path and clocking init */ err = miphy28lp_setup(miphy_phy, MIPHY_CTRL_DEFAULT); if (err) { dev_err(miphy_dev->dev, "PCIe phy setup failed\n"); return err; } /* initialize miphy */ err = miphy28lp_configure_pcie(miphy_phy); if (err) return err; /* PIPE Wrapper Configuration */ writeb_relaxed(0x68, miphy_phy->pipebase + 0x104); /* Rise_0 */ writeb_relaxed(0x61, miphy_phy->pipebase + 0x105); /* Rise_1 */ writeb_relaxed(0x68, miphy_phy->pipebase + 0x108); /* Fall_0 */ writeb_relaxed(0x61, miphy_phy->pipebase + 0x109); /* Fall-1 */ writeb_relaxed(0x68, miphy_phy->pipebase + 0x10c); /* Threshold_0 */ writeb_relaxed(0x60, miphy_phy->pipebase + 0x10d); /* Threshold_1 */ /* Wait for phy_ready */ return miphy_is_ready(miphy_phy); } static int miphy28lp_init_usb3(struct miphy28lp_phy *miphy_phy) { struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; int err; if ((!miphy_phy->base) || (!miphy_phy->pipebase)) return -EINVAL; dev_info(miphy_dev->dev, "usb3-up mode, addr 0x%p\n", miphy_phy->base); /* MiPHY path and clocking init */ err = miphy28lp_setup(miphy_phy, MIPHY_CTRL_SYNC_D_EN); if (err) { dev_err(miphy_dev->dev, "USB3 phy setup failed\n"); return err; } /* initialize miphy */ miphy28lp_configure_usb3(miphy_phy); /* PIPE Wrapper Configuration */ writeb_relaxed(0x68, miphy_phy->pipebase + 0x23); writeb_relaxed(0x61, miphy_phy->pipebase + 0x24); writeb_relaxed(0x68, miphy_phy->pipebase + 0x26); writeb_relaxed(0x61, miphy_phy->pipebase + 0x27); writeb_relaxed(0x18, miphy_phy->pipebase + 0x29); writeb_relaxed(0x61, miphy_phy->pipebase + 0x2a); /* pipe Wrapper usb3 TX swing de-emph margin PREEMPH[7:4], SWING[3:0] */ writeb_relaxed(0X67, miphy_phy->pipebase + 0x68); writeb_relaxed(0x0d, miphy_phy->pipebase + 0x69); writeb_relaxed(0X67, miphy_phy->pipebase + 0x6a); writeb_relaxed(0X0d, miphy_phy->pipebase + 0x6b); writeb_relaxed(0X67, miphy_phy->pipebase + 0x6c); writeb_relaxed(0X0d, miphy_phy->pipebase + 0x6d); writeb_relaxed(0X67, miphy_phy->pipebase + 0x6e); writeb_relaxed(0X0d, miphy_phy->pipebase + 0x6f); return miphy_is_ready(miphy_phy); } static int miphy28lp_init(struct phy *phy) { struct miphy28lp_phy *miphy_phy = phy_get_drvdata(phy); struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; int ret; mutex_lock(&miphy_dev->miphy_mutex); switch (miphy_phy->type) { case PHY_TYPE_SATA: ret = miphy28lp_init_sata(miphy_phy); break; case PHY_TYPE_PCIE: ret = miphy28lp_init_pcie(miphy_phy); break; case PHY_TYPE_USB3: ret = miphy28lp_init_usb3(miphy_phy); break; default: ret = -EINVAL; break; } mutex_unlock(&miphy_dev->miphy_mutex); return ret; } static int miphy28lp_get_addr(struct miphy28lp_phy *miphy_phy) { struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; struct device_node *phynode = miphy_phy->phy->dev.of_node; int err; if ((miphy_phy->type != PHY_TYPE_SATA) && (miphy_phy->type != PHY_TYPE_PCIE) && (miphy_phy->type != PHY_TYPE_USB3)) { return -EINVAL; } err = miphy28lp_get_one_addr(miphy_dev->dev, phynode, PHY_TYPE_name[miphy_phy->type - PHY_TYPE_SATA], &miphy_phy->base); if (err) return err; if ((miphy_phy->type == PHY_TYPE_PCIE) || (miphy_phy->type == PHY_TYPE_USB3)) { err = miphy28lp_get_one_addr(miphy_dev->dev, phynode, "pipew", &miphy_phy->pipebase); if (err) return err; } return 0; } static struct phy *miphy28lp_xlate(struct device *dev, const struct of_phandle_args *args) { struct miphy28lp_dev *miphy_dev = dev_get_drvdata(dev); struct miphy28lp_phy *miphy_phy = NULL; struct device_node *phynode = args->np; int ret, index = 0; if (args->args_count != 1) { dev_err(dev, "Invalid number of cells in 'phy' property\n"); return ERR_PTR(-EINVAL); } for (index = 0; index < miphy_dev->nphys; index++) if (phynode == miphy_dev->phys[index]->phy->dev.of_node) { miphy_phy = miphy_dev->phys[index]; break; } if (!miphy_phy) { dev_err(dev, "Failed to find appropriate phy\n"); return ERR_PTR(-EINVAL); } miphy_phy->type = args->args[0]; ret = miphy28lp_get_addr(miphy_phy); if (ret < 0) return ERR_PTR(ret); return miphy_phy->phy; } static const struct phy_ops miphy28lp_ops = { .init = miphy28lp_init, .owner = THIS_MODULE, }; static int miphy28lp_probe_resets(struct device_node *node, struct miphy28lp_phy *miphy_phy) { struct miphy28lp_dev *miphy_dev = miphy_phy->phydev; int err; miphy_phy->miphy_rst = of_reset_control_get_shared(node, "miphy-sw-rst"); if (IS_ERR(miphy_phy->miphy_rst)) { dev_err(miphy_dev->dev, "miphy soft reset control not defined\n"); return PTR_ERR(miphy_phy->miphy_rst); } err = reset_control_deassert(miphy_phy->miphy_rst); if (err) { dev_err(miphy_dev->dev, "unable to bring out of miphy reset\n"); return err; } return 0; } static int miphy28lp_of_probe(struct device_node *np, struct miphy28lp_phy *miphy_phy) { int i; u32 ctrlreg; miphy_phy->osc_force_ext = of_property_read_bool(np, "st,osc-force-ext"); miphy_phy->osc_rdy = of_property_read_bool(np, "st,osc-rdy"); miphy_phy->px_rx_pol_inv = of_property_read_bool(np, "st,px_rx_pol_inv"); miphy_phy->ssc = of_property_read_bool(np, "st,ssc-on"); miphy_phy->tx_impedance = of_property_read_bool(np, "st,tx-impedance-comp"); of_property_read_u32(np, "st,sata-gen", &miphy_phy->sata_gen); if (!miphy_phy->sata_gen) miphy_phy->sata_gen = SATA_GEN1; for (i = 0; i < SYSCFG_REG_MAX; i++) { if (!of_property_read_u32_index(np, "st,syscfg", i, &ctrlreg)) miphy_phy->syscfg_reg[i] = ctrlreg; } return 0; } static int miphy28lp_probe(struct platform_device *pdev) { struct device_node *child, *np = pdev->dev.of_node; struct miphy28lp_dev *miphy_dev; struct phy_provider *provider; struct phy *phy; int ret, port = 0; miphy_dev = devm_kzalloc(&pdev->dev, sizeof(*miphy_dev), GFP_KERNEL); if (!miphy_dev) return -ENOMEM; miphy_dev->nphys = of_get_child_count(np); miphy_dev->phys = devm_kcalloc(&pdev->dev, miphy_dev->nphys, sizeof(*miphy_dev->phys), GFP_KERNEL); if (!miphy_dev->phys) return -ENOMEM; miphy_dev->regmap = syscon_regmap_lookup_by_phandle(np, "st,syscfg"); if (IS_ERR(miphy_dev->regmap)) { dev_err(miphy_dev->dev, "No syscfg phandle specified\n"); return PTR_ERR(miphy_dev->regmap); } miphy_dev->dev = &pdev->dev; dev_set_drvdata(&pdev->dev, miphy_dev); mutex_init(&miphy_dev->miphy_mutex); for_each_child_of_node(np, child) { struct miphy28lp_phy *miphy_phy; miphy_phy = devm_kzalloc(&pdev->dev, sizeof(*miphy_phy), GFP_KERNEL); if (!miphy_phy) { ret = -ENOMEM; goto put_child; } miphy_dev->phys[port] = miphy_phy; phy = devm_phy_create(&pdev->dev, child, &miphy28lp_ops); if (IS_ERR(phy)) { dev_err(&pdev->dev, "failed to create PHY\n"); ret = PTR_ERR(phy); goto put_child; } miphy_dev->phys[port]->phy = phy; miphy_dev->phys[port]->phydev = miphy_dev; ret = miphy28lp_of_probe(child, miphy_phy); if (ret) goto put_child; ret = miphy28lp_probe_resets(child, miphy_dev->phys[port]); if (ret) goto put_child; phy_set_drvdata(phy, miphy_dev->phys[port]); port++; } provider = devm_of_phy_provider_register(&pdev->dev, miphy28lp_xlate); return PTR_ERR_OR_ZERO(provider); put_child: of_node_put(child); return ret; } static const struct of_device_id miphy28lp_of_match[] = { {.compatible = "st,miphy28lp-phy", }, {}, }; MODULE_DEVICE_TABLE(of, miphy28lp_of_match); static struct platform_driver miphy28lp_driver = { .probe = miphy28lp_probe, .driver = { .name = "miphy28lp-phy", .of_match_table = miphy28lp_of_match, } }; module_platform_driver(miphy28lp_driver); MODULE_AUTHOR("Alexandre Torgue <alexandre.torgue@st.com>"); MODULE_DESCRIPTION("STMicroelectronics miphy28lp driver"); MODULE_LICENSE("GPL v2");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1