usb: phy: msm: Migrate to Managed Device Resource allocation (6b99c68e) · Commits · jan.koester / Linux

drivers/usb/phy/phy-msm-usb.c

+68 −119

Original line number	Original line	Diff line number	Diff line
	@@ -63,27 +63,18 @@ static int msm_hsusb_init_vddcx(struct msm_otg *motg, int init)
	int ret = 0;		int ret = 0;

	if (init) {		if (init) {
	motg->vddcx = regulator_get(motg->phy.dev, "HSUSB_VDDCX");
	if (IS_ERR(motg->vddcx)) {
	dev_err(motg->phy.dev, "unable to get hsusb vddcx\n");
	return PTR_ERR(motg->vddcx);
	}

	ret = regulator_set_voltage(motg->vddcx,		ret = regulator_set_voltage(motg->vddcx,
	USB_PHY_VDD_DIG_VOL_MIN,		USB_PHY_VDD_DIG_VOL_MIN,
	USB_PHY_VDD_DIG_VOL_MAX);		USB_PHY_VDD_DIG_VOL_MAX);
	if (ret) {		if (ret) {
	dev_err(motg->phy.dev, "unable to set the voltage "		dev_err(motg->phy.dev, "unable to set the voltage "
	"for hsusb vddcx\n");		"for hsusb vddcx\n");
	regulator_put(motg->vddcx);
	return ret;		return ret;
	}		}

	ret = regulator_enable(motg->vddcx);		ret = regulator_enable(motg->vddcx);
	if (ret) {		if (ret)
	dev_err(motg->phy.dev, "unable to enable hsusb vddcx\n");		dev_err(motg->phy.dev, "unable to enable hsusb vddcx\n");
	regulator_put(motg->vddcx);
	}
	} else {		} else {
	ret = regulator_set_voltage(motg->vddcx, 0,		ret = regulator_set_voltage(motg->vddcx, 0,
	USB_PHY_VDD_DIG_VOL_MAX);		USB_PHY_VDD_DIG_VOL_MAX);
	@@ -93,8 +84,6 @@ static int msm_hsusb_init_vddcx(struct msm_otg *motg, int init)
	ret = regulator_disable(motg->vddcx);		ret = regulator_disable(motg->vddcx);
	if (ret)		if (ret)
	dev_err(motg->phy.dev, "unable to disable hsusb vddcx\n");		dev_err(motg->phy.dev, "unable to disable hsusb vddcx\n");

	regulator_put(motg->vddcx);
	}		}

	return ret;		return ret;
	@@ -105,53 +94,38 @@ static int msm_hsusb_ldo_init(struct msm_otg *motg, int init)
	int rc = 0;		int rc = 0;

	if (init) {		if (init) {
	motg->v3p3 = regulator_get(motg->phy.dev, "HSUSB_3p3");
	if (IS_ERR(motg->v3p3)) {
	dev_err(motg->phy.dev, "unable to get hsusb 3p3\n");
	return PTR_ERR(motg->v3p3);
	}

	rc = regulator_set_voltage(motg->v3p3, USB_PHY_3P3_VOL_MIN,		rc = regulator_set_voltage(motg->v3p3, USB_PHY_3P3_VOL_MIN,
	USB_PHY_3P3_VOL_MAX);		USB_PHY_3P3_VOL_MAX);
	if (rc) {		if (rc) {
	dev_err(motg->phy.dev, "unable to set voltage level "		dev_err(motg->phy.dev, "unable to set voltage level "
	"for hsusb 3p3\n");		"for hsusb 3p3\n");
	goto put_3p3;		goto exit;
	}		}
	rc = regulator_enable(motg->v3p3);		rc = regulator_enable(motg->v3p3);
	if (rc) {		if (rc) {
	dev_err(motg->phy.dev, "unable to enable the hsusb 3p3\n");		dev_err(motg->phy.dev, "unable to enable the hsusb 3p3\n");
	goto put_3p3;		goto exit;
	}
	motg->v1p8 = regulator_get(motg->phy.dev, "HSUSB_1p8");
	if (IS_ERR(motg->v1p8)) {
	dev_err(motg->phy.dev, "unable to get hsusb 1p8\n");
	rc = PTR_ERR(motg->v1p8);
	goto disable_3p3;
	}		}
	rc = regulator_set_voltage(motg->v1p8, USB_PHY_1P8_VOL_MIN,		rc = regulator_set_voltage(motg->v1p8, USB_PHY_1P8_VOL_MIN,
	USB_PHY_1P8_VOL_MAX);		USB_PHY_1P8_VOL_MAX);
	if (rc) {		if (rc) {
	dev_err(motg->phy.dev, "unable to set voltage level "		dev_err(motg->phy.dev, "unable to set voltage level "
	"for hsusb 1p8\n");		"for hsusb 1p8\n");
	goto put_1p8;		goto disable_3p3;
	}		}
	rc = regulator_enable(motg->v1p8);		rc = regulator_enable(motg->v1p8);
	if (rc) {		if (rc) {
	dev_err(motg->phy.dev, "unable to enable the hsusb 1p8\n");		dev_err(motg->phy.dev, "unable to enable the hsusb 1p8\n");
	goto put_1p8;		goto disable_3p3;
	}		}

	return 0;		return 0;
	}		}

	regulator_disable(motg->v1p8);		regulator_disable(motg->v1p8);
	put_1p8:
	regulator_put(motg->v1p8);
	disable_3p3:		disable_3p3:
	regulator_disable(motg->v3p3);		regulator_disable(motg->v3p3);
	put_3p3:		exit:
	regulator_put(motg->v3p3);
	return rc;		return rc;
	}		}

	@@ -506,7 +480,7 @@ static int msm_otg_suspend(struct msm_otg *motg)

	clk_disable_unprepare(motg->pclk);		clk_disable_unprepare(motg->pclk);
	clk_disable_unprepare(motg->clk);		clk_disable_unprepare(motg->clk);
	if (motg->core_clk)		if (!IS_ERR(motg->core_clk))
	clk_disable_unprepare(motg->core_clk);		clk_disable_unprepare(motg->core_clk);

	if (!IS_ERR(motg->pclk_src))		if (!IS_ERR(motg->pclk_src))
	@@ -546,7 +520,7 @@ static int msm_otg_resume(struct msm_otg *motg)

	clk_prepare_enable(motg->pclk);		clk_prepare_enable(motg->pclk);
	clk_prepare_enable(motg->clk);		clk_prepare_enable(motg->clk);
	if (motg->core_clk)		if (!IS_ERR(motg->core_clk))
	clk_prepare_enable(motg->core_clk);		clk_prepare_enable(motg->core_clk);

	if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&		if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
	@@ -1404,6 +1378,7 @@ static void msm_otg_debugfs_cleanup(void)

	static int msm_otg_probe(struct platform_device *pdev)		static int msm_otg_probe(struct platform_device *pdev)
	{		{
			struct regulator_bulk_data regs[3];
	int ret = 0;		int ret = 0;
	struct resource *res;		struct resource *res;
	struct msm_otg *motg;		struct msm_otg *motg;
	@@ -1415,37 +1390,34 @@ static int msm_otg_probe(struct platform_device *pdev)
	return -ENODEV;		return -ENODEV;
	}		}

	motg = kzalloc(sizeof(struct msm_otg), GFP_KERNEL);		motg = devm_kzalloc(&pdev->dev, sizeof(struct msm_otg), GFP_KERNEL);
	if (!motg) {		if (!motg) {
	dev_err(&pdev->dev, "unable to allocate msm_otg\n");		dev_err(&pdev->dev, "unable to allocate msm_otg\n");
	return -ENOMEM;		return -ENOMEM;
	}		}

	motg->phy.otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL);		motg->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg),
			GFP_KERNEL);
	if (!motg->phy.otg) {		if (!motg->phy.otg) {
	dev_err(&pdev->dev, "unable to allocate msm_otg\n");		dev_err(&pdev->dev, "unable to allocate msm_otg\n");
	ret = -ENOMEM;		return -ENOMEM;
	goto free_motg;
	}		}

	motg->pdata = dev_get_platdata(&pdev->dev);		motg->pdata = dev_get_platdata(&pdev->dev);
	phy = &motg->phy;		phy = &motg->phy;
	phy->dev = &pdev->dev;		phy->dev = &pdev->dev;

	motg->phy_reset_clk = clk_get(&pdev->dev, "usb_phy_clk");		motg->phy_reset_clk = devm_clk_get(&pdev->dev, "usb_phy_clk");
	if (IS_ERR(motg->phy_reset_clk)) {		if (IS_ERR(motg->phy_reset_clk)) {
	dev_err(&pdev->dev, "failed to get usb_phy_clk\n");		dev_err(&pdev->dev, "failed to get usb_phy_clk\n");
	ret = PTR_ERR(motg->phy_reset_clk);		return PTR_ERR(motg->phy_reset_clk);
	goto free_motg;
	}		}

	motg->clk = clk_get(&pdev->dev, "usb_hs_clk");		motg->clk = devm_clk_get(&pdev->dev, "usb_hs_clk");
	if (IS_ERR(motg->clk)) {		if (IS_ERR(motg->clk)) {
	dev_err(&pdev->dev, "failed to get usb_hs_clk\n");		dev_err(&pdev->dev, "failed to get usb_hs_clk\n");
	ret = PTR_ERR(motg->clk);		return PTR_ERR(motg->clk);
	goto put_phy_reset_clk;
	}		}
	clk_set_rate(motg->clk, 60000000);

	/*		/*
	* If USB Core is running its protocol engine based on CORE CLK,		* If USB Core is running its protocol engine based on CORE CLK,
	@@ -1454,22 +1426,18 @@ static int msm_otg_probe(struct platform_device *pdev)
	* CORE CLK. For such USB cores, vote for maximum clk frequency		* CORE CLK. For such USB cores, vote for maximum clk frequency
	* on pclk source		* on pclk source
	*/		*/
			motg->pclk_src = ERR_PTR(-ENOENT);
	if (motg->pdata->pclk_src_name) {		if (motg->pdata->pclk_src_name) {
	motg->pclk_src = clk_get(&pdev->dev,		motg->pclk_src = devm_clk_get(&pdev->dev,
	motg->pdata->pclk_src_name);		motg->pdata->pclk_src_name);
	if (IS_ERR(motg->pclk_src))		if (IS_ERR(motg->pclk_src))
	goto put_clk;		return PTR_ERR(motg->pclk_src);
	clk_set_rate(motg->pclk_src, INT_MAX);		}
	clk_prepare_enable(motg->pclk_src);
	} else
	motg->pclk_src = ERR_PTR(-ENOENT);


	motg->pclk = clk_get(&pdev->dev, "usb_hs_pclk");		motg->pclk = devm_clk_get(&pdev->dev, "usb_hs_pclk");
	if (IS_ERR(motg->pclk)) {		if (IS_ERR(motg->pclk)) {
	dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");		dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");
	ret = PTR_ERR(motg->pclk);		return PTR_ERR(motg->pclk);
	goto put_pclk_src;
	}		}

	/*		/*
	@@ -1477,65 +1445,72 @@ static int msm_otg_probe(struct platform_device *pdev)
	* clock is introduced to remove the dependency on AXI		* clock is introduced to remove the dependency on AXI
	* bus frequency.		* bus frequency.
	*/		*/
	motg->core_clk = clk_get(&pdev->dev, "usb_hs_core_clk");		motg->core_clk = devm_clk_get(&pdev->dev, "usb_hs_core_clk");
	if (IS_ERR(motg->core_clk))
	motg->core_clk = NULL;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);		res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {		motg->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
	dev_err(&pdev->dev, "failed to get platform resource mem\n");		if (IS_ERR(motg->regs))
	ret = -ENODEV;		return PTR_ERR(motg->regs);
	goto put_core_clk;
	}

	motg->regs = ioremap(res->start, resource_size(res));
	if (!motg->regs) {
	dev_err(&pdev->dev, "ioremap failed\n");
	ret = -ENOMEM;
	goto put_core_clk;
	}
	dev_info(&pdev->dev, "OTG regs = %p\n", motg->regs);		dev_info(&pdev->dev, "OTG regs = %p\n", motg->regs);

	motg->irq = platform_get_irq(pdev, 0);		motg->irq = platform_get_irq(pdev, 0);
	if (!motg->irq) {		if (!motg->irq) {
	dev_err(&pdev->dev, "platform_get_irq failed\n");		dev_err(&pdev->dev, "platform_get_irq failed\n");
	ret = -ENODEV;		return motg->irq;
	goto free_regs;		}

			regs[0].supply = "HSUSB_VDDCX";
			regs[1].supply = "HSUSB_3p3";
			regs[2].supply = "HSUSB_1p8";

			ret = devm_regulator_bulk_get(motg->phy.dev, ARRAY_SIZE(regs), regs);
			if (ret)
			return ret;

			motg->vddcx = regs[0].consumer;
			motg->v3p3 = regs[1].consumer;
			motg->v1p8 = regs[2].consumer;

			clk_set_rate(motg->clk, 60000000);
			if (!IS_ERR(motg->pclk_src)) {
			clk_set_rate(motg->pclk_src, INT_MAX);
			clk_prepare_enable(motg->pclk_src);
	}		}

	clk_prepare_enable(motg->clk);		clk_prepare_enable(motg->clk);
	clk_prepare_enable(motg->pclk);		clk_prepare_enable(motg->pclk);

			if (!IS_ERR(motg->core_clk))
			clk_prepare_enable(motg->core_clk);

	ret = msm_hsusb_init_vddcx(motg, 1);		ret = msm_hsusb_init_vddcx(motg, 1);
	if (ret) {		if (ret) {
	dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");		dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
	goto free_regs;		goto disable_clks;
	}		}

	ret = msm_hsusb_ldo_init(motg, 1);		ret = msm_hsusb_ldo_init(motg, 1);
	if (ret) {		if (ret) {
	dev_err(&pdev->dev, "hsusb vreg configuration failed\n");		dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
	goto vddcx_exit;		goto disable_vddcx;
	}		}
	ret = msm_hsusb_ldo_set_mode(motg, 1);		ret = msm_hsusb_ldo_set_mode(motg, 1);
	if (ret) {		if (ret) {
	dev_err(&pdev->dev, "hsusb vreg enable failed\n");		dev_err(&pdev->dev, "hsusb vreg enable failed\n");
	goto ldo_exit;		goto disable_ldo;
	}		}

	if (motg->core_clk)
	clk_prepare_enable(motg->core_clk);

	writel(0, USB_USBINTR);		writel(0, USB_USBINTR);
	writel(0, USB_OTGSC);		writel(0, USB_OTGSC);

	INIT_WORK(&motg->sm_work, msm_otg_sm_work);		INIT_WORK(&motg->sm_work, msm_otg_sm_work);
	INIT_DELAYED_WORK(&motg->chg_work, msm_chg_detect_work);		INIT_DELAYED_WORK(&motg->chg_work, msm_chg_detect_work);
	ret = request_irq(motg->irq, msm_otg_irq, IRQF_SHARED,		ret = devm_request_irq(&pdev->dev, motg->irq, msm_otg_irq, IRQF_SHARED,
	"msm_otg", motg);		"msm_otg", motg);
	if (ret) {		if (ret) {
	dev_err(&pdev->dev, "request irq failed\n");		dev_err(&pdev->dev, "request irq failed\n");
	goto disable_clks;		goto disable_ldo;
	}		}

	phy->init = msm_otg_reset;		phy->init = msm_otg_reset;
	@@ -1550,7 +1525,7 @@ static int msm_otg_probe(struct platform_device *pdev)
	ret = usb_add_phy(&motg->phy, USB_PHY_TYPE_USB2);		ret = usb_add_phy(&motg->phy, USB_PHY_TYPE_USB2);
	if (ret) {		if (ret) {
	dev_err(&pdev->dev, "usb_add_phy failed\n");		dev_err(&pdev->dev, "usb_add_phy failed\n");
	goto free_irq;		goto disable_ldo;
	}		}

	platform_set_drvdata(pdev, motg);		platform_set_drvdata(pdev, motg);
	@@ -1568,33 +1543,18 @@ static int msm_otg_probe(struct platform_device *pdev)
	pm_runtime_enable(&pdev->dev);		pm_runtime_enable(&pdev->dev);

	return 0;		return 0;
	free_irq:
	free_irq(motg->irq, motg);		disable_ldo:
			msm_hsusb_ldo_init(motg, 0);
			disable_vddcx:
			msm_hsusb_init_vddcx(motg, 0);
	disable_clks:		disable_clks:
	clk_disable_unprepare(motg->pclk);		clk_disable_unprepare(motg->pclk);
	clk_disable_unprepare(motg->clk);		clk_disable_unprepare(motg->clk);
	ldo_exit:		if (!IS_ERR(motg->core_clk))
	msm_hsusb_ldo_init(motg, 0);		clk_disable_unprepare(motg->core_clk);
	vddcx_exit:		if (!IS_ERR(motg->pclk_src))
	msm_hsusb_init_vddcx(motg, 0);
	free_regs:
	iounmap(motg->regs);
	put_core_clk:
	if (motg->core_clk)
	clk_put(motg->core_clk);
	clk_put(motg->pclk);
	put_pclk_src:
	if (!IS_ERR(motg->pclk_src)) {
	clk_disable_unprepare(motg->pclk_src);		clk_disable_unprepare(motg->pclk_src);
	clk_put(motg->pclk_src);
	}
	put_clk:
	clk_put(motg->clk);
	put_phy_reset_clk:
	clk_put(motg->phy_reset_clk);
	free_motg:
	kfree(motg->phy.otg);
	kfree(motg);
	return ret;		return ret;
	}		}

	@@ -1617,7 +1577,7 @@ static int msm_otg_remove(struct platform_device *pdev)
	pm_runtime_disable(&pdev->dev);		pm_runtime_disable(&pdev->dev);

	usb_remove_phy(phy);		usb_remove_phy(phy);
	free_irq(motg->irq, motg);		disable_irq(motg->irq);

	/*		/*
	* Put PHY in low power mode.		* Put PHY in low power mode.
	@@ -1637,26 +1597,15 @@ static int msm_otg_remove(struct platform_device *pdev)

	clk_disable_unprepare(motg->pclk);		clk_disable_unprepare(motg->pclk);
	clk_disable_unprepare(motg->clk);		clk_disable_unprepare(motg->clk);
	if (motg->core_clk)		if (!IS_ERR(motg->core_clk))
	clk_disable_unprepare(motg->core_clk);		clk_disable_unprepare(motg->core_clk);
	if (!IS_ERR(motg->pclk_src)) {		if (!IS_ERR(motg->pclk_src))
	clk_disable_unprepare(motg->pclk_src);		clk_disable_unprepare(motg->pclk_src);
	clk_put(motg->pclk_src);
	}
	msm_hsusb_ldo_init(motg, 0);		msm_hsusb_ldo_init(motg, 0);

	iounmap(motg->regs);
	pm_runtime_set_suspended(&pdev->dev);		pm_runtime_set_suspended(&pdev->dev);

	clk_put(motg->phy_reset_clk);
	clk_put(motg->pclk);
	clk_put(motg->clk);
	if (motg->core_clk)
	clk_put(motg->core_clk);

	kfree(motg->phy.otg);
	kfree(motg);

	return 0;		return 0;
	}		}