path: root/drivers/phy/qualcomm/phy-qcom-qmp-pcie-multiphy.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 */

#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/mfd/syscon.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/phy/phy.h>
#include <linux/platform_device.h>
#include <linux/pm_domain.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <linux/reset.h>
#include <linux/slab.h>

#include "phy-qcom-qmp.h"

#define PHY_INIT_COMPLETE_TIMEOUT_US		10000

enum qmp_pcie_glymur_link_mode {
	QMP_PCIE_GLYMUR_MODE_X8,
	QMP_PCIE_GLYMUR_MODE_X4X4,
};

enum qphy_reg_layout {
	QPHY_PCS_STATUS,
	QPHY_LAYOUT_SIZE
};

static const unsigned int pciephy_v8_50_regs_layout[QPHY_LAYOUT_SIZE] = {
	[QPHY_PCS_STATUS]		= QPHY_V8_50_PCS_STATUS1,
};

struct qmp_pcie_offsets {
	u16 pcs;
};

struct qmp_phy_cfg {
	const struct qmp_pcie_offsets *offsets;
	const char * const *reg_names;
	int num_regs;
	const char * const *pd_names;
	int num_pds;
	const char * const *nocsr_reset_list;
	int num_nocsr_resets;
	const char * const *vreg_list;
	int num_vregs;
	const unsigned int *regs;
	unsigned int phy_status;
	const char * const *clk_list;
	int num_clks;
	const char * const *pipe_clk_list;
	int num_pipe_clks;
};

struct qmp_pcie {
	struct device *dev;
	const struct qmp_phy_cfg *cfg;
	void __iomem **base;
	struct clk_bulk_data *clks;
	struct clk_bulk_data *pipe_clks;
	struct reset_control_bulk_data *nocsr_resets;
	struct regulator_bulk_data *vregs;
	struct device **pd_devs;
};

struct qmp_pcie_multiphy {
	struct phy **phys;
	const struct qmp_pcie_link_mode_cfg *mode_cfg;
	int num_pipe_outputs;
	struct clk_fixed_rate *pipe_out_clks;
};

struct qmp_pcie_link_mode_cfg {
	const struct qmp_phy_cfg * const *cfgs;
	u32 num_phys;
};

struct qmp_pcie_match_data {
	const struct qmp_pcie_link_mode_cfg *mode_cfgs;
	u32 num_modes;
};

static const char * const glymur_pciephy_clk_l[] = {
	"aux", "cfg_ahb", "ref", "rchng", "phy_b_aux",
};

static const char * const glymur_pciephy_a_clk_l[] = {
	"aux", "cfg_ahb", "ref", "rchng",
};

static const char * const glymur_pciephy_b_clk_l[] = {
	"phy_b_aux", "cfg_ahb_b", "ref", "rchng_b",
};

static const char * const glymur_pciephy_pipeclk_l[] = {
	"pipe",
};

static const char * const glymur_pipephy_b_pipeclk_l[] = {
	"pipe_b", "pipediv2_b",
};

static const char * const glymur_vreg_l[] = {
	"vdda-phy", "vdda-pll", "vdda-refgen0p9", "vdda-refgen1p2",
};

static const char * const glymur_pciephy_a_reg_l[] = {
	"port_a",
};

static const char * const glymur_pciephy_b_reg_l[] = {
	"port_b",
};

static const char * const glymur_pciephy_reg_l[] = {
	"port_a", "port_b",
};

static const char * const glymur_pciephy_a_pd_l[] = {
	"port_a",
};

static const char * const glymur_pciephy_b_pd_l[] = {
	"port_b",
};

static const char * const glymur_pciephy_pd_l[] = {
	"port_a", "port_b",
};

static const char * const glymur_pciephy_a_nocsr_reset_l[] = {
	"port_a_nocsr",
};

static const char * const glymur_pciephy_nocsr_reset_l[] = {
	"port_a_nocsr", "port_b_nocsr",
};

static const char * const glymur_pciephy_b_nocsr_reset_l[] = {
	"port_b_nocsr",
};

static const struct qmp_pcie_offsets glymur_pcie_offsets_v8_50 = {
	.pcs		= 0x9000,
};

static const struct qmp_phy_cfg glymur_qmp_gen5x4_pciephy_a_cfg = {
	.offsets		= &glymur_pcie_offsets_v8_50,
	.reg_names		= glymur_pciephy_a_reg_l,
	.num_regs		= ARRAY_SIZE(glymur_pciephy_a_reg_l),
	.pd_names		= glymur_pciephy_a_pd_l,
	.num_pds		= ARRAY_SIZE(glymur_pciephy_a_pd_l),
	.nocsr_reset_list	= glymur_pciephy_a_nocsr_reset_l,
	.num_nocsr_resets	= ARRAY_SIZE(glymur_pciephy_a_nocsr_reset_l),
	.vreg_list		= glymur_vreg_l,
	.num_vregs		= ARRAY_SIZE(glymur_vreg_l),
	.regs			= pciephy_v8_50_regs_layout,
	.phy_status		= PHYSTATUS_4_20,
	.pipe_clk_list		= glymur_pciephy_pipeclk_l,
	.num_pipe_clks		= ARRAY_SIZE(glymur_pciephy_pipeclk_l),
	.clk_list		= glymur_pciephy_a_clk_l,
	.num_clks		= ARRAY_SIZE(glymur_pciephy_a_clk_l),
};

static const struct qmp_phy_cfg glymur_qmp_gen5x4_pciephy_b_cfg = {
	.offsets		= &glymur_pcie_offsets_v8_50,
	.reg_names		= glymur_pciephy_b_reg_l,
	.num_regs		= ARRAY_SIZE(glymur_pciephy_b_reg_l),
	.pd_names		= glymur_pciephy_b_pd_l,
	.num_pds		= ARRAY_SIZE(glymur_pciephy_b_pd_l),
	.nocsr_reset_list	= glymur_pciephy_b_nocsr_reset_l,
	.num_nocsr_resets	= ARRAY_SIZE(glymur_pciephy_b_nocsr_reset_l),
	.vreg_list		= glymur_vreg_l,
	.num_vregs		= ARRAY_SIZE(glymur_vreg_l),
	.regs			= pciephy_v8_50_regs_layout,
	.phy_status		= PHYSTATUS_4_20,
	.pipe_clk_list		= glymur_pipephy_b_pipeclk_l,
	.num_pipe_clks		= ARRAY_SIZE(glymur_pipephy_b_pipeclk_l),
	.clk_list		= glymur_pciephy_b_clk_l,
	.num_clks		= ARRAY_SIZE(glymur_pciephy_b_clk_l),
};

static const struct qmp_phy_cfg glymur_qmp_gen5x8_pciephy_cfg = {
	.offsets		= &glymur_pcie_offsets_v8_50,
	.reg_names		= glymur_pciephy_reg_l,
	.num_regs		= ARRAY_SIZE(glymur_pciephy_reg_l),
	.pd_names		= glymur_pciephy_pd_l,
	.num_pds		= ARRAY_SIZE(glymur_pciephy_pd_l),
	.nocsr_reset_list	= glymur_pciephy_nocsr_reset_l,
	.num_nocsr_resets	= ARRAY_SIZE(glymur_pciephy_nocsr_reset_l),
	.vreg_list		= glymur_vreg_l,
	.num_vregs		= ARRAY_SIZE(glymur_vreg_l),
	.regs			= pciephy_v8_50_regs_layout,
	.phy_status		= PHYSTATUS_4_20,
	.pipe_clk_list		= glymur_pciephy_pipeclk_l,
	.num_pipe_clks		= ARRAY_SIZE(glymur_pciephy_pipeclk_l),
	.clk_list		= glymur_pciephy_clk_l,
	.num_clks		= ARRAY_SIZE(glymur_pciephy_clk_l),
};

static const struct qmp_phy_cfg * const glymur_qmp_gen5x8_mode_x8_cfgs[] = {
	&glymur_qmp_gen5x8_pciephy_cfg,
};

static const struct qmp_phy_cfg * const glymur_qmp_gen5x8_mode_x4x4_cfgs[] = {
	&glymur_qmp_gen5x4_pciephy_a_cfg,
	&glymur_qmp_gen5x4_pciephy_b_cfg,
};

static const struct qmp_pcie_link_mode_cfg glymur_qmp_gen5x8_mode_cfgs[] = {
	[QMP_PCIE_GLYMUR_MODE_X8] = {
		.cfgs		= glymur_qmp_gen5x8_mode_x8_cfgs,
		.num_phys	= ARRAY_SIZE(glymur_qmp_gen5x8_mode_x8_cfgs),
	},
	[QMP_PCIE_GLYMUR_MODE_X4X4] = {
		.cfgs		= glymur_qmp_gen5x8_mode_x4x4_cfgs,
		.num_phys	= ARRAY_SIZE(glymur_qmp_gen5x8_mode_x4x4_cfgs),
	},
};

static const struct qmp_pcie_match_data glymur_qmp_gen5x8_match_data = {
	.mode_cfgs	= glymur_qmp_gen5x8_mode_cfgs,
	.num_modes	= ARRAY_SIZE(glymur_qmp_gen5x8_mode_cfgs),
};

static int qmp_pcie_pd_power_on(struct qmp_pcie *qmp)
{
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	int i, ret;

	for (i = 0; i < cfg->num_pds; i++) {
		ret = pm_runtime_resume_and_get(qmp->pd_devs[i]);
		if (ret < 0) {
			dev_err(qmp->dev, "failed to power on %s domain: %d\n",
				cfg->pd_names[i], ret);
			goto err_power_off;
		}
	}

	return 0;

err_power_off:
	while (--i >= 0)
		pm_runtime_put(qmp->pd_devs[i]);

	return ret;
}

static void qmp_pcie_pd_power_off(struct qmp_pcie *qmp)
{
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	int i;

	for (i = cfg->num_pds - 1; i >= 0; i--)
		pm_runtime_put(qmp->pd_devs[i]);
}

static int qmp_pcie_init(struct phy *phy)
{
	struct qmp_pcie *qmp = phy_get_drvdata(phy);
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	int ret;

	ret = qmp_pcie_pd_power_on(qmp);
	if (ret)
		return ret;

	ret = regulator_bulk_enable(cfg->num_vregs, qmp->vregs);
	if (ret) {
		dev_err(qmp->dev, "failed to enable regulators: %d\n", ret);
		goto err_pd_power_off;
	}

	ret = reset_control_bulk_assert(qmp->cfg->num_nocsr_resets, qmp->nocsr_resets);
	if (ret) {
		dev_err(qmp->dev, "no-csr reset assert failed: %d\n", ret);
		goto err_disable_regulators;
	}

	usleep_range(200, 300);

	ret = clk_bulk_prepare_enable(qmp->cfg->num_clks, qmp->clks);
	if (ret)
		goto err_disable_regulators;

	return 0;

err_disable_regulators:
	regulator_bulk_disable(cfg->num_vregs, qmp->vregs);
err_pd_power_off:
	qmp_pcie_pd_power_off(qmp);

	return ret;
}

static int qmp_pcie_exit(struct phy *phy)
{
	struct qmp_pcie *qmp = phy_get_drvdata(phy);
	const struct qmp_phy_cfg *cfg = qmp->cfg;

	reset_control_bulk_assert(qmp->cfg->num_nocsr_resets, qmp->nocsr_resets);

	clk_bulk_disable_unprepare(qmp->cfg->num_clks, qmp->clks);
	regulator_bulk_disable(cfg->num_vregs, qmp->vregs);
	qmp_pcie_pd_power_off(qmp);

	return 0;
}

static int qmp_pcie_power_on(struct phy *phy)
{
	struct qmp_pcie *qmp = phy_get_drvdata(phy);
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	const struct qmp_pcie_offsets *offs = cfg->offsets;
	void __iomem *status;
	unsigned int val;
	int i, ret;

	ret = clk_bulk_prepare_enable(qmp->cfg->num_pipe_clks, qmp->pipe_clks);
	if (ret)
		return ret;

	ret = reset_control_bulk_deassert(qmp->cfg->num_nocsr_resets, qmp->nocsr_resets);
	if (ret) {
		dev_err(qmp->dev, "no-csr reset deassert failed: %d\n", ret);
		goto err_disable_pipe_clk;
	}

	for (i = 0; i < cfg->num_regs; i++) {
		status = qmp->base[i] + offs->pcs + cfg->regs[QPHY_PCS_STATUS];
		ret = readl_poll_timeout(status, val, !(val & cfg->phy_status), 200,
					 PHY_INIT_COMPLETE_TIMEOUT_US);
		if (ret) {
			dev_err(qmp->dev, "PHY power on timed-out (%s): %d\n",
				cfg->reg_names[i], ret);
			goto err_disable_pipe_clk;
		}
	}

	return 0;

err_disable_pipe_clk:
	clk_bulk_disable_unprepare(qmp->cfg->num_pipe_clks, qmp->pipe_clks);

	return ret;
}

static int qmp_pcie_power_off(struct phy *phy)
{
	struct qmp_pcie *qmp = phy_get_drvdata(phy);

	clk_bulk_disable_unprepare(qmp->cfg->num_pipe_clks, qmp->pipe_clks);

	return 0;
}

static int qmp_pcie_enable(struct phy *phy)
{
	int ret;

	ret = qmp_pcie_init(phy);
	if (ret)
		return ret;

	ret = qmp_pcie_power_on(phy);
	if (ret)
		qmp_pcie_exit(phy);

	return ret;
}

static int qmp_pcie_disable(struct phy *phy)
{
	int ret;

	ret = qmp_pcie_power_off(phy);
	if (ret)
		return ret;

	return qmp_pcie_exit(phy);
}

static const struct phy_ops qmp_pcie_phy_ops = {
	.power_on	= qmp_pcie_enable,
	.power_off	= qmp_pcie_disable,
	.owner		= THIS_MODULE,
};

static void qmp_pcie_pd_detach(void *data)
{
	struct qmp_pcie *qmp = data;
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	int i;

	for (i = 0; i < cfg->num_pds; i++) {
		if (!IS_ERR_OR_NULL(qmp->pd_devs[i]))
			dev_pm_domain_detach(qmp->pd_devs[i], true);
	}
}

static int qmp_pcie_pd_init(struct qmp_pcie *qmp)
{
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	struct device *dev = qmp->dev;
	int i, ret;

	if (!cfg->num_pds)
		return 0;

	qmp->pd_devs = devm_kcalloc(dev, cfg->num_pds, sizeof(*qmp->pd_devs),
				    GFP_KERNEL);
	if (!qmp->pd_devs)
		return -ENOMEM;

	for (i = 0; i < cfg->num_pds; i++) {
		qmp->pd_devs[i] = dev_pm_domain_attach_by_name(dev,
							       cfg->pd_names[i]);
		if (IS_ERR_OR_NULL(qmp->pd_devs[i])) {
			ret = PTR_ERR(qmp->pd_devs[i]) ? : -ENODATA;
			goto err_detach;
		}
	}

	return devm_add_action_or_reset(dev, qmp_pcie_pd_detach, qmp);

err_detach:
	while (--i >= 0)
		dev_pm_domain_detach(qmp->pd_devs[i], false);

	return ret;
}

static int qmp_pcie_vreg_init(struct qmp_pcie *qmp)
{
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	struct device *dev = qmp->dev;
	int i;

	qmp->vregs = devm_kcalloc(dev, cfg->num_vregs, sizeof(*qmp->vregs),
				  GFP_KERNEL);
	if (!qmp->vregs)
		return -ENOMEM;

	for (i = 0; i < cfg->num_vregs; i++)
		qmp->vregs[i].supply = cfg->vreg_list[i];

	return devm_regulator_bulk_get(dev, cfg->num_vregs, qmp->vregs);
}

static int qmp_pcie_reset_init(struct qmp_pcie *qmp)
{
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	struct device *dev = qmp->dev;
	int i, ret;

	qmp->nocsr_resets = devm_kcalloc(dev, cfg->num_nocsr_resets,
					 sizeof(*qmp->nocsr_resets),
					 GFP_KERNEL);
	if (!qmp->nocsr_resets)
		return -ENOMEM;

	for (i = 0; i < cfg->num_nocsr_resets; i++)
		qmp->nocsr_resets[i].id = cfg->nocsr_reset_list[i];

	ret = devm_reset_control_bulk_get_exclusive(dev,
						    cfg->num_nocsr_resets,
						    qmp->nocsr_resets);
	if (ret)
		return dev_err_probe(dev, ret, "failed to get no-csr resets\n");

	return 0;
}

static int qmp_pcie_clk_init(struct qmp_pcie *qmp)
{
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	struct device *dev = qmp->dev;
	int i, ret;

	qmp->clks = devm_kcalloc(dev, cfg->num_clks, sizeof(*qmp->clks),
				 GFP_KERNEL);
	if (!qmp->clks)
		return -ENOMEM;

	for (i = 0; i < cfg->num_clks; i++)
		qmp->clks[i].id = cfg->clk_list[i];

	ret = devm_clk_bulk_get_optional(dev, cfg->num_clks, qmp->clks);
	if (ret)
		return ret;

	qmp->pipe_clks = devm_kcalloc(dev, cfg->num_pipe_clks,
				      sizeof(*qmp->pipe_clks), GFP_KERNEL);
	if (!qmp->pipe_clks)
		return -ENOMEM;

	for (i = 0; i < cfg->num_pipe_clks; i++)
		qmp->pipe_clks[i].id = cfg->pipe_clk_list[i];

	return devm_clk_bulk_get_optional(dev, cfg->num_pipe_clks,
					  qmp->pipe_clks);
}

static int __phy_pipe_clk_register(struct device *dev, struct device_node *np,
				   int idx, struct clk_fixed_rate *fixed)
{
	struct clk_init_data init = { };
	int ret;

	ret = of_property_read_string_index(np, "clock-output-names", idx,
					    &init.name);
	if (ret) {
		dev_err(dev, "%pOFn: No clock-output-names\n", np);
		return ret;
	}

	init.ops = &clk_fixed_rate_ops;

	fixed->fixed_rate = 125000000;

	fixed->hw.init = &init;

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

static struct clk_hw *
qmp_pcie_multiphy_clk_hw_get(struct of_phandle_args *clkspec, void *data)
{
	struct qmp_pcie_multiphy *qmp_data = data;
	unsigned int idx = 0;

	if (clkspec->args_count)
		idx = clkspec->args[0];

	if (idx < (unsigned int)qmp_data->num_pipe_outputs)
		return &qmp_data->pipe_out_clks[idx].hw;

	return ERR_PTR(-EINVAL);
}

static int qmp_pcie_multiphy_register_clocks(struct device *dev,
					     struct device_node *np,
					     struct qmp_pcie_multiphy *qmp_data)
{
	int num_pipe_outputs;
	int i, ret;

	num_pipe_outputs = of_property_count_strings(np, "clock-output-names");

	qmp_data->num_pipe_outputs = num_pipe_outputs;
	qmp_data->pipe_out_clks = devm_kcalloc(dev, num_pipe_outputs,
					       sizeof(*qmp_data->pipe_out_clks),
					       GFP_KERNEL);
	if (!qmp_data->pipe_out_clks)
		return -ENOMEM;

	for (i = 0; i < num_pipe_outputs; i++) {
		ret = __phy_pipe_clk_register(dev, np, i,
					      &qmp_data->pipe_out_clks[i]);
		if (ret)
			return ret;
	}

	return devm_of_clk_add_hw_provider(dev, qmp_pcie_multiphy_clk_hw_get, qmp_data);
}

static int qmp_pcie_get_mmio(struct qmp_pcie *qmp)
{
	struct platform_device *pdev = to_platform_device(qmp->dev);
	const struct qmp_phy_cfg *cfg = qmp->cfg;
	struct device *dev = qmp->dev;
	void __iomem *base;
	int i;

	qmp->base = devm_kcalloc(dev, cfg->num_regs, sizeof(*qmp->base),
				 GFP_KERNEL);
	if (!qmp->base)
		return -ENOMEM;

	for (i = 0; i < cfg->num_regs; i++) {
		base = devm_platform_ioremap_resource_byname(pdev, cfg->reg_names[i]);
		if (IS_ERR(base))
			return PTR_ERR(base);

		qmp->base[i] = base;
	}

	return 0;
}

static int qmp_pcie_read_link_mode(struct device *dev, unsigned int *link_mode)
{
	struct regmap *map;
	unsigned int args[1];

	map = syscon_regmap_lookup_by_phandle_args(dev->of_node, "qcom,link-mode",
						   ARRAY_SIZE(args), args);
	if (IS_ERR(map))
		return PTR_ERR(map);

	return regmap_read(map, args[0], link_mode);
}

static struct phy *qmp_pcie_multiphy_xlate(struct device *dev,
					   const struct of_phandle_args *args)
{
	struct qmp_pcie_multiphy *qmp_data = dev_get_drvdata(dev);
	unsigned int idx;

	if (!qmp_data || args->args_count < 1)
		return ERR_PTR(-EINVAL);

	idx = args->args[0];

	if (idx < (unsigned int)qmp_data->mode_cfg->num_phys)
		return qmp_data->phys[idx] ?: ERR_PTR(-EINVAL);

	return ERR_PTR(-EINVAL);
}

static int qmp_pcie_probe_phy(struct qmp_pcie *qmp, struct device_node *np,
			      struct phy **out_phy)
{
	int ret;

	ret = qmp_pcie_get_mmio(qmp);
	if (ret)
		return ret;

	ret = qmp_pcie_clk_init(qmp);
	if (ret)
		return ret;

	ret = qmp_pcie_reset_init(qmp);
	if (ret)
		return ret;

	ret = qmp_pcie_vreg_init(qmp);
	if (ret)
		return ret;

	ret = qmp_pcie_pd_init(qmp);
	if (ret)
		return ret;

	*out_phy = devm_phy_create(qmp->dev, np, &qmp_pcie_phy_ops);
	if (IS_ERR(*out_phy))
		return PTR_ERR(*out_phy);

	phy_set_drvdata(*out_phy, qmp);

	return 0;
}

static int qmp_pcie_multiphy_probe(struct platform_device *pdev)
{
	const struct qmp_pcie_match_data *match_data;
	struct qmp_pcie_multiphy *qmp_data;
	struct phy_provider *phy_provider;
	struct device *dev = &pdev->dev;
	unsigned int link_mode;
	struct qmp_pcie *qmp;
	struct phy **phys;
	int phy_index;
	int ret;

	qmp_data = devm_kzalloc(dev, sizeof(*qmp_data), GFP_KERNEL);

	match_data = of_device_get_match_data(dev);
	if (!match_data)
		return -EINVAL;

	if (!qmp_data)
		return -ENOMEM;

	ret = qmp_pcie_read_link_mode(dev, &link_mode);
	if (ret)
		return dev_err_probe(dev, ret, "failed to read qcom,link-mode\n");

	if (link_mode >= match_data->num_modes)
		return dev_err_probe(dev, -EINVAL, "invalid qcom,link-mode: %u\n",
				     link_mode);

	qmp_data->mode_cfg = &match_data->mode_cfgs[link_mode];

	qmp = devm_kcalloc(dev, qmp_data->mode_cfg->num_phys, sizeof(*qmp), GFP_KERNEL);
	if (!qmp)
		return -ENOMEM;

	phys = devm_kcalloc(dev, qmp_data->mode_cfg->num_phys, sizeof(*phys), GFP_KERNEL);
	if (!phys)
		return -ENOMEM;

	qmp_data->phys = phys;
	dev_set_drvdata(dev, qmp_data);

	for (phy_index = 0; phy_index < qmp_data->mode_cfg->num_phys; phy_index++) {
		qmp[phy_index].dev = dev;
		qmp[phy_index].cfg = qmp_data->mode_cfg->cfgs[phy_index];
		ret = qmp_pcie_probe_phy(&qmp[phy_index], dev->of_node, &phys[phy_index]);
		if (ret)
			return ret;
	}

	ret = qmp_pcie_multiphy_register_clocks(dev, dev->of_node, qmp_data);
	if (ret)
		return ret;

	phy_provider = devm_of_phy_provider_register(dev, qmp_pcie_multiphy_xlate);

	return PTR_ERR_OR_ZERO(phy_provider);
}

static const struct of_device_id qmp_pcie_multiphy_of_match_table[] = {
	{
		.compatible = "qcom,glymur-qmp-gen5x8-pcie-phy",
		.data = &glymur_qmp_gen5x8_match_data,
	},
	{ }
};
MODULE_DEVICE_TABLE(of, qmp_pcie_multiphy_of_match_table);

static struct platform_driver qmp_pcie_multiphy_driver = {
	.probe		= qmp_pcie_multiphy_probe,
	.driver = {
		.name	= "qcom-qmp-pcie-multiphy",
		.of_match_table = qmp_pcie_multiphy_of_match_table,
	},
};
module_platform_driver(qmp_pcie_multiphy_driver);

MODULE_AUTHOR("Qiang Yu <qiang.yu@oss.qualcomm.com>");
MODULE_DESCRIPTION("Qualcomm QMP PCIe Multi-PHY driver for Glymur");
MODULE_LICENSE("GPL");