drivers/gpu/drm/msm/adreno/a6xx_gmu.c

1888

if (cmd->enable_by_level && IS_ERR_OR_NULL(gmu->qmp)) {

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

1894

if (IS_ERR_OR_NULL(gmu->qmp))

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

1901

ret = qmp_send(gmu->qmp, "{class: gpu, res: acd, val: %d}", !!cmd->enable_by_level);

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

2002

if (!IS_ERR_OR_NULL(gmu->qmp))

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

2003

qmp_put(gmu->qmp);

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

2295

gmu->qmp = qmp_get(gmu->dev);

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

2296

if (PTR_ERR_OR_ZERO(gmu->qmp) == -EPROBE_DEFER) {

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

2332

if (!IS_ERR_OR_NULL(gmu->qmp))

drivers/gpu/drm/msm/adreno/a6xx_gmu.c

2333

qmp_put(gmu->qmp);

drivers/gpu/drm/msm/adreno/a6xx_gmu.h

123

struct qmp *qmp;

drivers/net/ipa/ipa_power.c

199

struct qmp *qmp = qmp_get(power->dev);

drivers/net/ipa/ipa_power.c

201

if (IS_ERR(qmp)) {

drivers/net/ipa/ipa_power.c

202

if (PTR_ERR(qmp) == -EPROBE_DEFER)

drivers/net/ipa/ipa_power.c

206

qmp = NULL;

drivers/net/ipa/ipa_power.c

208

power->qmp = qmp;

drivers/net/ipa/ipa_power.c

215

qmp_put(power->qmp);

drivers/net/ipa/ipa_power.c

216

power->qmp = NULL;

drivers/net/ipa/ipa_power.c

226

if (!power->qmp)

drivers/net/ipa/ipa_power.c

229

ret = qmp_send(power->qmp, fmt, enable ? '1' : '0');

drivers/net/ipa/ipa_power.c

48

struct qmp *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2242

int (*configure_dp_clocks)(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2243

int (*configure_dp_phy)(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2244

void (*configure_dp_tx)(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2245

int (*calibrate_dp_phy)(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2246

void (*dp_aux_init)(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2319

static void qmp_v3_dp_aux_init(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2320

static void qmp_v3_configure_dp_tx(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2321

static int qmp_v3_configure_dp_clocks(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2322

static int qmp_v3_configure_dp_phy(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2323

static int qmp_v3_calibrate_dp_phy(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2325

static void qmp_v4_dp_aux_init(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2326

static void qmp_v4_configure_dp_tx(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2327

static int qmp_v4_configure_dp_phy(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2328

static int qmp_v4_calibrate_dp_phy(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2330

static void qmp_v8_dp_aux_init(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2331

static int qmp_v8_configure_dp_clocks(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

2332

static int qmp_v8_configure_dp_phy(struct qmp_combo *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3032

static int qmp_combo_dp_serdes_init(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3034

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3035

void __iomem *serdes = qmp->dp_serdes;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3036

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3038

qmp_configure(qmp->dev, serdes, cfg->dp_serdes_tbl,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3043

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl_rbr,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3047

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl_hbr,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3051

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl_hbr2,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3055

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl_hbr3,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3066

static void qmp_v3_dp_aux_init(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3068

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3072

qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3077

qmp->dp_serdes + cfg->regs[QPHY_COM_BIAS_EN_CLKBUFLR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3079

writel(DP_PHY_PD_CTL_PSR_PWRDN, qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3085

qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3091

qmp->dp_serdes + cfg->regs[QPHY_COM_BIAS_EN_CLKBUFLR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3093

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG0);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3094

writel(0x13, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3095

writel(0x24, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3096

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG3);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3097

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG4);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3098

writel(0x26, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG5);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3099

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG6);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3100

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG7);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3101

writel(0xbb, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG8);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3102

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG9);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3103

qmp->dp_aux_cfg = 0;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3108

qmp->dp_dp_phy + QSERDES_V3_DP_PHY_AUX_INTERRUPT_MASK);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3111

static int qmp_combo_configure_dp_swing(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3113

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3114

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3140

writel(voltage_swing_cfg, qmp->dp_tx + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3141

writel(pre_emphasis_cfg, qmp->dp_tx + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3142

writel(voltage_swing_cfg, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3143

writel(pre_emphasis_cfg, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3148

static void qmp_v3_configure_dp_tx(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3150

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3153

if (qmp_combo_configure_dp_swing(qmp) < 0)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3164

writel(drvr_en, qmp->dp_tx + QSERDES_V3_TX_HIGHZ_DRVR_EN);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3165

writel(bias_en, qmp->dp_tx + QSERDES_V3_TX_TRANSCEIVER_BIAS_EN);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3166

writel(drvr_en, qmp->dp_tx2 + QSERDES_V3_TX_HIGHZ_DRVR_EN);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3167

writel(bias_en, qmp->dp_tx2 + QSERDES_V3_TX_TRANSCEIVER_BIAS_EN);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3170

static bool qmp_combo_configure_dp_mode(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3172

bool reverse = (qmp->orientation == TYPEC_ORIENTATION_REVERSE);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3173

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3184

writel(val, qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3187

writel(0x4c, qmp->dp_dp_phy + QSERDES_DP_PHY_MODE);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3189

writel(0x5c, qmp->dp_dp_phy + QSERDES_DP_PHY_MODE);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3194

static int qmp_v3_configure_dp_clocks(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3196

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3199

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3222

writel(phy_vco_div, qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_VCO_DIV]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3224

clk_set_rate(qmp->dp_link_hw.clk, dp_opts->link_rate * 100000);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3225

clk_set_rate(qmp->dp_pixel_hw.clk, pixel_freq);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3230

static int qmp_v3_configure_dp_phy(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3232

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3236

qmp_combo_configure_dp_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3238

writel(0x05, qmp->dp_dp_phy + QSERDES_V3_DP_PHY_TX0_TX1_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3239

writel(0x05, qmp->dp_dp_phy + QSERDES_V3_DP_PHY_TX2_TX3_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3241

ret = qmp_v3_configure_dp_clocks(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3245

writel(0x04, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3246

writel(0x01, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3247

writel(0x05, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3248

writel(0x01, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3249

writel(0x09, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3251

writel(0x20, qmp->dp_serdes + cfg->regs[QPHY_COM_RESETSM_CNTRL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3253

if (readl_poll_timeout(qmp->dp_serdes + cfg->regs[QPHY_COM_C_READY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3260

writel(0x19, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3262

if (readl_poll_timeout(qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3269

writel(0x18, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3271

writel(0x19, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3273

return readl_poll_timeout(qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3284

static int qmp_v3_calibrate_dp_phy(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3289

qmp->dp_aux_cfg++;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3290

qmp->dp_aux_cfg %= ARRAY_SIZE(cfg1_settings);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3291

val = cfg1_settings[qmp->dp_aux_cfg];

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3293

writel(val, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3298

static void qmp_v4_dp_aux_init(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3300

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3304

qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3307

writel(0x17, qmp->dp_serdes + cfg->regs[QPHY_COM_BIAS_EN_CLKBUFLR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3309

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG0);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3310

writel(0x13, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3311

writel(0xa4, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3312

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG3);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3313

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG4);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3314

writel(0x26, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG5);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3315

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG6);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3316

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG7);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3317

writel(0xb7, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG8);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3318

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG9);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3319

qmp->dp_aux_cfg = 0;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3324

qmp->dp_dp_phy + QSERDES_V4_DP_PHY_AUX_INTERRUPT_MASK);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3327

static void qmp_v8_dp_aux_init(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3329

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3333

qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3336

writel(0x1c, qmp->dp_serdes + cfg->regs[QPHY_COM_BIAS_EN_CLKBUFLR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3338

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG0);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3339

writel(0x13, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3340

writel(0x06, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3341

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG3);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3342

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG4);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3343

writel(0x26, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG5);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3344

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG6);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3345

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG7);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3346

writel(0xb7, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG8);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3347

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG9);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3348

qmp->dp_aux_cfg = 0;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3353

qmp->dp_dp_phy + QSERDES_V4_DP_PHY_AUX_INTERRUPT_MASK);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3356

static void qmp_v4_configure_dp_tx(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3358

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3361

writel(0x27, qmp->dp_tx + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3362

writel(0x27, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3364

writel(0x20, qmp->dp_tx + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3365

writel(0x20, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3367

qmp_combo_configure_dp_swing(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3370

static int qmp_v8_configure_dp_clocks(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3372

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3375

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3398

writel(phy_vco_div, qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_VCO_DIV]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3401

writel(0x09, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3403

writel(0x04, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_AUXLESS_SETUP_CYC);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3404

writel(0x08, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_AUXLESS_SILENCE_CYC);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3405

writel(0x08, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_LFPS_CYC);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3406

writel(0x11, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_LFPS_PERIOD);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3408

writel(0x3e, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_TSYNC_OVRD);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3409

writel(0x05, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_TX2_TX3_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3410

writel(0x05, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_TX0_TX1_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3411

writel(0x01, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_AUXLESS_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3412

writel(0x11, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_LFPS_PERIOD);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3413

writel(0x1f, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_LN0_DRV_LVL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3414

writel(0x1f, qmp->dp_dp_phy + QSERDES_V8_DP_PHY_LN1_DRV_LVL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3416

clk_set_rate(qmp->dp_link_hw.clk, dp_opts->link_rate * 100000);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3417

clk_set_rate(qmp->dp_pixel_hw.clk, pixel_freq);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3422

static int qmp_v456_configure_dp_phy(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3424

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3428

writel(0x0f, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG_1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3430

qmp_combo_configure_dp_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3432

writel(0x13, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3433

writel(0xa4, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3435

writel(0x05, qmp->dp_dp_phy + QSERDES_V4_DP_PHY_TX0_TX1_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3436

writel(0x05, qmp->dp_dp_phy + QSERDES_V4_DP_PHY_TX2_TX3_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3438

ret = qmp->cfg->configure_dp_clocks(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3442

writel(0x01, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3443

writel(0x05, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3444

writel(0x01, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3445

writel(0x09, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3447

writel(0x20, qmp->dp_serdes + cfg->regs[QPHY_COM_RESETSM_CNTRL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3449

if (readl_poll_timeout(qmp->dp_serdes + cfg->regs[QPHY_COM_C_READY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3456

if (readl_poll_timeout(qmp->dp_serdes + cfg->regs[QPHY_COM_CMN_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3463

if (readl_poll_timeout(qmp->dp_serdes + cfg->regs[QPHY_COM_CMN_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3470

writel(0x19, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3472

if (readl_poll_timeout(qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3479

if (readl_poll_timeout(qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3489

static int qmp_v4_configure_dp_phy(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3491

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3492

bool reverse = (qmp->orientation == TYPEC_ORIENTATION_REVERSE);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3493

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3498

ret = qmp_v456_configure_dp_phy(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3524

writel(drvr0_en, qmp->dp_tx + cfg->regs[QPHY_TX_HIGHZ_DRVR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3525

writel(bias0_en, qmp->dp_tx + cfg->regs[QPHY_TX_TRANSCEIVER_BIAS_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3526

writel(drvr1_en, qmp->dp_tx2 + cfg->regs[QPHY_TX_HIGHZ_DRVR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3527

writel(bias1_en, qmp->dp_tx2 + cfg->regs[QPHY_TX_TRANSCEIVER_BIAS_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3529

writel(0x18, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3531

writel(0x19, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3533

if (readl_poll_timeout(qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3540

writel(0x0a, qmp->dp_tx + cfg->regs[QPHY_TX_TX_POL_INV]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3541

writel(0x0a, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_POL_INV]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3543

writel(0x27, qmp->dp_tx + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3544

writel(0x27, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3546

writel(0x20, qmp->dp_tx + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3547

writel(0x20, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3552

static int qmp_v8_configure_dp_phy(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3554

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3555

bool reverse = (qmp->orientation == TYPEC_ORIENTATION_REVERSE);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3556

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3561

ret = qmp_v456_configure_dp_phy(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3582

writel(drvr0_en, qmp->dp_tx + cfg->regs[QPHY_TX_HIGHZ_DRVR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3583

writel(bias0_en, qmp->dp_tx + cfg->regs[QPHY_TX_TRANSCEIVER_BIAS_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3584

writel(drvr1_en, qmp->dp_tx2 + cfg->regs[QPHY_TX_HIGHZ_DRVR_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3585

writel(bias1_en, qmp->dp_tx2 + cfg->regs[QPHY_TX_TRANSCEIVER_BIAS_EN]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3587

writel(0x08, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3589

writel(0x09, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3592

if (readl_poll_timeout(qmp->dp_dp_phy + cfg->regs[QPHY_DP_PHY_STATUS],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3599

writel(0x00, qmp->dp_tx + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3600

writel(0x00, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_DRV_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3602

writel(0x2b, qmp->dp_tx + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3603

writel(0x2b, qmp->dp_tx2 + cfg->regs[QPHY_TX_TX_EMP_POST1_LVL]);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3612

static int qmp_v4_calibrate_dp_phy(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3617

qmp->dp_aux_cfg++;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3618

qmp->dp_aux_cfg %= ARRAY_SIZE(cfg1_settings);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3619

val = cfg1_settings[qmp->dp_aux_cfg];

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3621

writel(val, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3629

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3630

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3632

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3634

memcpy(&qmp->dp_opts, dp_opts, sizeof(*dp_opts));

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3635

if (qmp->dp_opts.set_voltages) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3636

cfg->configure_dp_tx(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3637

qmp->dp_opts.set_voltages = 0;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3640

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3647

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3648

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3651

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3654

ret = cfg->calibrate_dp_phy(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3656

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3661

static int qmp_combo_com_init(struct qmp_combo *qmp, bool force)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3663

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3664

void __iomem *com = qmp->com;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3665

void __iomem *pcs_aon = qmp->pcs_aon;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3669

if (!force && qmp->init_count++)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3672

ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3674

dev_err(qmp->dev, "failed to enable regulators, err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3678

ret = reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3680

dev_err(qmp->dev, "reset assert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3684

ret = reset_control_bulk_deassert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3686

dev_err(qmp->dev, "reset deassert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3690

ret = clk_bulk_prepare_enable(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3709

if (qmp->orientation == TYPEC_ORIENTATION_REVERSE)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3717

switch (qmp->qmpphy_mode) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3747

qphy_setbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3753

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3755

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3757

qmp->init_count--;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3762

static int qmp_combo_com_exit(struct qmp_combo *qmp, bool force)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3764

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3766

if (!force && --qmp->init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3769

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3771

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3773

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3780

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3781

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3784

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3786

ret = qmp_combo_com_init(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3790

cfg->dp_aux_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3792

qmp->dp_init_count++;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3795

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3801

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3803

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3805

qmp_combo_com_exit(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3807

qmp->dp_init_count--;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3809

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3816

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3817

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3818

void __iomem *tx = qmp->dp_tx;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3819

void __iomem *tx2 = qmp->dp_tx2;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3821

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3823

qmp_combo_dp_serdes_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3825

qmp_configure_lane(qmp->dev, tx, cfg->dp_tx_tbl, cfg->dp_tx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3826

qmp_configure_lane(qmp->dev, tx2, cfg->dp_tx_tbl, cfg->dp_tx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3829

cfg->configure_dp_tx(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3832

cfg->configure_dp_phy(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3834

qmp->dp_powered_on = true;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3836

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3843

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3845

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3848

writel(DP_PHY_PD_CTL_PSR_PWRDN, qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3850

qmp->dp_powered_on = false;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3852

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3859

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3860

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3861

void __iomem *serdes = qmp->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3862

void __iomem *tx = qmp->tx;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3863

void __iomem *rx = qmp->rx;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3864

void __iomem *tx2 = qmp->tx2;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3865

void __iomem *rx2 = qmp->rx2;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3866

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3867

void __iomem *pcs_usb = qmp->pcs_usb;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3872

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl, cfg->serdes_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3874

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3876

dev_err(qmp->dev, "pipe_clk enable failed err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3881

qmp_configure_lane(qmp->dev, tx, cfg->tx_tbl, cfg->tx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3882

qmp_configure_lane(qmp->dev, tx2, cfg->tx_tbl, cfg->tx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3884

qmp_configure_lane(qmp->dev, rx, cfg->rx_tbl, cfg->rx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3885

qmp_configure_lane(qmp->dev, rx2, cfg->rx_tbl, cfg->rx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3887

qmp_configure(qmp->dev, pcs, cfg->pcs_tbl, cfg->pcs_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3888

qmp_configure(qmp->dev, qmp->pcs_misc, cfg->pcs_misc_tbl, cfg->pcs_misc_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3892

qmp_configure(qmp->dev, pcs_usb, cfg->pcs_usb_tbl,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3908

dev_err(qmp->dev, "phy initialization timed-out\n");

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3915

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3922

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3923

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3925

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3928

qphy_setbits(qmp->pcs, cfg->regs[QPHY_SW_RESET], SW_RESET);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3931

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_START_CTRL],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3935

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL],

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3943

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3946

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3947

ret = qmp_combo_com_init(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3953

qmp_combo_com_exit(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3957

qmp->usb_init_count++;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3960

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3966

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3969

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3974

ret = qmp_combo_com_exit(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3978

qmp->usb_init_count--;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3981

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3987

struct qmp_combo *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

3989

qmp->phy_mode = mode;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4011

static void qmp_combo_enable_autonomous_mode(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4013

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4014

void __iomem *pcs_usb = qmp->pcs_usb ?: qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4015

void __iomem *pcs_misc = qmp->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4016

void __iomem *pcs_aon = qmp->pcs_aon;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4019

if (qmp->phy_mode == PHY_MODE_USB_HOST_SS ||

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4020

qmp->phy_mode == PHY_MODE_USB_DEVICE_SS)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4046

static void qmp_combo_disable_autonomous_mode(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4048

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4049

void __iomem *pcs_usb = qmp->pcs_usb ?: qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4050

void __iomem *pcs_misc = qmp->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4051

void __iomem *pcs_aon = qmp->pcs_aon;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4069

struct qmp_combo *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4071

dev_vdbg(dev, "Suspending QMP phy, mode:%d\n", qmp->phy_mode);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4073

if (!qmp->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4078

qmp_combo_enable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4080

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4081

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4088

struct qmp_combo *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4091

dev_vdbg(dev, "Resuming QMP phy, mode:%d\n", qmp->phy_mode);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4093

if (!qmp->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4098

ret = clk_bulk_prepare_enable(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4102

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4105

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4109

qmp_combo_disable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4119

static int qmp_combo_reset_init(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4121

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4122

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4126

qmp->resets = devm_kcalloc(dev, cfg->num_resets,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4127

sizeof(*qmp->resets), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4128

if (!qmp->resets)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4132

qmp->resets[i].id = cfg->reset_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4134

ret = devm_reset_control_bulk_get_exclusive(dev, cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4141

static int qmp_combo_clk_init(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4143

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4147

qmp->clks = devm_kcalloc(dev, num, sizeof(*qmp->clks), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4148

if (!qmp->clks)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4152

qmp->clks[i].id = qmp_combo_phy_clk_l[i];

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4154

qmp->num_clks = num;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4156

return devm_clk_bulk_get_optional(dev, num, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4182

static int phy_pipe_clk_register(struct qmp_combo *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4184

struct clk_fixed_rate *fixed = &qmp->pipe_clk_fixed;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4188

snprintf(name, sizeof(name), "%s::pipe_clk", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4196

return devm_clk_hw_register(qmp->dev, &fixed->hw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4262

const struct qmp_combo *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4265

qmp = container_of(hw, struct qmp_combo, dp_pixel_hw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4266

dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4302

const struct qmp_combo *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4305

qmp = container_of(hw, struct qmp_combo, dp_link_hw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4306

dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4326

struct qmp_combo *qmp = data;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4335

return &qmp->dp_link_hw;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4337

return &qmp->dp_pixel_hw;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4340

static int phy_dp_clks_register(struct qmp_combo *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4346

snprintf(name, sizeof(name), "%s::link_clk", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4349

qmp->dp_link_hw.init = &init;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4350

ret = devm_clk_hw_register(qmp->dev, &qmp->dp_link_hw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4354

snprintf(name, sizeof(name), "%s::vco_div_clk", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4357

qmp->dp_pixel_hw.init = &init;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4358

ret = devm_clk_hw_register(qmp->dev, &qmp->dp_pixel_hw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4367

struct qmp_combo *qmp = data;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4371

return &qmp->pipe_clk_fixed.hw;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4373

return &qmp->dp_link_hw;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4375

return &qmp->dp_pixel_hw;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4381

static int qmp_combo_register_clocks(struct qmp_combo *qmp, struct device_node *usb_np,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4386

ret = phy_pipe_clk_register(qmp, usb_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4390

ret = phy_dp_clks_register(qmp, dp_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4397

if (usb_np == qmp->dev->of_node)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4398

return devm_of_clk_add_hw_provider(qmp->dev, qmp_combo_clk_hw_get, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4404

&qmp->pipe_clk_fixed.hw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4412

ret = devm_add_action_or_reset(qmp->dev, phy_clk_release_provider, usb_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4416

ret = of_clk_add_hw_provider(dp_np, qmp_dp_clks_hw_get, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4420

return devm_add_action_or_reset(qmp->dev, phy_clk_release_provider, dp_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4427

struct qmp_combo *qmp = typec_switch_get_drvdata(sw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4428

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4430

if (orientation == qmp->orientation || orientation == TYPEC_ORIENTATION_NONE)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4433

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4434

qmp->orientation = orientation;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4436

if (qmp->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4437

if (qmp->usb_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4438

qmp_combo_usb_power_off(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4439

qmp_combo_com_exit(qmp, true);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4441

qmp_combo_com_init(qmp, true);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4442

if (qmp->usb_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4443

qmp_combo_usb_power_on(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4444

if (qmp->dp_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4445

cfg->dp_aux_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4447

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4454

struct qmp_combo *qmp = typec_mux_get_drvdata(mux);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4455

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4459

guard(mutex)(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4488

if (new_mode == qmp->qmpphy_mode) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4489

dev_dbg(qmp->dev, "typec_mux_set: same qmpphy mode, bail out\n");

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4493

if (qmp->qmpphy_mode != QMPPHY_MODE_USB3_ONLY && qmp->dp_powered_on) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4494

dev_dbg(qmp->dev, "typec_mux_set: DP PHY is still in use, delaying switch\n");

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4498

dev_dbg(qmp->dev, "typec_mux_set: switching from qmpphy mode %d to %d\n",

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4499

qmp->qmpphy_mode, new_mode);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4501

qmp->qmpphy_mode = new_mode;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4503

if (qmp->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4504

if (qmp->usb_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4505

qmp_combo_usb_power_off(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4507

if (qmp->dp_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4508

writel(DP_PHY_PD_CTL_PSR_PWRDN, qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4510

qmp_combo_com_exit(qmp, true);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4513

qmp_combo_com_init(qmp, true);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4516

if (qmp->usb_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4517

qmp->usb_init_count--;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4521

qmp_combo_usb_power_on(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4522

if (!qmp->usb_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4523

qmp->usb_init_count++;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4527

if (qmp->dp_init_count)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4528

cfg->dp_aux_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4537

struct qmp_combo *qmp = data;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4539

typec_switch_unregister(qmp->sw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4544

struct qmp_combo *qmp = data;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4546

typec_mux_unregister(qmp->mux);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4549

static int qmp_combo_typec_register(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4553

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4556

sw_desc.drvdata = qmp;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4559

qmp->sw = typec_switch_register(dev, &sw_desc);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4560

if (IS_ERR(qmp->sw)) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4561

dev_err(dev, "Unable to register typec switch: %pe\n", qmp->sw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4562

return PTR_ERR(qmp->sw);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4565

ret = devm_add_action_or_reset(dev, qmp_combo_typec_switch_unregister, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4569

mux_desc.drvdata = qmp;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4572

qmp->mux = typec_mux_register(dev, &mux_desc);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4573

if (IS_ERR(qmp->mux)) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4574

dev_err(dev, "Unable to register typec mux: %pe\n", qmp->mux);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4575

return PTR_ERR(qmp->mux);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4578

return devm_add_action_or_reset(dev, qmp_combo_typec_mux_unregister, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4581

static int qmp_combo_typec_register(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4587

static int qmp_combo_parse_dt_legacy_dp(struct qmp_combo *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4589

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4599

qmp->dp_tx = devm_of_iomap(dev, np, 0, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4600

if (IS_ERR(qmp->dp_tx))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4601

return PTR_ERR(qmp->dp_tx);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4603

qmp->dp_dp_phy = devm_of_iomap(dev, np, 2, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4604

if (IS_ERR(qmp->dp_dp_phy))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4605

return PTR_ERR(qmp->dp_dp_phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4607

qmp->dp_tx2 = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4608

if (IS_ERR(qmp->dp_tx2))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4609

return PTR_ERR(qmp->dp_tx2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4614

static int qmp_combo_parse_dt_legacy_usb(struct qmp_combo *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4616

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4617

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4624

qmp->tx = devm_of_iomap(dev, np, 0, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4625

if (IS_ERR(qmp->tx))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4626

return PTR_ERR(qmp->tx);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4628

qmp->rx = devm_of_iomap(dev, np, 1, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4629

if (IS_ERR(qmp->rx))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4630

return PTR_ERR(qmp->rx);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4632

qmp->pcs = devm_of_iomap(dev, np, 2, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4633

if (IS_ERR(qmp->pcs))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4634

return PTR_ERR(qmp->pcs);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4637

qmp->pcs_usb = qmp->pcs + cfg->pcs_usb_offset;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4639

qmp->tx2 = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4640

if (IS_ERR(qmp->tx2))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4641

return PTR_ERR(qmp->tx2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4643

qmp->rx2 = devm_of_iomap(dev, np, 4, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4644

if (IS_ERR(qmp->rx2))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4645

return PTR_ERR(qmp->rx2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4647

qmp->pcs_misc = devm_of_iomap(dev, np, 5, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4648

if (IS_ERR(qmp->pcs_misc)) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4650

qmp->pcs_misc = NULL;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4653

qmp->pipe_clk = devm_get_clk_from_child(dev, np, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4654

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4655

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4662

static int qmp_combo_parse_dt_legacy(struct qmp_combo *qmp, struct device_node *usb_np,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4665

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4668

qmp->serdes = devm_platform_ioremap_resource(pdev, 0);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4669

if (IS_ERR(qmp->serdes))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4670

return PTR_ERR(qmp->serdes);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4672

qmp->com = devm_platform_ioremap_resource(pdev, 1);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4673

if (IS_ERR(qmp->com))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4674

return PTR_ERR(qmp->com);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4676

qmp->dp_serdes = devm_platform_ioremap_resource(pdev, 2);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4677

if (IS_ERR(qmp->dp_serdes))

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4678

return PTR_ERR(qmp->dp_serdes);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4680

ret = qmp_combo_parse_dt_legacy_usb(qmp, usb_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4684

ret = qmp_combo_parse_dt_legacy_dp(qmp, dp_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4688

ret = devm_clk_bulk_get_all(qmp->dev, &qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4692

qmp->num_clks = ret;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4697

static int qmp_combo_parse_dt(struct qmp_combo *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4699

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4700

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4702

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4713

qmp->com = base + offs->com;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4714

qmp->tx = base + offs->txa;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4715

qmp->rx = base + offs->rxa;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4716

qmp->tx2 = base + offs->txb;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4717

qmp->rx2 = base + offs->rxb;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4719

qmp->serdes = base + offs->usb3_serdes;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4720

qmp->pcs_misc = base + offs->usb3_pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4721

qmp->pcs = base + offs->usb3_pcs;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4723

qmp->pcs_aon = base + offs->usb3_pcs_aon;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4724

qmp->pcs_usb = base + offs->usb3_pcs_usb;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4726

qmp->dp_serdes = base + offs->dp_serdes;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4728

qmp->dp_tx = base + offs->dp_txa;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4729

qmp->dp_tx2 = base + offs->dp_txb;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4731

qmp->dp_tx = base + offs->txa;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4732

qmp->dp_tx2 = base + offs->txb;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4734

qmp->dp_dp_phy = base + offs->dp_dp_phy;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4736

ret = qmp_combo_clk_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4740

qmp->pipe_clk = devm_clk_get(dev, "usb3_pipe");

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4741

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4742

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4751

struct qmp_combo *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4758

return qmp->usb_phy;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4760

return qmp->dp_phy;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4846

struct qmp_combo *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4852

qmp = devm_kzalloc(dev, sizeof(*qmp), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4853

if (!qmp)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4856

qmp->dev = dev;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4857

dev_set_drvdata(dev, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4859

qmp->orientation = TYPEC_ORIENTATION_NORMAL;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4861

qmp->cfg = of_device_get_match_data(dev);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4862

if (!qmp->cfg)

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4865

mutex_init(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4867

ret = qmp_combo_reset_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4871

ret = devm_regulator_bulk_get_const(dev, qmp->cfg->num_vregs,

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4872

qmp->cfg->vreg_list, &qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4885

ret = qmp_combo_parse_dt_legacy(qmp, usb_np, dp_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4890

ret = qmp_combo_parse_dt(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4895

qmp->qmpphy_mode = QMPPHY_MODE_USB3DP;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4899

ret = qmp_combo_typec_register(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4916

qmp->qmpphy_mode = QMPPHY_MODE_USB3_ONLY;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4917

qmp->orientation = usb3_orientation;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4920

qmp->qmpphy_mode = QMPPHY_MODE_DP_ONLY;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4921

qmp->orientation = dp_orientation;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4924

qmp->qmpphy_mode = QMPPHY_MODE_USB3DP;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4925

qmp->orientation = dp_orientation;

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4945

ret = qmp_combo_register_clocks(qmp, usb_np, dp_np);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4950

qmp->usb_phy = devm_phy_create(dev, usb_np, &qmp_combo_usb_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4951

if (IS_ERR(qmp->usb_phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4952

ret = PTR_ERR(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4957

phy_set_drvdata(qmp->usb_phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4959

qmp->dp_phy = devm_phy_create(dev, dp_np, &qmp_combo_dp_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4960

if (IS_ERR(qmp->dp_phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4961

ret = PTR_ERR(qmp->dp_phy);

drivers/phy/qualcomm/phy-qcom-qmp-combo.c

4966

phy_set_drvdata(qmp->dp_phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

191

struct qcom_qmp *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

282

struct qcom_qmp *qmp = qphy->qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

291

qmp_configure(qmp->dev, serdes, serdes_tbl, serdes_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

301

dev_err(qmp->dev,

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

311

struct qcom_qmp *qmp = qphy->qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

316

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

317

if (qmp->init_count++) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

318

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

322

ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

324

dev_err(qmp->dev, "failed to enable regulators, err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

328

ret = reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

330

dev_err(qmp->dev, "reset assert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

334

ret = reset_control_bulk_deassert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

336

dev_err(qmp->dev, "reset deassert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

340

ret = clk_bulk_prepare_enable(cfg->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

347

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

352

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

354

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

356

qmp->init_count--;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

357

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

364

struct qcom_qmp *qmp = qphy->qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

368

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

369

if (--qmp->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

370

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

381

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

383

clk_bulk_disable_unprepare(cfg->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

385

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

387

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

395

struct qcom_qmp *qmp = qphy->qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

397

dev_vdbg(qmp->dev, "Initializing QMP phy\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

409

struct qcom_qmp *qmp = qphy->qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

422

dev_err(qmp->dev, "lane%d reset deassert failed\n",

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

429

dev_err(qmp->dev, "pipe_clk enable failed err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

434

qmp_configure_lane(qmp->dev, tx, cfg->tx_tbl, cfg->tx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

435

qmp_configure_lane(qmp->dev, rx, cfg->rx_tbl, cfg->rx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

436

qmp_configure(qmp->dev, pcs, cfg->pcs_tbl, cfg->pcs_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

458

dev_err(qmp->dev, "phy initialization timed-out\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

531

struct qcom_qmp *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

535

qmp->vregs = devm_kcalloc(dev, num, sizeof(*qmp->vregs), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

536

if (!qmp->vregs)

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

540

qmp->vregs[i].supply = cfg->vreg_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

542

return devm_regulator_bulk_get(dev, num, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

547

struct qcom_qmp *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

551

qmp->resets = devm_kcalloc(dev, cfg->num_resets,

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

552

sizeof(*qmp->resets), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

553

if (!qmp->resets)

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

557

qmp->resets[i].id = cfg->reset_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

559

ret = devm_reset_control_bulk_get_exclusive(dev, cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

568

struct qcom_qmp *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

572

qmp->clks = devm_kcalloc(dev, num, sizeof(*qmp->clks), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

573

if (!qmp->clks)

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

577

qmp->clks[i].id = cfg->clk_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

579

return devm_clk_bulk_get(dev, num, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

605

static int phy_pipe_clk_register(struct qcom_qmp *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

613

dev_err(qmp->dev, "%pOFn: No clock-output-names\n", np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

617

fixed = devm_kzalloc(qmp->dev, sizeof(*fixed), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

627

ret = devm_clk_hw_register(qmp->dev, &fixed->hw);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

639

return devm_add_action_or_reset(qmp->dev, phy_clk_release_provider, np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

656

struct qcom_qmp *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

708

qphy->qmp = qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

709

qmp->phys[id] = qphy;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

726

struct qcom_qmp *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

734

qmp = devm_kzalloc(dev, sizeof(*qmp), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

735

if (!qmp)

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

738

qmp->dev = dev;

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

739

dev_set_drvdata(dev, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

751

mutex_init(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

770

qmp->phys = devm_kcalloc(dev, num, sizeof(*qmp->phys), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

771

if (!qmp->phys)

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

788

ret = phy_pipe_clk_register(qmp, child);

drivers/phy/qualcomm/phy-qcom-qmp-pcie-msm8996.c

790

dev_err(qmp->dev,

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4651

static void qmp_pcie_init_port_b(struct qmp_pcie *qmp, const struct qmp_phy_cfg_tbls *tbls)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4653

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4657

serdes = qmp->port_b + offs->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4658

tx3 = qmp->port_b + offs->tx;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4659

rx3 = qmp->port_b + offs->rx;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4660

tx4 = qmp->port_b + offs->tx2;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4661

rx4 = qmp->port_b + offs->rx2;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4662

pcs = qmp->port_b + offs->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4663

pcs_misc = qmp->port_b + offs->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4664

ln_shrd = qmp->port_b + offs->ln_shrd;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4666

qmp_configure(qmp->dev, serdes, tbls->serdes, tbls->serdes_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4667

qmp_configure(qmp->dev, serdes, cfg->serdes_4ln_tbl, cfg->serdes_4ln_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4669

qmp_configure_lane(qmp->dev, tx3, tbls->tx, tbls->tx_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4670

qmp_configure_lane(qmp->dev, rx3, tbls->rx, tbls->rx_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4672

qmp_configure_lane(qmp->dev, tx4, tbls->tx, tbls->tx_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4673

qmp_configure_lane(qmp->dev, rx4, tbls->rx, tbls->rx_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4675

qmp_configure(qmp->dev, pcs, tbls->pcs, tbls->pcs_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4676

qmp_configure(qmp->dev, pcs_misc, tbls->pcs_misc, tbls->pcs_misc_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4678

qmp_configure(qmp->dev, ln_shrd, tbls->ln_shrd, tbls->ln_shrd_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4681

static void qmp_pcie_init_registers(struct qmp_pcie *qmp, const struct qmp_phy_cfg_tbls *tbls)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4683

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4684

void __iomem *serdes = qmp->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4685

void __iomem *tx = qmp->tx;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4686

void __iomem *rx = qmp->rx;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4687

void __iomem *tx2 = qmp->tx2;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4688

void __iomem *rx2 = qmp->rx2;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4689

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4690

void __iomem *pcs_misc = qmp->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4691

void __iomem *pcs_lane1 = qmp->pcs_lane1;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4692

void __iomem *ln_shrd = qmp->ln_shrd;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4697

qmp_configure(qmp->dev, serdes, tbls->serdes, tbls->serdes_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4703

qmp_configure(qmp->dev, qmp->txz, tbls->txz, tbls->txz_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4704

qmp_configure(qmp->dev, qmp->rxz, tbls->rxz, tbls->rxz_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4706

qmp_configure_lane(qmp->dev, tx, tbls->tx, tbls->tx_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4707

qmp_configure_lane(qmp->dev, rx, tbls->rx, tbls->rx_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4710

qmp_configure_lane(qmp->dev, tx2, tbls->tx, tbls->tx_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4711

qmp_configure_lane(qmp->dev, rx2, tbls->rx, tbls->rx_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4714

qmp_configure(qmp->dev, pcs, tbls->pcs, tbls->pcs_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4715

qmp_configure(qmp->dev, pcs_misc, tbls->pcs_misc, tbls->pcs_misc_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4716

qmp_configure(qmp->dev, pcs_lane1, tbls->pcs_lane1, tbls->pcs_lane1_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4718

if (cfg->lanes >= 4 && qmp->tcsr_4ln_config) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4719

qmp_configure(qmp->dev, serdes, cfg->serdes_4ln_tbl,

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4721

qmp_pcie_init_port_b(qmp, tbls);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4724

qmp_configure(qmp->dev, ln_shrd, tbls->ln_shrd, tbls->ln_shrd_num);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4729

struct qmp_pcie *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4730

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4731

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4743

qmp->skip_init = qmp->nocsr_reset &&

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4747

if (!qmp->skip_init && !cfg->tbls.serdes_num) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4748

dev_err(qmp->dev, "Init sequence not available\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4752

ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4754

dev_err(qmp->dev, "failed to enable regulators, err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4762

if (!qmp->skip_init) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4763

ret = reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4765

dev_err(qmp->dev, "reset assert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4770

ret = reset_control_assert(qmp->nocsr_reset);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4772

dev_err(qmp->dev, "no-csr reset assert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4778

if (!qmp->skip_init) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4779

ret = reset_control_bulk_deassert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4781

dev_err(qmp->dev, "reset deassert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4786

ret = clk_bulk_prepare_enable(ARRAY_SIZE(qmp_pciephy_clk_l), qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4793

if (!qmp->skip_init)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4794

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4796

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4803

struct qmp_pcie *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4804

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4806

if (qmp->nocsr_reset)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4807

reset_control_assert(qmp->nocsr_reset);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4809

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4811

clk_bulk_disable_unprepare(ARRAY_SIZE(qmp_pciephy_clk_l), qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4813

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4820

struct qmp_pcie *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4821

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4823

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4832

if (qmp->skip_init)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4838

if (qmp->mode == PHY_MODE_PCIE_RC)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4843

qmp_pcie_init_registers(qmp, &cfg->tbls);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4844

qmp_pcie_init_registers(qmp, mode_tbls);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4847

ret = clk_bulk_prepare_enable(qmp->num_pipe_clks, qmp->pipe_clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4851

ret = reset_control_deassert(qmp->nocsr_reset);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4853

dev_err(qmp->dev, "no-csr reset deassert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4857

if (qmp->skip_init)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4875

dev_err(qmp->dev, "phy initialization timed-out\n");

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4882

clk_bulk_disable_unprepare(qmp->num_pipe_clks, qmp->pipe_clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4889

struct qmp_pcie *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4890

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4892

clk_bulk_disable_unprepare(qmp->num_pipe_clks, qmp->pipe_clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4900

if (qmp->nocsr_reset)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4904

qphy_setbits(qmp->pcs, cfg->regs[QPHY_SW_RESET], SW_RESET);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4907

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_START_CTRL],

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4911

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL],

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4946

struct qmp_pcie *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4951

qmp->mode = submode;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4968

static int qmp_pcie_vreg_init(struct qmp_pcie *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4970

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4971

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4975

qmp->vregs = devm_kcalloc(dev, num, sizeof(*qmp->vregs), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4976

if (!qmp->vregs)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4980

qmp->vregs[i].supply = cfg->vreg_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4982

return devm_regulator_bulk_get(dev, num, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4985

static int qmp_pcie_reset_init(struct qmp_pcie *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4987

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4988

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4992

qmp->resets = devm_kcalloc(dev, cfg->num_resets,

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4993

sizeof(*qmp->resets), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4994

if (!qmp->resets)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

4998

qmp->resets[i].id = cfg->reset_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5000

ret = devm_reset_control_bulk_get_exclusive(dev, cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5004

qmp->nocsr_reset = devm_reset_control_get_optional_exclusive(dev, "phy_nocsr");

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5005

if (IS_ERR(qmp->nocsr_reset))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5006

return dev_err_probe(dev, PTR_ERR(qmp->nocsr_reset),

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5012

static int qmp_pcie_clk_init(struct qmp_pcie *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5014

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5018

qmp->clks = devm_kcalloc(dev, num, sizeof(*qmp->clks), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5019

if (!qmp->clks)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5023

qmp->clks[i].id = qmp_pciephy_clk_l[i];

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5025

return devm_clk_bulk_get_optional(dev, num, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5051

static int phy_pipe_clk_register(struct qmp_pcie *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5053

struct clk_fixed_rate *fixed = &qmp->pipe_clk_fixed;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5059

dev_err(qmp->dev, "%pOFn: No clock-output-names\n", np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5069

if (qmp->cfg->pipe_clock_rate)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5070

fixed->fixed_rate = qmp->cfg->pipe_clock_rate;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5076

return devm_clk_hw_register(qmp->dev, &fixed->hw);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5097

static int phy_aux_clk_register(struct qmp_pcie *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5099

struct clk_fixed_rate *fixed = &qmp->aux_clk_fixed;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5103

snprintf(name, sizeof(name), "%s::phy_aux_clk", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5108

fixed->fixed_rate = qmp->cfg->aux_clock_rate;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5111

return devm_clk_hw_register(qmp->dev, &fixed->hw);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5116

struct qmp_pcie *qmp = data;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5120

return &qmp->pipe_clk_fixed.hw;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5124

return &qmp->pipe_clk_fixed.hw;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5126

return &qmp->aux_clk_fixed.hw;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5132

static int qmp_pcie_register_clocks(struct qmp_pcie *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5136

ret = phy_pipe_clk_register(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5140

if (qmp->cfg->aux_clock_rate) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5141

ret = phy_aux_clk_register(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5145

ret = of_clk_add_hw_provider(np, qmp_pcie_clk_hw_get, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5149

ret = of_clk_add_hw_provider(np, of_clk_hw_simple_get, &qmp->pipe_clk_fixed.hw);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5158

return devm_add_action_or_reset(qmp->dev, phy_clk_release_provider, np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5161

static int qmp_pcie_parse_dt_legacy(struct qmp_pcie *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5163

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5164

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5165

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5168

qmp->serdes = devm_platform_ioremap_resource(pdev, 0);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5169

if (IS_ERR(qmp->serdes))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5170

return PTR_ERR(qmp->serdes);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5178

qmp->tx = devm_of_iomap(dev, np, 0, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5179

if (IS_ERR(qmp->tx))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5180

return PTR_ERR(qmp->tx);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5183

qmp->rx = qmp->tx;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5185

qmp->rx = devm_of_iomap(dev, np, 1, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5186

if (IS_ERR(qmp->rx))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5187

return PTR_ERR(qmp->rx);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5189

qmp->pcs = devm_of_iomap(dev, np, 2, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5190

if (IS_ERR(qmp->pcs))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5191

return PTR_ERR(qmp->pcs);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5194

qmp->tx2 = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5195

if (IS_ERR(qmp->tx2))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5196

return PTR_ERR(qmp->tx2);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5198

qmp->rx2 = devm_of_iomap(dev, np, 4, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5199

if (IS_ERR(qmp->rx2))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5200

return PTR_ERR(qmp->rx2);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5202

qmp->pcs_misc = devm_of_iomap(dev, np, 5, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5204

qmp->pcs_misc = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5207

if (IS_ERR(qmp->pcs_misc) &&

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5209

qmp->pcs_misc = qmp->pcs + 0x400;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5211

if (IS_ERR(qmp->pcs_misc)) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5215

return PTR_ERR(qmp->pcs_misc);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5223

if (!IS_ERR(qmp->pcs_misc) && cfg->offsets->pcs_lane1 != 0)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5224

qmp->pcs_lane1 = qmp->pcs_misc +

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5233

qmp->num_pipe_clks = 1;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5234

qmp->pipe_clks[0].id = "pipe";

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5235

qmp->pipe_clks[0].clk = clk;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5240

static int qmp_pcie_get_4ln_config(struct qmp_pcie *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5246

tcsr = syscon_regmap_lookup_by_phandle_args(qmp->dev->of_node,

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5254

dev_err(qmp->dev, "failed to lookup syscon: %d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5260

dev_err(qmp->dev, "failed to read tcsr: %d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5264

qmp->tcsr_4ln_config = ret;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5266

dev_dbg(qmp->dev, "4ln_config_sel = %d\n", qmp->tcsr_4ln_config);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5271

static int qmp_pcie_parse_dt(struct qmp_pcie *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5273

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5274

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5276

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5283

ret = qmp_pcie_get_4ln_config(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5291

qmp->serdes = base + offs->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5292

qmp->pcs = base + offs->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5293

qmp->pcs_misc = base + offs->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5294

qmp->pcs_lane1 = base + offs->pcs_lane1;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5295

qmp->tx = base + offs->tx;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5296

qmp->rx = base + offs->rx;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5299

qmp->tx2 = base + offs->tx2;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5300

qmp->rx2 = base + offs->rx2;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5303

if (qmp->cfg->lanes >= 4 && qmp->tcsr_4ln_config) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5304

qmp->port_b = devm_platform_ioremap_resource(pdev, 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5305

if (IS_ERR(qmp->port_b))

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5306

return PTR_ERR(qmp->port_b);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5309

qmp->txz = base + offs->txz;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5310

qmp->rxz = base + offs->rxz;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5313

qmp->ln_shrd = base + offs->ln_shrd;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5315

qmp->num_pipe_clks = 2;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5316

qmp->pipe_clks[0].id = "pipe";

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5317

qmp->pipe_clks[1].id = "pipediv2";

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5319

ret = devm_clk_bulk_get(dev, 1, qmp->pipe_clks);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5323

ret = devm_clk_bulk_get_optional(dev, qmp->num_pipe_clks - 1, qmp->pipe_clks + 1);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5335

struct qmp_pcie *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5338

qmp = devm_kzalloc(dev, sizeof(*qmp), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5339

if (!qmp)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5342

qmp->dev = dev;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5344

qmp->cfg = of_device_get_match_data(dev);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5345

if (!qmp->cfg)

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5348

WARN_ON_ONCE(!qmp->cfg->pwrdn_ctrl);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5349

WARN_ON_ONCE(!qmp->cfg->phy_status);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5351

ret = qmp_pcie_clk_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5355

ret = qmp_pcie_reset_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5359

ret = qmp_pcie_vreg_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5366

ret = qmp_pcie_parse_dt_legacy(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5369

ret = qmp_pcie_parse_dt(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5374

ret = qmp_pcie_register_clocks(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5378

qmp->mode = PHY_MODE_PCIE_RC;

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5380

qmp->phy = devm_phy_create(dev, np, &qmp_pcie_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5381

if (IS_ERR(qmp->phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5382

ret = PTR_ERR(qmp->phy);

drivers/phy/qualcomm/phy-qcom-qmp-pcie.c

5387

phy_set_drvdata(qmp->phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1847

static void qmp_ufs_serdes_init(struct qmp_ufs *qmp, const struct qmp_phy_cfg_tbls *tbls)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1849

void __iomem *serdes = qmp->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1851

qmp_configure(qmp->dev, serdes, tbls->serdes, tbls->serdes_num);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1854

static void qmp_ufs_lanes_init(struct qmp_ufs *qmp, const struct qmp_phy_cfg_tbls *tbls)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1856

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1857

void __iomem *tx = qmp->tx;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1858

void __iomem *rx = qmp->rx;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1860

qmp_configure_lane(qmp->dev, tx, tbls->tx, tbls->tx_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1861

qmp_configure_lane(qmp->dev, rx, tbls->rx, tbls->rx_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1864

qmp_configure_lane(qmp->dev, qmp->tx2, tbls->tx, tbls->tx_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1865

qmp_configure_lane(qmp->dev, qmp->rx2, tbls->rx, tbls->rx_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1869

static void qmp_ufs_pcs_init(struct qmp_ufs *qmp, const struct qmp_phy_cfg_tbls *tbls)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1871

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1873

qmp_configure(qmp->dev, pcs, tbls->pcs, tbls->pcs_num);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1876

static int qmp_ufs_get_gear_overlay(struct qmp_ufs *qmp, const struct qmp_phy_cfg *cfg)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1889

if (qmp->submode == max_gear)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1902

static void qmp_ufs_init_all(struct qmp_ufs *qmp, const struct qmp_phy_cfg_tbls *tbls)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1904

qmp_ufs_serdes_init(qmp, tbls);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1905

qmp_ufs_lanes_init(qmp, tbls);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1906

qmp_ufs_pcs_init(qmp, tbls);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1909

static void qmp_ufs_init_registers(struct qmp_ufs *qmp, const struct qmp_phy_cfg *cfg)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1913

qmp_ufs_init_all(qmp, &cfg->tbls);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1915

i = qmp_ufs_get_gear_overlay(qmp, cfg);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1917

qmp_ufs_init_all(qmp, &cfg->tbls_hs_overlay[i]);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1920

if (qmp->mode == PHY_MODE_UFS_HS_B)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1921

qmp_ufs_init_all(qmp, &cfg->tbls_hs_b);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1926

struct qmp_ufs *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1927

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1928

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1931

ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1933

dev_err(qmp->dev, "failed to enable regulators, err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1937

ret = clk_bulk_prepare_enable(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1945

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1951

struct qmp_ufs *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1952

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1953

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1958

ret = reset_control_assert(qmp->ufs_reset);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1962

qmp_ufs_init_registers(qmp, cfg);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1964

ret = reset_control_deassert(qmp->ufs_reset);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1979

dev_err(qmp->dev, "phy initialization timed-out\n");

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1988

struct qmp_ufs *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1989

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1992

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL],

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1995

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

1997

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2004

struct qmp_ufs *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2005

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2008

dev_err(qmp->dev, "Invalid PHY submode %d\n", submode);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2012

qmp->mode = mode;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2013

qmp->submode = submode;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2020

struct qmp_ufs *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2021

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2032

if (!qmp->ufs_reset) {

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2033

qmp->ufs_reset =

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2034

devm_reset_control_get_exclusive(qmp->dev, "ufsphy");

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2036

if (IS_ERR(qmp->ufs_reset)) {

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2037

ret = PTR_ERR(qmp->ufs_reset);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2038

dev_err(qmp->dev, "failed to get PHY reset: %d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2039

qmp->ufs_reset = NULL;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2057

static int qmp_ufs_clk_init(struct qmp_ufs *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2059

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2061

qmp->num_clks = devm_clk_bulk_get_all(dev, &qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2062

if (qmp->num_clks < 0)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2063

return qmp->num_clks;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2075

static int qmp_ufs_register_clocks(struct qmp_ufs *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2082

clk_data = devm_kzalloc(qmp->dev,

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2090

snprintf(name, sizeof(name), "%s::rx_symbol_0", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2091

hw = devm_clk_hw_register_fixed_rate(qmp->dev, name, NULL, 0, 0);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2097

snprintf(name, sizeof(name), "%s::rx_symbol_1", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2098

hw = devm_clk_hw_register_fixed_rate(qmp->dev, name, NULL, 0, 0);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2104

snprintf(name, sizeof(name), "%s::tx_symbol_0", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2105

hw = devm_clk_hw_register_fixed_rate(qmp->dev, name, NULL, 0, 0);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2118

return devm_add_action_or_reset(qmp->dev, qmp_ufs_clk_release_provider, np);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2121

static int qmp_ufs_parse_dt_legacy(struct qmp_ufs *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2123

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2124

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2125

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2127

qmp->serdes = devm_platform_ioremap_resource(pdev, 0);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2128

if (IS_ERR(qmp->serdes))

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2129

return PTR_ERR(qmp->serdes);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2137

qmp->tx = devm_of_iomap(dev, np, 0, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2138

if (IS_ERR(qmp->tx))

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2139

return PTR_ERR(qmp->tx);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2141

qmp->rx = devm_of_iomap(dev, np, 1, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2142

if (IS_ERR(qmp->rx))

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2143

return PTR_ERR(qmp->rx);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2145

qmp->pcs = devm_of_iomap(dev, np, 2, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2146

if (IS_ERR(qmp->pcs))

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2147

return PTR_ERR(qmp->pcs);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2150

qmp->tx2 = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2151

if (IS_ERR(qmp->tx2))

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2152

return PTR_ERR(qmp->tx2);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2154

qmp->rx2 = devm_of_iomap(dev, np, 4, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2155

if (IS_ERR(qmp->rx2))

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2156

return PTR_ERR(qmp->rx2);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2158

qmp->pcs_misc = devm_of_iomap(dev, np, 5, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2160

qmp->pcs_misc = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2163

if (IS_ERR(qmp->pcs_misc))

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2169

static int qmp_ufs_parse_dt(struct qmp_ufs *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2171

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2172

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2183

qmp->serdes = base + offs->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2184

qmp->pcs = base + offs->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2185

qmp->tx = base + offs->tx;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2186

qmp->rx = base + offs->rx;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2189

qmp->tx2 = base + offs->tx2;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2190

qmp->rx2 = base + offs->rx2;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2201

struct qmp_ufs *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2204

qmp = devm_kzalloc(dev, sizeof(*qmp), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2205

if (!qmp)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2208

qmp->dev = dev;

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2210

qmp->cfg = of_device_get_match_data(dev);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2211

if (!qmp->cfg)

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2214

ret = qmp_ufs_clk_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2218

ret = devm_regulator_bulk_get_const(dev, qmp->cfg->num_vregs,

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2219

qmp->cfg->vreg_list,

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2220

&qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2227

ret = qmp_ufs_parse_dt_legacy(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2230

ret = qmp_ufs_parse_dt(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2235

ret = qmp_ufs_register_clocks(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2239

qmp->phy = devm_phy_create(dev, np, &qcom_qmp_ufs_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2240

if (IS_ERR(qmp->phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2241

ret = PTR_ERR(qmp->phy);

drivers/phy/qualcomm/phy-qcom-qmp-ufs.c

2246

phy_set_drvdata(qmp->phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1006

struct qmp_usb *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1007

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1010

dev_vdbg(dev, "Resuming QMP phy, mode:%d\n", qmp->mode);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1012

if (!qmp->phy->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1017

ret = clk_bulk_prepare_enable(cfg->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1021

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1024

clk_bulk_disable_unprepare(cfg->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1028

qmp_usb_legacy_disable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1038

static int qmp_usb_legacy_vreg_init(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1040

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1041

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1045

qmp->vregs = devm_kcalloc(dev, num, sizeof(*qmp->vregs), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1046

if (!qmp->vregs)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1050

qmp->vregs[i].supply = cfg->vreg_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1052

return devm_regulator_bulk_get(dev, num, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1055

static int qmp_usb_legacy_reset_init(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1057

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1058

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1062

qmp->resets = devm_kcalloc(dev, cfg->num_resets,

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1063

sizeof(*qmp->resets), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1064

if (!qmp->resets)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1068

qmp->resets[i].id = cfg->reset_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1070

ret = devm_reset_control_bulk_get_exclusive(dev, cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1077

static int qmp_usb_legacy_clk_init(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1079

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1080

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1084

qmp->clks = devm_kcalloc(dev, num, sizeof(*qmp->clks), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1085

if (!qmp->clks)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1089

qmp->clks[i].id = cfg->clk_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1091

return devm_clk_bulk_get(dev, num, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1117

static int phy_pipe_clk_register(struct qmp_usb *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1119

struct clk_fixed_rate *fixed = &qmp->pipe_clk_fixed;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1125

dev_err(qmp->dev, "%pOFn: No clock-output-names\n", np);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1135

ret = devm_clk_hw_register(qmp->dev, &fixed->hw);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1147

return devm_add_action_or_reset(qmp->dev, phy_clk_release_provider, np);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1150

static int qmp_usb_legacy_parse_dt_legacy(struct qmp_usb *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1152

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1153

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1154

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1156

qmp->serdes = devm_platform_ioremap_resource(pdev, 0);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1157

if (IS_ERR(qmp->serdes))

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1158

return PTR_ERR(qmp->serdes);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1160

qmp->dp_com = devm_platform_ioremap_resource(pdev, 1);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1161

if (IS_ERR(qmp->dp_com))

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1162

return PTR_ERR(qmp->dp_com);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1170

qmp->tx = devm_of_iomap(dev, np, 0, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1171

if (IS_ERR(qmp->tx))

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1172

return PTR_ERR(qmp->tx);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1174

qmp->rx = devm_of_iomap(dev, np, 1, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1175

if (IS_ERR(qmp->rx))

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1176

return PTR_ERR(qmp->rx);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1178

qmp->pcs = devm_of_iomap(dev, np, 2, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1179

if (IS_ERR(qmp->pcs))

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1180

return PTR_ERR(qmp->pcs);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1183

qmp->pcs_usb = qmp->pcs + cfg->pcs_usb_offset;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1185

qmp->tx2 = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1186

if (IS_ERR(qmp->tx2))

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1187

return PTR_ERR(qmp->tx2);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1189

qmp->rx2 = devm_of_iomap(dev, np, 4, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1190

if (IS_ERR(qmp->rx2))

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1191

return PTR_ERR(qmp->rx2);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1193

qmp->pcs_misc = devm_of_iomap(dev, np, 5, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1194

if (IS_ERR(qmp->pcs_misc)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1196

qmp->pcs_misc = NULL;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1199

qmp->pipe_clk = devm_get_clk_from_child(dev, np, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1200

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1201

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1208

static int qmp_usb_legacy_parse_dt(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1210

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1211

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1213

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1223

qmp->serdes = base + offs->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1224

qmp->pcs = base + offs->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1225

qmp->pcs_usb = base + offs->pcs_usb;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1226

qmp->tx = base + offs->tx;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1227

qmp->rx = base + offs->rx;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1229

qmp->pipe_clk = devm_clk_get(dev, "pipe");

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1230

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1231

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1243

struct qmp_usb *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1246

qmp = devm_kzalloc(dev, sizeof(*qmp), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1247

if (!qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1250

qmp->dev = dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1251

dev_set_drvdata(dev, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1253

qmp->cfg = of_device_get_match_data(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1254

if (!qmp->cfg)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1257

ret = qmp_usb_legacy_clk_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1261

ret = qmp_usb_legacy_reset_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1265

ret = qmp_usb_legacy_vreg_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1272

ret = qmp_usb_legacy_parse_dt_legacy(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1275

ret = qmp_usb_legacy_parse_dt(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1290

ret = phy_pipe_clk_register(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1294

qmp->phy = devm_phy_create(dev, np, &qmp_usb_legacy_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1295

if (IS_ERR(qmp->phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1296

ret = PTR_ERR(qmp->phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

1301

phy_set_drvdata(qmp->phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

727

static int qmp_usb_legacy_serdes_init(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

729

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

730

void __iomem *serdes = qmp->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

741

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

742

void __iomem *dp_com = qmp->dp_com;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

768

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

769

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

770

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

773

ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

775

dev_err(qmp->dev, "failed to enable regulators, err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

779

ret = reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

781

dev_err(qmp->dev, "reset assert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

785

ret = reset_control_bulk_deassert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

787

dev_err(qmp->dev, "reset deassert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

791

ret = clk_bulk_prepare_enable(cfg->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

802

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

804

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

811

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

812

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

814

reset_control_bulk_assert(cfg->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

816

clk_bulk_disable_unprepare(cfg->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

818

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

825

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

826

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

827

void __iomem *tx = qmp->tx;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

828

void __iomem *rx = qmp->rx;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

829

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

834

qmp_usb_legacy_serdes_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

836

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

838

dev_err(qmp->dev, "pipe_clk enable failed err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

846

qmp_usb_legacy_configure_lane(qmp->tx2, cfg->tx_tbl, cfg->tx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

847

qmp_usb_legacy_configure_lane(qmp->rx2, cfg->rx_tbl, cfg->rx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

863

dev_err(qmp->dev, "phy initialization timed-out\n");

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

870

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

877

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

878

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

880

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

883

qphy_setbits(qmp->pcs, cfg->regs[QPHY_SW_RESET], SW_RESET);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

886

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_START_CTRL],

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

890

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL],

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

923

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

925

qmp->mode = mode;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

937

static void qmp_usb_legacy_enable_autonomous_mode(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

939

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

940

void __iomem *pcs_usb = qmp->pcs_usb ?: qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

941

void __iomem *pcs_misc = qmp->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

944

if (qmp->mode == PHY_MODE_USB_HOST_SS ||

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

945

qmp->mode == PHY_MODE_USB_DEVICE_SS)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

966

static void qmp_usb_legacy_disable_autonomous_mode(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

968

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

969

void __iomem *pcs_usb = qmp->pcs_usb ?: qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

970

void __iomem *pcs_misc = qmp->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

986

struct qmp_usb *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

987

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

989

dev_vdbg(dev, "Suspending QMP phy, mode:%d\n", qmp->mode);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

991

if (!qmp->phy->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

996

qmp_usb_legacy_enable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

998

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb-legacy.c

999

clk_bulk_disable_unprepare(cfg->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1868

static int qmp_usb_serdes_init(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1870

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1871

void __iomem *serdes = qmp->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1875

qmp_configure(qmp->dev, serdes, serdes_tbl, serdes_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1882

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1883

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1884

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1887

ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1889

dev_err(qmp->dev, "failed to enable regulators, err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1893

ret = reset_control_bulk_assert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1895

dev_err(qmp->dev, "reset assert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1899

ret = reset_control_bulk_deassert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1901

dev_err(qmp->dev, "reset deassert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1905

ret = clk_bulk_prepare_enable(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1914

reset_control_bulk_assert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1916

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1923

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1924

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1926

reset_control_bulk_assert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1928

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1930

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1937

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1938

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1939

void __iomem *tx = qmp->tx;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1940

void __iomem *rx = qmp->rx;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1941

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1942

void __iomem *pcs_usb = qmp->pcs_usb;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1947

qmp_usb_serdes_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1949

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1951

dev_err(qmp->dev, "pipe_clk enable failed err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1956

qmp_configure_lane(qmp->dev, tx, cfg->tx_tbl, cfg->tx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1957

qmp_configure_lane(qmp->dev, rx, cfg->rx_tbl, cfg->rx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1959

qmp_configure(qmp->dev, pcs, cfg->pcs_tbl, cfg->pcs_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1962

qmp_configure(qmp->dev, pcs_usb, cfg->pcs_usb_tbl, cfg->pcs_usb_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1977

dev_err(qmp->dev, "phy initialization timed-out\n");

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1984

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1991

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1992

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1994

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

1997

qphy_setbits(qmp->pcs, cfg->regs[QPHY_SW_RESET], SW_RESET);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2000

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_START_CTRL],

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2004

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL],

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2037

struct qmp_usb *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2039

qmp->mode = mode;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2051

static void qmp_usb_enable_autonomous_mode(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2053

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2054

void __iomem *pcs_usb = qmp->pcs_usb ?: qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2055

void __iomem *pcs_misc = qmp->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2058

if (qmp->mode == PHY_MODE_USB_HOST_SS ||

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2059

qmp->mode == PHY_MODE_USB_DEVICE_SS)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2080

static void qmp_usb_disable_autonomous_mode(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2082

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2083

void __iomem *pcs_usb = qmp->pcs_usb ?: qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2084

void __iomem *pcs_misc = qmp->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2100

struct qmp_usb *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2102

dev_vdbg(dev, "Suspending QMP phy, mode:%d\n", qmp->mode);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2104

if (!qmp->phy->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2109

qmp_usb_enable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2111

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2112

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2119

struct qmp_usb *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2122

dev_vdbg(dev, "Resuming QMP phy, mode:%d\n", qmp->mode);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2124

if (!qmp->phy->init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2129

ret = clk_bulk_prepare_enable(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2133

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2136

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2140

qmp_usb_disable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2150

static int qmp_usb_reset_init(struct qmp_usb *qmp,

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2154

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2158

qmp->resets = devm_kcalloc(dev, num_resets,

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2159

sizeof(*qmp->resets), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2160

if (!qmp->resets)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2164

qmp->resets[i].id = reset_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2166

qmp->num_resets = num_resets;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2168

ret = devm_reset_control_bulk_get_exclusive(dev, num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2175

static int qmp_usb_clk_init(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2177

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2181

qmp->clks = devm_kcalloc(dev, num, sizeof(*qmp->clks), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2182

if (!qmp->clks)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2186

qmp->clks[i].id = qmp_usb_phy_clk_l[i];

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2188

qmp->num_clks = num;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2190

return devm_clk_bulk_get_optional(dev, num, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2216

static int phy_pipe_clk_register(struct qmp_usb *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2218

struct clk_fixed_rate *fixed = &qmp->pipe_clk_fixed;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2224

dev_err(qmp->dev, "%pOFn: No clock-output-names\n", np);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2234

ret = devm_clk_hw_register(qmp->dev, &fixed->hw);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2246

return devm_add_action_or_reset(qmp->dev, phy_clk_release_provider, np);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2268

static int qmp_usb_parse_dt_legacy(struct qmp_usb *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2270

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2271

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2272

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2276

qmp->serdes = devm_platform_ioremap_resource(pdev, 0);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2277

if (IS_ERR(qmp->serdes))

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2278

return PTR_ERR(qmp->serdes);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2294

qmp->tx = devm_of_iomap(dev, np, 0, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2295

if (IS_ERR(qmp->tx))

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2296

return PTR_ERR(qmp->tx);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2298

qmp->rx = devm_of_iomap(dev, np, 1, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2299

if (IS_ERR(qmp->rx))

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2300

return PTR_ERR(qmp->rx);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2302

qmp->pcs = qmp_usb_iomap(dev, np, 2, exclusive);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2303

if (IS_ERR(qmp->pcs))

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2304

return PTR_ERR(qmp->pcs);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2307

qmp->pcs_usb = qmp->pcs + cfg->pcs_usb_offset;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2309

qmp->pcs_misc = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2311

if (IS_ERR(qmp->pcs_misc)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2313

qmp->pcs_misc = NULL;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2316

qmp->pipe_clk = devm_get_clk_from_child(dev, np, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2317

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2318

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2322

ret = devm_clk_bulk_get_all(qmp->dev, &qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2326

qmp->num_clks = ret;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2328

ret = qmp_usb_reset_init(qmp, usb3phy_legacy_reset_l,

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2336

static int qmp_usb_parse_dt(struct qmp_usb *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2338

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2339

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2341

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2352

qmp->serdes = base + offs->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2353

qmp->pcs = base + offs->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2355

qmp->pcs_usb = base + offs->pcs_usb;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2357

qmp->pcs_misc = base + offs->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2358

qmp->tx = base + offs->tx;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2359

qmp->rx = base + offs->rx;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2361

ret = qmp_usb_clk_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2365

qmp->pipe_clk = devm_clk_get(dev, "pipe");

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2366

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2367

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2371

ret = qmp_usb_reset_init(qmp, usb3phy_reset_l,

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2384

struct qmp_usb *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2387

qmp = devm_kzalloc(dev, sizeof(*qmp), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2388

if (!qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2391

qmp->dev = dev;

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2392

dev_set_drvdata(dev, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2394

qmp->cfg = of_device_get_match_data(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2395

if (!qmp->cfg)

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2398

ret = devm_regulator_bulk_get_const(dev, qmp->cfg->num_vregs,

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2399

qmp->cfg->vreg_list, &qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2406

ret = qmp_usb_parse_dt_legacy(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2409

ret = qmp_usb_parse_dt(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2424

ret = phy_pipe_clk_register(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2428

qmp->phy = devm_phy_create(dev, np, &qmp_usb_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2429

if (IS_ERR(qmp->phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2430

ret = PTR_ERR(qmp->phy);

drivers/phy/qualcomm/phy-qcom-qmp-usb.c

2435

phy_set_drvdata(qmp->phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1002

qphy_setbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL], SW_PWRDN);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1006

if (qmp->orientation == TYPEC_ORIENTATION_REVERSE)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1008

writel(val, qmp->pcs_misc);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1010

qmp_configure(qmp->dev, qmp->serdes, cfg->serdes_tbl,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1013

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1015

dev_err(qmp->dev, "pipe_clk enable failed err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1020

qmp_configure_lane(qmp->dev, qmp->tx, cfg->tx_tbl, cfg->tx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1021

qmp_configure_lane(qmp->dev, qmp->rx, cfg->rx_tbl, cfg->rx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1023

qmp_configure_lane(qmp->dev, qmp->tx2, cfg->tx_tbl, cfg->tx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1024

qmp_configure_lane(qmp->dev, qmp->rx2, cfg->rx_tbl, cfg->rx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1026

qmp_configure(qmp->dev, qmp->pcs, cfg->pcs_tbl, cfg->pcs_tbl_num);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1029

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_SW_RESET], SW_RESET);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1032

qphy_setbits(qmp->pcs, cfg->regs[QPHY_START_CTRL], SERDES_START | PCS_START);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1034

status = qmp->pcs + cfg->regs[QPHY_PCS_STATUS];

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1038

dev_err(qmp->dev, "phy initialization timed-out\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1045

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1052

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1053

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1055

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1058

qphy_setbits(qmp->pcs, cfg->regs[QPHY_SW_RESET], SW_RESET);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1061

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_START_CTRL],

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1065

qphy_clrbits(qmp->pcs, cfg->regs[QPHY_PCS_POWER_DOWN_CONTROL],

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1071

static int qmp_usbc_check_phy_status(struct qmp_usbc *qmp, bool is_dp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1073

if ((is_dp && qmp->usb_init_count) ||

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1074

(!is_dp && qmp->dp_init_count)) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1075

dev_err(qmp->dev,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1086

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1089

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1091

ret = qmp_usbc_check_phy_status(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1099

qmp_usbc_set_phy_mode(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1107

qmp->usb_init_count++;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1109

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1116

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1119

qmp->usb_init_count--;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1128

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1130

qmp->mode = mode;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1137

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1138

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1141

if (qmp->dp_init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1142

dev_err(qmp->dev, "DP already inited\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1146

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1148

ret = qmp_usbc_check_phy_status(qmp, true);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1156

qmp_usbc_set_phy_mode(qmp, true);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1158

cfg->dp_aux_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1160

qmp->dp_init_count++;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1163

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1169

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1171

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1175

qmp->dp_init_count--;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1177

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1185

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1186

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1188

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1190

memcpy(&qmp->dp_opts, dp_opts, sizeof(*dp_opts));

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1191

if (qmp->dp_opts.set_voltages) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1192

cfg->configure_dp_tx(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1193

qmp->dp_opts.set_voltages = 0;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1196

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1203

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1204

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1207

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1210

ret = cfg->calibrate_dp_phy(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1212

dev_err(qmp->dev, "dp calibrate err(%d)\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1213

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1218

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1222

static int qmp_usbc_dp_serdes_init(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1224

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1225

void __iomem *serdes = qmp->dp_serdes;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1226

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1228

qmp_configure(qmp->dev, serdes, cfg->dp_serdes_tbl,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1233

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl_rbr,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1237

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl_hbr,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1241

qmp_configure(qmp->dev, serdes, cfg->serdes_tbl_hbr2,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1254

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1255

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1257

void __iomem *tx = qmp->dp_tx;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1258

void __iomem *tx2 = qmp->dp_tx2;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1268

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1270

qmp_usbc_dp_serdes_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1272

qmp_configure_lane(qmp->dev, tx, cfg->dp_tx_tbl, cfg->dp_tx_tbl_num, 1);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1273

qmp_configure_lane(qmp->dev, tx2, cfg->dp_tx_tbl, cfg->dp_tx_tbl_num, 2);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1276

cfg->configure_dp_tx(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1279

cfg->configure_dp_phy(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1281

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1288

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1290

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1293

writel(DP_PHY_PD_CTL_PSR_PWRDN, qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1295

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1317

static void qmp_usbc_enable_autonomous_mode(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1319

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1320

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1323

if (qmp->mode == PHY_MODE_USB_HOST_SS ||

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1324

qmp->mode == PHY_MODE_USB_DEVICE_SS)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1341

if (qmp->tcsr_map && qmp->vls_clamp_reg)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1342

regmap_write(qmp->tcsr_map, qmp->vls_clamp_reg, 1);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1345

static void qmp_usbc_disable_autonomous_mode(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1347

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1348

void __iomem *pcs = qmp->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1351

if (qmp->tcsr_map && qmp->vls_clamp_reg)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1352

regmap_write(qmp->tcsr_map, qmp->vls_clamp_reg, 0);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1364

struct qmp_usbc *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1366

dev_vdbg(dev, "Suspending QMP phy, mode:%d\n", qmp->mode);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1368

if (!qmp->usb_init_count && !qmp->dp_init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1373

qmp_usbc_enable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1375

clk_disable_unprepare(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1376

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1383

struct qmp_usbc *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1386

dev_vdbg(dev, "Resuming QMP phy, mode:%d\n", qmp->mode);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1388

if (!qmp->usb_init_count && !qmp->dp_init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1393

ret = clk_bulk_prepare_enable(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1397

ret = clk_prepare_enable(qmp->pipe_clk);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1400

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1404

qmp_usbc_disable_autonomous_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1414

static int qmp_usbc_reset_init(struct qmp_usbc *qmp,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1418

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1422

qmp->resets = devm_kcalloc(dev, num_resets,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1423

sizeof(*qmp->resets), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1424

if (!qmp->resets)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1428

qmp->resets[i].id = reset_list[i];

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1430

qmp->num_resets = num_resets;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1432

ret = devm_reset_control_bulk_get_exclusive(dev, num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1439

static int qmp_usbc_clk_init(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1441

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1445

qmp->clks = devm_kcalloc(dev, num, sizeof(*qmp->clks), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1446

if (!qmp->clks)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1450

qmp->clks[i].id = qmp_usbc_phy_clk_l[i];

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1452

qmp->num_clks = num;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1454

return devm_clk_bulk_get_optional(dev, num, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1459

struct qmp_usbc *qmp = data;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1462

return &qmp->pipe_clk_fixed.hw;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1466

return &qmp->pipe_clk_fixed.hw;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1468

return &qmp->dp_link_hw;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1470

return &qmp->dp_pixel_hw;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1494

static int phy_pipe_clk_register(struct qmp_usbc *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1496

struct clk_fixed_rate *fixed = &qmp->pipe_clk_fixed;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1504

snprintf(name, sizeof(name), "%s::pipe_clk", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1514

return devm_clk_hw_register(qmp->dev, &fixed->hw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1580

const struct qmp_usbc *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1583

qmp = container_of(hw, struct qmp_usbc, dp_pixel_hw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1585

dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1618

const struct qmp_usbc *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1621

qmp = container_of(hw, struct qmp_usbc, dp_link_hw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1622

dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1639

static int phy_dp_clks_register(struct qmp_usbc *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1645

snprintf(name, sizeof(name), "%s::link_clk", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1648

qmp->dp_link_hw.init = &init;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1649

ret = devm_clk_hw_register(qmp->dev, &qmp->dp_link_hw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1651

dev_err(qmp->dev, "link clk reg fail ret=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1655

snprintf(name, sizeof(name), "%s::vco_div_clk", dev_name(qmp->dev));

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1658

qmp->dp_pixel_hw.init = &init;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1659

ret = devm_clk_hw_register(qmp->dev, &qmp->dp_pixel_hw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1661

dev_err(qmp->dev, "pxl clk reg fail ret=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1673

static int qmp_usbc_register_clocks(struct qmp_usbc *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1675

struct clk_fixed_rate *fixed = &qmp->pipe_clk_fixed;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1678

ret = phy_pipe_clk_register(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1682

if (qmp->dp_serdes != 0) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1683

ret = phy_dp_clks_register(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1688

if (np == qmp->dev->of_node)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1689

return devm_of_clk_add_hw_provider(qmp->dev, qmp_usbc_clks_hw_get, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1699

return devm_add_action_or_reset(qmp->dev, phy_clk_release_provider, np);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1706

struct qmp_usbc *qmp = typec_switch_get_drvdata(sw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1708

if (orientation == qmp->orientation || orientation == TYPEC_ORIENTATION_NONE)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1711

mutex_lock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1712

qmp->orientation = orientation;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1714

if (qmp->usb_init_count) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1715

qmp_usbc_usb_power_off(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1716

qmp_usbc_com_exit(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1718

qmp_usbc_com_init(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1719

qmp_usbc_set_phy_mode(qmp, false);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1720

qmp_usbc_usb_power_on(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1723

mutex_unlock(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1730

struct qmp_usbc *qmp = data;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1732

typec_switch_unregister(qmp->sw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1735

static int qmp_usbc_typec_switch_register(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1738

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1740

sw_desc.drvdata = qmp;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1743

qmp->sw = typec_switch_register(dev, &sw_desc);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1744

if (IS_ERR(qmp->sw)) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1745

dev_err(dev, "Unable to register typec switch: %pe\n", qmp->sw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1746

return PTR_ERR(qmp->sw);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1749

return devm_add_action_or_reset(dev, qmp_usbc_typec_unregister, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1752

static int qmp_usbc_typec_switch_register(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1758

static int qmp_usbc_parse_dt_legacy(struct qmp_usbc *qmp, struct device_node *np)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1760

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1761

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1764

qmp->serdes = devm_platform_ioremap_resource(pdev, 0);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1765

if (IS_ERR(qmp->serdes))

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1766

return PTR_ERR(qmp->serdes);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1774

qmp->tx = devm_of_iomap(dev, np, 0, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1775

if (IS_ERR(qmp->tx))

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1776

return PTR_ERR(qmp->tx);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1778

qmp->rx = devm_of_iomap(dev, np, 1, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1779

if (IS_ERR(qmp->rx))

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1780

return PTR_ERR(qmp->rx);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1782

qmp->pcs = devm_of_iomap(dev, np, 2, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1783

if (IS_ERR(qmp->pcs))

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1784

return PTR_ERR(qmp->pcs);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1786

qmp->tx2 = devm_of_iomap(dev, np, 3, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1787

if (IS_ERR(qmp->tx2))

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1788

return PTR_ERR(qmp->tx2);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1790

qmp->rx2 = devm_of_iomap(dev, np, 4, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1791

if (IS_ERR(qmp->rx2))

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1792

return PTR_ERR(qmp->rx2);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1794

qmp->pcs_misc = devm_of_iomap(dev, np, 5, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1795

if (IS_ERR(qmp->pcs_misc)) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1797

qmp->pcs_misc = NULL;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1800

qmp->pipe_clk = devm_get_clk_from_child(dev, np, NULL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1801

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1802

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1806

ret = devm_clk_bulk_get_all(qmp->dev, &qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1810

qmp->num_clks = ret;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1812

ret = qmp_usbc_reset_init(qmp, usb3phy_legacy_reset_l,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1820

static int qmp_usbc_parse_dt(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1822

struct platform_device *pdev = to_platform_device(qmp->dev);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1823

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1825

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1837

qmp->dp_serdes = base + offs->dp_serdes;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1838

qmp->dp_tx = base + offs->dp_txa;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1839

qmp->dp_tx2 = base + offs->dp_txb;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1840

qmp->dp_dp_phy = base + offs->dp_dp_phy;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1843

qmp->serdes = base + offs->serdes;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1844

qmp->pcs = base + offs->pcs;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1846

qmp->pcs_misc = base + offs->pcs_misc;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1847

qmp->tx = base + offs->tx;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1848

qmp->rx = base + offs->rx;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1850

qmp->tx2 = base + offs->tx2;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1851

qmp->rx2 = base + offs->rx2;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1853

ret = qmp_usbc_clk_init(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1857

qmp->pipe_clk = devm_clk_get(dev, "pipe");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1858

if (IS_ERR(qmp->pipe_clk)) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1859

return dev_err_probe(dev, PTR_ERR(qmp->pipe_clk),

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1863

ret = qmp_usbc_reset_init(qmp, cfg->reset_list, cfg->num_resets);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1870

static int qmp_usbc_parse_tcsr(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1873

struct device *dev = qmp->dev;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1885

qmp->tcsr_map = syscon_node_to_regmap(tcsr_args.np);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1887

if (IS_ERR(qmp->tcsr_map))

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1888

return PTR_ERR(qmp->tcsr_map);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1890

qmp->vls_clamp_reg = tcsr_args.args[0];

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1893

qmp->dp_phy_mode_reg = tcsr_args.args[1];

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1900

struct qmp_usbc *qmp = dev_get_drvdata(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1903

return qmp->usb_phy;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1907

return qmp->usb_phy;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1909

return qmp->dp_phy ?: ERR_PTR(-ENODEV);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1920

struct qmp_usbc *qmp;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1923

qmp = devm_kzalloc(dev, sizeof(*qmp), GFP_KERNEL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1924

if (!qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1927

qmp->dev = dev;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1928

dev_set_drvdata(dev, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1930

qmp->orientation = TYPEC_ORIENTATION_NORMAL;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1932

qmp->cfg = of_device_get_match_data(dev);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1933

if (!qmp->cfg)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1936

mutex_init(&qmp->phy_mutex);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1938

ret = devm_regulator_bulk_get_const(qmp->dev, qmp->cfg->num_vregs,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1939

qmp->cfg->vreg_list, &qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1943

ret = qmp_usbc_typec_switch_register(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1947

ret = qmp_usbc_parse_tcsr(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1954

ret = qmp_usbc_parse_dt_legacy(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1957

ret = qmp_usbc_parse_dt(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1972

ret = qmp_usbc_register_clocks(qmp, np);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1976

qmp->usb_phy = devm_phy_create(dev, np, &qmp_usbc_usb_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1977

if (IS_ERR(qmp->usb_phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1978

ret = PTR_ERR(qmp->usb_phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1983

phy_set_drvdata(qmp->usb_phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1985

if (qmp->dp_serdes != 0) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1986

qmp->dp_phy = devm_phy_create(dev, np, &qmp_usbc_dp_phy_ops);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1987

if (IS_ERR(qmp->dp_phy)) {

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1988

ret = PTR_ERR(qmp->dp_phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

1992

phy_set_drvdata(qmp->dp_phy, qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

416

void (*dp_aux_init)(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

417

void (*configure_dp_tx)(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

418

int (*configure_dp_phy)(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

419

int (*calibrate_dp_phy)(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

644

static void qmp_v2_dp_aux_init(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

645

static void qmp_v2_configure_dp_tx(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

646

static int qmp_v2_configure_dp_phy(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

647

static int qmp_v2_calibrate_dp_phy(struct qmp_usbc *qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

689

static void qmp_usbc_set_phy_mode(struct qmp_usbc *qmp, bool is_dp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

691

if (qmp->tcsr_map && qmp->dp_phy_mode_reg)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

692

regmap_write(qmp->tcsr_map, qmp->dp_phy_mode_reg, is_dp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

697

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

698

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

701

ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

703

dev_err(qmp->dev, "failed to enable regulators, err=%d\n", ret);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

707

ret = reset_control_bulk_assert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

709

dev_err(qmp->dev, "reset assert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

713

ret = reset_control_bulk_deassert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

715

dev_err(qmp->dev, "reset deassert failed\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

719

ret = clk_bulk_prepare_enable(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

726

reset_control_bulk_assert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

728

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

735

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

736

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

738

reset_control_bulk_assert(qmp->num_resets, qmp->resets);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

740

clk_bulk_disable_unprepare(qmp->num_clks, qmp->clks);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

742

regulator_bulk_disable(cfg->num_vregs, qmp->vregs);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

747

static void qmp_v2_dp_aux_init(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

752

qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

757

qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

759

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG0);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

760

writel(0x13, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

761

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG2);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

762

writel(0x00, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG3);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

763

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG4);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

764

writel(0x26, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG5);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

765

writel(0x0a, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG6);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

766

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG7);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

767

writel(0xbb, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG8);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

768

writel(0x03, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG9);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

769

qmp->dp_aux_cfg = 0;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

774

qmp->dp_dp_phy + QSERDES_V2_DP_PHY_AUX_INTERRUPT_MASK);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

777

static int qmp_v2_configure_dp_swing(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

779

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

780

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

781

void __iomem *tx = qmp->dp_tx;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

782

void __iomem *tx2 = qmp->dp_tx2;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

788

dev_err(qmp->dev, "Invalid lane_num(%d)\n", dp_opts->lanes);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

798

dev_err(qmp->dev, "Invalid v(%d) | p(%d) level)\n",

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

820

static void qmp_usbc_configure_dp_mode(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

822

bool reverse = (qmp->orientation == TYPEC_ORIENTATION_REVERSE);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

828

writel(val, qmp->dp_dp_phy + QSERDES_DP_PHY_PD_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

831

writel(0xc9, qmp->dp_dp_phy + QSERDES_DP_PHY_MODE);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

833

writel(0xd9, qmp->dp_dp_phy + QSERDES_DP_PHY_MODE);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

836

static int qmp_usbc_configure_dp_clocks(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

838

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

856

dev_err(qmp->dev, "link rate:%d not supported\n", dp_opts->link_rate);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

859

writel(phy_vco_div, qmp->dp_dp_phy + QSERDES_V2_DP_PHY_VCO_DIV);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

861

clk_set_rate(qmp->dp_link_hw.clk, dp_opts->link_rate * 100000);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

862

clk_set_rate(qmp->dp_pixel_hw.clk, pixel_freq);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

867

static void qmp_v2_configure_dp_tx(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

869

const struct phy_configure_opts_dp *dp_opts = &qmp->dp_opts;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

870

void __iomem *tx = qmp->dp_tx;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

871

void __iomem *tx2 = qmp->dp_tx2;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

887

qmp_v2_configure_dp_swing(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

890

static int qmp_v2_configure_dp_phy(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

895

qmp_usbc_configure_dp_mode(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

897

writel(0x05, qmp->dp_dp_phy + QSERDES_V2_DP_PHY_TX0_TX1_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

898

writel(0x05, qmp->dp_dp_phy + QSERDES_V2_DP_PHY_TX2_TX3_LANE_CTL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

900

ret = qmp_usbc_configure_dp_clocks(qmp);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

904

writel(0x01, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

905

writel(0x05, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

906

writel(0x01, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

907

writel(0x09, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

909

writel(0x20, qmp->dp_serdes + QSERDES_COM_RESETSM_CNTRL);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

911

if (readl_poll_timeout(qmp->dp_serdes + QSERDES_COM_C_READY_STATUS,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

916

dev_err(qmp->dev, "C_READY not ready\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

920

if (readl_poll_timeout(qmp->dp_serdes + QSERDES_COM_CMN_STATUS,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

925

dev_err(qmp->dev, "FREQ_DONE not ready\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

929

if (readl_poll_timeout(qmp->dp_serdes + QSERDES_COM_CMN_STATUS,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

934

dev_err(qmp->dev, "PLL_LOCKED not ready\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

938

writel(0x19, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

940

if (readl_poll_timeout(qmp->dp_dp_phy + QSERDES_V2_DP_PHY_STATUS,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

945

dev_err(qmp->dev, "TSYNC_DONE not ready\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

949

if (readl_poll_timeout(qmp->dp_dp_phy + QSERDES_V2_DP_PHY_STATUS,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

954

dev_err(qmp->dev, "PHY_READY not ready\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

958

writel(0x3f, qmp->dp_tx + QSERDES_V2_TX_TRANSCEIVER_BIAS_EN);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

959

writel(0x10, qmp->dp_tx + QSERDES_V2_TX_HIGHZ_DRVR_EN);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

960

writel(0x0a, qmp->dp_tx + QSERDES_V2_TX_TX_POL_INV);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

961

writel(0x3f, qmp->dp_tx2 + QSERDES_V2_TX_TRANSCEIVER_BIAS_EN);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

962

writel(0x10, qmp->dp_tx2 + QSERDES_V2_TX_HIGHZ_DRVR_EN);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

963

writel(0x0a, qmp->dp_tx2 + QSERDES_V2_TX_TX_POL_INV);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

965

writel(0x18, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

966

writel(0x19, qmp->dp_dp_phy + QSERDES_DP_PHY_CFG);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

968

if (readl_poll_timeout(qmp->dp_dp_phy + QSERDES_V2_DP_PHY_STATUS,

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

973

dev_err(qmp->dev, "PHY_READY not ready\n");

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

980

static int qmp_v2_calibrate_dp_phy(struct qmp_usbc *qmp)

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

985

qmp->dp_aux_cfg++;

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

986

qmp->dp_aux_cfg %= ARRAY_SIZE(cfg1_settings);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

987

val = cfg1_settings[qmp->dp_aux_cfg];

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

989

writel(val, qmp->dp_dp_phy + QSERDES_DP_PHY_AUX_CFG1);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

996

struct qmp_usbc *qmp = phy_get_drvdata(phy);

drivers/phy/qualcomm/phy-qcom-qmp-usbc.c

997

const struct qmp_phy_cfg *cfg = qmp->cfg;

drivers/remoteproc/qcom_q6v5.c

28

if (!q6v5->qmp)

drivers/remoteproc/qcom_q6v5.c

31

ret = qmp_send(q6v5->qmp, "{class: image, res: load_state, name: %s, val: %s}",

drivers/remoteproc/qcom_q6v5.c

335

q6v5->qmp = qmp_get(&pdev->dev);

drivers/remoteproc/qcom_q6v5.c

336

if (IS_ERR(q6v5->qmp)) {

drivers/remoteproc/qcom_q6v5.c

337

if (PTR_ERR(q6v5->qmp) != -ENODEV)

drivers/remoteproc/qcom_q6v5.c

338

return dev_err_probe(&pdev->dev, PTR_ERR(q6v5->qmp),

drivers/remoteproc/qcom_q6v5.c

340

q6v5->qmp = NULL;

drivers/remoteproc/qcom_q6v5.c

345

qmp_put(q6v5->qmp);

drivers/remoteproc/qcom_q6v5.c

364

qmp_put(q6v5->qmp);

drivers/remoteproc/qcom_q6v5.h

20

struct qmp *qmp;

drivers/soc/qcom/qcom_aoss.c

100

mbox_send_message(qmp->mbox_chan, NULL);

drivers/soc/qcom/qcom_aoss.c

101

mbox_client_txdone(qmp->mbox_chan, 0);

drivers/soc/qcom/qcom_aoss.c

104

static bool qmp_magic_valid(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

106

return readl(qmp->msgram + QMP_DESC_MAGIC) == QMP_MAGIC;

drivers/soc/qcom/qcom_aoss.c

109

static bool qmp_link_acked(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

111

return readl(qmp->msgram + QMP_DESC_MCORE_LINK_STATE_ACK) == QMP_STATE_UP;

drivers/soc/qcom/qcom_aoss.c

114

static bool qmp_mcore_channel_acked(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

116

return readl(qmp->msgram + QMP_DESC_MCORE_CH_STATE_ACK) == QMP_STATE_UP;

drivers/soc/qcom/qcom_aoss.c

119

static bool qmp_ucore_channel_up(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

121

return readl(qmp->msgram + QMP_DESC_UCORE_CH_STATE) == QMP_STATE_UP;

drivers/soc/qcom/qcom_aoss.c

124

static int qmp_open(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

129

if (!qmp_magic_valid(qmp)) {

drivers/soc/qcom/qcom_aoss.c

130

dev_err(qmp->dev, "QMP magic doesn't match\n");

drivers/soc/qcom/qcom_aoss.c

134

val = readl(qmp->msgram + QMP_DESC_VERSION);

drivers/soc/qcom/qcom_aoss.c

136

dev_err(qmp->dev, "unsupported QMP version %d\n", val);

drivers/soc/qcom/qcom_aoss.c

140

qmp->offset = readl(qmp->msgram + QMP_DESC_MCORE_MBOX_OFFSET);

drivers/soc/qcom/qcom_aoss.c

141

qmp->size = readl(qmp->msgram + QMP_DESC_MCORE_MBOX_SIZE);

drivers/soc/qcom/qcom_aoss.c

142

if (!qmp->size) {

drivers/soc/qcom/qcom_aoss.c

143

dev_err(qmp->dev, "invalid mailbox size\n");

drivers/soc/qcom/qcom_aoss.c

148

val = readl(qmp->msgram + QMP_DESC_UCORE_LINK_STATE);

drivers/soc/qcom/qcom_aoss.c

149

writel(val, qmp->msgram + QMP_DESC_UCORE_LINK_STATE_ACK);

drivers/soc/qcom/qcom_aoss.c

152

writel(QMP_STATE_UP, qmp->msgram + QMP_DESC_MCORE_LINK_STATE);

drivers/soc/qcom/qcom_aoss.c

154

qmp_kick(qmp);

drivers/soc/qcom/qcom_aoss.c

156

ret = wait_event_timeout(qmp->event, qmp_link_acked(qmp), HZ);

drivers/soc/qcom/qcom_aoss.c

158

dev_err(qmp->dev, "ucore didn't ack link\n");

drivers/soc/qcom/qcom_aoss.c

162

writel(QMP_STATE_UP, qmp->msgram + QMP_DESC_MCORE_CH_STATE);

drivers/soc/qcom/qcom_aoss.c

164

qmp_kick(qmp);

drivers/soc/qcom/qcom_aoss.c

166

ret = wait_event_timeout(qmp->event, qmp_ucore_channel_up(qmp), HZ);

drivers/soc/qcom/qcom_aoss.c

168

dev_err(qmp->dev, "ucore didn't open channel\n");

drivers/soc/qcom/qcom_aoss.c

173

writel(QMP_STATE_UP, qmp->msgram + QMP_DESC_UCORE_CH_STATE_ACK);

drivers/soc/qcom/qcom_aoss.c

175

qmp_kick(qmp);

drivers/soc/qcom/qcom_aoss.c

177

ret = wait_event_timeout(qmp->event, qmp_mcore_channel_acked(qmp), HZ);

drivers/soc/qcom/qcom_aoss.c

179

dev_err(qmp->dev, "ucore didn't ack channel\n");

drivers/soc/qcom/qcom_aoss.c

186

writel(QMP_STATE_DOWN, qmp->msgram + QMP_DESC_MCORE_CH_STATE);

drivers/soc/qcom/qcom_aoss.c

189

writel(QMP_STATE_DOWN, qmp->msgram + QMP_DESC_MCORE_LINK_STATE);

drivers/soc/qcom/qcom_aoss.c

190

qmp_kick(qmp);

drivers/soc/qcom/qcom_aoss.c

195

static void qmp_close(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

197

writel(QMP_STATE_DOWN, qmp->msgram + QMP_DESC_MCORE_CH_STATE);

drivers/soc/qcom/qcom_aoss.c

198

writel(QMP_STATE_DOWN, qmp->msgram + QMP_DESC_MCORE_LINK_STATE);

drivers/soc/qcom/qcom_aoss.c

199

qmp_kick(qmp);

drivers/soc/qcom/qcom_aoss.c

204

struct qmp *qmp = data;

drivers/soc/qcom/qcom_aoss.c

206

wake_up_all(&qmp->event);

drivers/soc/qcom/qcom_aoss.c

211

static bool qmp_message_empty(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

213

return readl(qmp->msgram + qmp->offset) == 0;

drivers/soc/qcom/qcom_aoss.c

228

int __printf(2, 3) qmp_send(struct qmp *qmp, const char *fmt, ...)

drivers/soc/qcom/qcom_aoss.c

236

if (WARN_ON(IS_ERR_OR_NULL(qmp) || !fmt))

drivers/soc/qcom/qcom_aoss.c

247

mutex_lock(&qmp->tx_lock);

drivers/soc/qcom/qcom_aoss.c

252

__iowrite32_copy(qmp->msgram + qmp->offset + sizeof(u32),

drivers/soc/qcom/qcom_aoss.c

254

writel(sizeof(buf), qmp->msgram + qmp->offset);

drivers/soc/qcom/qcom_aoss.c

257

readl(qmp->msgram + qmp->offset);

drivers/soc/qcom/qcom_aoss.c

258

qmp_kick(qmp);

drivers/soc/qcom/qcom_aoss.c

260

time_left = wait_event_interruptible_timeout(qmp->event,

drivers/soc/qcom/qcom_aoss.c

261

qmp_message_empty(qmp), HZ);

drivers/soc/qcom/qcom_aoss.c

263

dev_err(qmp->dev, "ucore did not ack channel\n");

drivers/soc/qcom/qcom_aoss.c

267

writel(0, qmp->msgram + qmp->offset);

drivers/soc/qcom/qcom_aoss.c

274

mutex_unlock(&qmp->tx_lock);

drivers/soc/qcom/qcom_aoss.c

283

struct qmp *qmp = container_of(hw, struct qmp, qdss_clk);

drivers/soc/qcom/qcom_aoss.c

285

return qmp_send(qmp, buf);

drivers/soc/qcom/qcom_aoss.c

291

struct qmp *qmp = container_of(hw, struct qmp, qdss_clk);

drivers/soc/qcom/qcom_aoss.c

293

qmp_send(qmp, buf);

drivers/soc/qcom/qcom_aoss.c

301

static int qmp_qdss_clk_add(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

309

qmp->qdss_clk.init = &qdss_init;

drivers/soc/qcom/qcom_aoss.c

310

ret = clk_hw_register(qmp->dev, &qmp->qdss_clk);

drivers/soc/qcom/qcom_aoss.c

312

dev_err(qmp->dev, "failed to register qdss clock\n");

drivers/soc/qcom/qcom_aoss.c

316

ret = of_clk_add_hw_provider(qmp->dev->of_node, of_clk_hw_simple_get,

drivers/soc/qcom/qcom_aoss.c

317

&qmp->qdss_clk);

drivers/soc/qcom/qcom_aoss.c

319

dev_err(qmp->dev, "unable to register of clk hw provider\n");

drivers/soc/qcom/qcom_aoss.c

320

clk_hw_unregister(&qmp->qdss_clk);

drivers/soc/qcom/qcom_aoss.c

326

static void qmp_qdss_clk_remove(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

328

of_clk_del_provider(qmp->dev->of_node);

drivers/soc/qcom/qcom_aoss.c

329

clk_hw_unregister(&qmp->qdss_clk);

drivers/soc/qcom/qcom_aoss.c

361

ret = qmp_send(qmp_cdev->qmp, "{class: volt_flr, event:zero_temp, res:%s, value:%s}",

drivers/soc/qcom/qcom_aoss.c

375

static int qmp_cooling_device_add(struct qmp *qmp,

drivers/soc/qcom/qcom_aoss.c

381

qmp_cdev->qmp = qmp;

drivers/soc/qcom/qcom_aoss.c

385

(qmp->dev, node,

drivers/soc/qcom/qcom_aoss.c

390

dev_err(qmp->dev, "unable to register %s cooling device\n",

drivers/soc/qcom/qcom_aoss.c

396

static int qmp_cooling_devices_register(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

402

np = qmp->dev->of_node;

drivers/soc/qcom/qcom_aoss.c

404

qmp->cooling_devs = devm_kcalloc(qmp->dev, QMP_NUM_COOLING_RESOURCES,

drivers/soc/qcom/qcom_aoss.c

405

sizeof(*qmp->cooling_devs),

drivers/soc/qcom/qcom_aoss.c

408

if (!qmp->cooling_devs)

drivers/soc/qcom/qcom_aoss.c

414

ret = qmp_cooling_device_add(qmp, &qmp->cooling_devs[count++],

drivers/soc/qcom/qcom_aoss.c

421

devm_kfree(qmp->dev, qmp->cooling_devs);

drivers/soc/qcom/qcom_aoss.c

428

(qmp->cooling_devs[count].cdev);

drivers/soc/qcom/qcom_aoss.c

429

devm_kfree(qmp->dev, qmp->cooling_devs);

drivers/soc/qcom/qcom_aoss.c

434

static void qmp_cooling_devices_remove(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

439

thermal_cooling_device_unregister(qmp->cooling_devs[i].cdev);

drivers/soc/qcom/qcom_aoss.c

448

struct qmp *qmp_get(struct device *dev)

drivers/soc/qcom/qcom_aoss.c

452

struct qmp *qmp;

drivers/soc/qcom/qcom_aoss.c

466

qmp = platform_get_drvdata(pdev);

drivers/soc/qcom/qcom_aoss.c

468

if (!qmp) {

drivers/soc/qcom/qcom_aoss.c

472

return qmp;

drivers/soc/qcom/qcom_aoss.c

480

void qmp_put(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

486

if (!IS_ERR_OR_NULL(qmp))

drivers/soc/qcom/qcom_aoss.c

487

put_device(qmp->dev);

drivers/soc/qcom/qcom_aoss.c

510

struct qmp *qmp = file->private_data;

drivers/soc/qcom/qcom_aoss.c

518

for (i = 0; i < ARRAY_SIZE(qmp->debugfs_files); i++) {

drivers/soc/qcom/qcom_aoss.c

519

if (qmp->debugfs_files[i] == file->f_path.dentry) {

drivers/soc/qcom/qcom_aoss.c

547

ret = qmp_send(qmp, buf);

drivers/soc/qcom/qcom_aoss.c

559

static void qmp_debugfs_create(struct qmp *qmp)

drivers/soc/qcom/qcom_aoss.c

564

qmp->debugfs_root = debugfs_create_dir("qcom_aoss", NULL);

drivers/soc/qcom/qcom_aoss.c

566

for (i = 0; i < ARRAY_SIZE(qmp->debugfs_files); i++) {

drivers/soc/qcom/qcom_aoss.c

569

qmp->debugfs_files[i] = debugfs_create_file(entry->name, 0200,

drivers/soc/qcom/qcom_aoss.c

570

qmp->debugfs_root,

drivers/soc/qcom/qcom_aoss.c

571

qmp,

drivers/soc/qcom/qcom_aoss.c

578

struct qmp *qmp;

drivers/soc/qcom/qcom_aoss.c

58

struct qmp *qmp;

drivers/soc/qcom/qcom_aoss.c

582

qmp = devm_kzalloc(&pdev->dev, sizeof(*qmp), GFP_KERNEL);

drivers/soc/qcom/qcom_aoss.c

583

if (!qmp)

drivers/soc/qcom/qcom_aoss.c

586

qmp->dev = &pdev->dev;

drivers/soc/qcom/qcom_aoss.c

587

init_waitqueue_head(&qmp->event);

drivers/soc/qcom/qcom_aoss.c

588

mutex_init(&qmp->tx_lock);

drivers/soc/qcom/qcom_aoss.c

590

qmp->msgram = devm_platform_ioremap_resource(pdev, 0);

drivers/soc/qcom/qcom_aoss.c

591

if (IS_ERR(qmp->msgram))

drivers/soc/qcom/qcom_aoss.c

592

return PTR_ERR(qmp->msgram);

drivers/soc/qcom/qcom_aoss.c

594

qmp->mbox_client.dev = &pdev->dev;

drivers/soc/qcom/qcom_aoss.c

595

qmp->mbox_client.knows_txdone = true;

drivers/soc/qcom/qcom_aoss.c

596

qmp->mbox_chan = mbox_request_channel(&qmp->mbox_client, 0);

drivers/soc/qcom/qcom_aoss.c

597

if (IS_ERR(qmp->mbox_chan)) {

drivers/soc/qcom/qcom_aoss.c

599

return PTR_ERR(qmp->mbox_chan);

drivers/soc/qcom/qcom_aoss.c

604

"aoss-qmp", qmp);

drivers/soc/qcom/qcom_aoss.c

610

ret = qmp_open(qmp);

drivers/soc/qcom/qcom_aoss.c

614

ret = qmp_qdss_clk_add(qmp);

drivers/soc/qcom/qcom_aoss.c

618

ret = qmp_cooling_devices_register(qmp);

drivers/soc/qcom/qcom_aoss.c

622

platform_set_drvdata(pdev, qmp);

drivers/soc/qcom/qcom_aoss.c

624

qmp_debugfs_create(qmp);

drivers/soc/qcom/qcom_aoss.c

629

qmp_close(qmp);

drivers/soc/qcom/qcom_aoss.c

631

mbox_free_channel(qmp->mbox_chan);

drivers/soc/qcom/qcom_aoss.c

638

struct qmp *qmp = platform_get_drvdata(pdev);

drivers/soc/qcom/qcom_aoss.c

640

debugfs_remove_recursive(qmp->debugfs_root);

drivers/soc/qcom/qcom_aoss.c

642

qmp_qdss_clk_remove(qmp);

drivers/soc/qcom/qcom_aoss.c

643

qmp_cooling_devices_remove(qmp);

drivers/soc/qcom/qcom_aoss.c

645

qmp_close(qmp);

drivers/soc/qcom/qcom_aoss.c

646

mbox_free_channel(qmp->mbox_chan);

drivers/soc/qcom/qcom_aoss.c

98

static void qmp_kick(struct qmp *qmp)

drivers/soc/qcom/qcom_stats.c

41

static struct qmp *qcom_stats_qmp;

include/linux/soc/qcom/qcom_aoss.h

12

struct qmp;

include/linux/soc/qcom/qcom_aoss.h

16

int qmp_send(struct qmp *qmp, const char *fmt, ...);

include/linux/soc/qcom/qcom_aoss.h

17

struct qmp *qmp_get(struct device *dev);

include/linux/soc/qcom/qcom_aoss.h

18

void qmp_put(struct qmp *qmp);

include/linux/soc/qcom/qcom_aoss.h

22

static inline int qmp_send(struct qmp *qmp, const char *fmt, ...)

include/linux/soc/qcom/qcom_aoss.h

27

static inline struct qmp *qmp_get(struct device *dev)

include/linux/soc/qcom/qcom_aoss.h

32

static inline void qmp_put(struct qmp *qmp)