drivers/usb/dwc2/platform.c - linux - Git at Google

 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
 /*
  * platform.c - DesignWare HS OTG Controller platform driver
  *
  * Copyright (C) Matthijs Kooijman <matthijs@stdin.nl>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions, and the following disclaimer,
  *    without modification.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The names of the above-listed copyright holders may not be used
  *    to endorse or promote products derived from this software without
  *    specific prior written permission.
  *
  * ALTERNATIVELY, this software may be distributed under the terms of the
  * GNU General Public License ("GPL") as published by the Free Software
  * Foundation; either version 2 of the License, or (at your option) any
  * later version.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/of_device.h>
 #include <linux/mutex.h>
 #include <linux/platform_device.h>
 #include <linux/phy/phy.h>
 #include <linux/platform_data/s3c-hsotg.h>
 #include <linux/reset.h>

 #include <linux/usb/of.h>

 #include "core.h"
 #include "hcd.h"
 #include "debug.h"

 static const char dwc2_driver_name[] = "dwc2";

 /*
  * Check the dr_mode against the module configuration and hardware
  * capabilities.
  *
  * The hardware, module, and dr_mode, can each be set to host, device,
  * or otg. Check that all these values are compatible and adjust the
  * value of dr_mode if possible.
  *
  *                      actual
  *    HW  MOD dr_mode   dr_mode
  *  ------------------------------
  *   HST  HST  any    :  HST
  *   HST  DEV  any    :  ---
  *   HST  OTG  any    :  HST
  *
  *   DEV  HST  any    :  ---
  *   DEV  DEV  any    :  DEV
  *   DEV  OTG  any    :  DEV
  *
  *   OTG  HST  any    :  HST
  *   OTG  DEV  any    :  DEV
  *   OTG  OTG  any    :  dr_mode
  */
 static int dwc2_get_dr_mode(struct dwc2_hsotg *hsotg)
 {
 	enum usb_dr_mode mode;

 	hsotg->dr_mode = usb_get_dr_mode(hsotg->dev);
 	if (hsotg->dr_mode == USB_DR_MODE_UNKNOWN)
 		hsotg->dr_mode = USB_DR_MODE_OTG;

 	mode = hsotg->dr_mode;

 	if (dwc2_hw_is_device(hsotg)) {
 		if (IS_ENABLED(CONFIG_USB_DWC2_HOST)) {
 			dev_err(hsotg->dev,
 				"Controller does not support host mode.\n");
 			return -EINVAL;
 		}
 		mode = USB_DR_MODE_PERIPHERAL;
 	} else if (dwc2_hw_is_host(hsotg)) {
 		if (IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL)) {
 			dev_err(hsotg->dev,
 				"Controller does not support device mode.\n");
 			return -EINVAL;
 		}
 		mode = USB_DR_MODE_HOST;
 	} else {
 		if (IS_ENABLED(CONFIG_USB_DWC2_HOST))
 			mode = USB_DR_MODE_HOST;
 		else if (IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL))
 			mode = USB_DR_MODE_PERIPHERAL;
 	}

 	if (mode != hsotg->dr_mode) {
 		dev_warn(hsotg->dev,
 			 "Configuration mismatch. dr_mode forced to %s\n",
 			mode == USB_DR_MODE_HOST ? "host" : "device");

 		hsotg->dr_mode = mode;
 	}

 	return 0;
 }

 static int __dwc2_lowlevel_hw_enable(struct dwc2_hsotg *hsotg)
 {
 	struct platform_device *pdev = to_platform_device(hsotg->dev);
 	int ret;

 	ret = regulator_bulk_enable(ARRAY_SIZE(hsotg->supplies),
 				    hsotg->supplies);
 	if (ret)
 		return ret;

 	if (hsotg->clk) {
 		ret = clk_prepare_enable(hsotg->clk);
 		if (ret)
 			return ret;
 	}

 	if (hsotg->uphy) {
 		ret = usb_phy_init(hsotg->uphy);
 	} else if (hsotg->plat && hsotg->plat->phy_init) {
 		ret = hsotg->plat->phy_init(pdev, hsotg->plat->phy_type);
 	} else {
 		ret = phy_power_on(hsotg->phy);
 		if (ret == 0)
 			ret = phy_init(hsotg->phy);
 	}

 	return ret;
 }

 /**
  * dwc2_lowlevel_hw_enable - enable platform lowlevel hw resources
  * @hsotg: The driver state
  *
  * A wrapper for platform code responsible for controlling
  * low-level USB platform resources (phy, clock, regulators)
  */
 int dwc2_lowlevel_hw_enable(struct dwc2_hsotg *hsotg)
 {
 	int ret = __dwc2_lowlevel_hw_enable(hsotg);

 	if (ret == 0)
 		hsotg->ll_hw_enabled = true;
 	return ret;
 }

 static int __dwc2_lowlevel_hw_disable(struct dwc2_hsotg *hsotg)
 {
 	struct platform_device *pdev = to_platform_device(hsotg->dev);
 	int ret = 0;

 	if (hsotg->uphy) {
 		usb_phy_shutdown(hsotg->uphy);
 	} else if (hsotg->plat && hsotg->plat->phy_exit) {
 		ret = hsotg->plat->phy_exit(pdev, hsotg->plat->phy_type);
 	} else {
 		ret = phy_exit(hsotg->phy);
 		if (ret == 0)
 			ret = phy_power_off(hsotg->phy);
 	}
 	if (ret)
 		return ret;

 	if (hsotg->clk)
 		clk_disable_unprepare(hsotg->clk);

 	ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
 				     hsotg->supplies);

 	return ret;
 }

 /**
  * dwc2_lowlevel_hw_disable - disable platform lowlevel hw resources
  * @hsotg: The driver state
  *
  * A wrapper for platform code responsible for controlling
  * low-level USB platform resources (phy, clock, regulators)
  */
 int dwc2_lowlevel_hw_disable(struct dwc2_hsotg *hsotg)
 {
 	int ret = __dwc2_lowlevel_hw_disable(hsotg);

 	if (ret == 0)
 		hsotg->ll_hw_enabled = false;
 	return ret;
 }

 static int dwc2_lowlevel_hw_init(struct dwc2_hsotg *hsotg)
 {
 	int i, ret;

 	hsotg->reset = devm_reset_control_get_optional(hsotg->dev, "dwc2");
 	if (IS_ERR(hsotg->reset)) {
 		ret = PTR_ERR(hsotg->reset);
 		dev_err(hsotg->dev, "error getting reset control %d\n", ret);
 		return ret;
 	}

 	reset_control_deassert(hsotg->reset);

 	hsotg->reset_ecc = devm_reset_control_get_optional(hsotg->dev, "dwc2-ecc");
 	if (IS_ERR(hsotg->reset_ecc)) {
 		ret = PTR_ERR(hsotg->reset_ecc);
 		dev_err(hsotg->dev, "error getting reset control for ecc %d\n", ret);
 		return ret;
 	}

 	reset_control_deassert(hsotg->reset_ecc);

 	/* Set default UTMI width */
 	hsotg->phyif = GUSBCFG_PHYIF16;

 	/*
 	 * Attempt to find a generic PHY, then look for an old style
 	 * USB PHY and then fall back to pdata
 	 */
 	hsotg->phy = devm_phy_get(hsotg->dev, "usb2-phy");
 	if (IS_ERR(hsotg->phy)) {
 		ret = PTR_ERR(hsotg->phy);
 		switch (ret) {
 		case -ENODEV:
 		case -ENOSYS:
 			hsotg->phy = NULL;
 			break;
 		case -EPROBE_DEFER:
 			return ret;
 		default:
 			dev_err(hsotg->dev, "error getting phy %d\n", ret);
 			return ret;
 		}
 	}

 	if (!hsotg->phy) {
 		hsotg->uphy = devm_usb_get_phy(hsotg->dev, USB_PHY_TYPE_USB2);
 		if (IS_ERR(hsotg->uphy)) {
 			ret = PTR_ERR(hsotg->uphy);
 			switch (ret) {
 			case -ENODEV:
 			case -ENXIO:
 				hsotg->uphy = NULL;
 				break;
 			case -EPROBE_DEFER:
 				return ret;
 			default:
 				dev_err(hsotg->dev, "error getting usb phy %d\n",
 					ret);
 				return ret;
 			}
 		}
 	}

 	hsotg->plat = dev_get_platdata(hsotg->dev);

 	if (hsotg->phy) {
 		/*
 		 * If using the generic PHY framework, check if the PHY bus
 		 * width is 8-bit and set the phyif appropriately.
 		 */
 		if (phy_get_bus_width(hsotg->phy) == 8)
 			hsotg->phyif = GUSBCFG_PHYIF8;
 	}

 	/* Clock */
 	hsotg->clk = devm_clk_get(hsotg->dev, "otg");
 	if (IS_ERR(hsotg->clk)) {
 		hsotg->clk = NULL;
 		dev_dbg(hsotg->dev, "cannot get otg clock\n");
 	}

 	/* Regulators */
 	for (i = 0; i < ARRAY_SIZE(hsotg->supplies); i++)
 		hsotg->supplies[i].supply = dwc2_hsotg_supply_names[i];

 	ret = devm_regulator_bulk_get(hsotg->dev, ARRAY_SIZE(hsotg->supplies),
 				      hsotg->supplies);
 	if (ret) {
 		dev_err(hsotg->dev, "failed to request supplies: %d\n", ret);
 		return ret;
 	}
 	return 0;
 }

 /**
  * dwc2_driver_remove() - Called when the DWC_otg core is unregistered with the
  * DWC_otg driver
  *
  * @dev: Platform device
  *
  * This routine is called, for example, when the rmmod command is executed. The
  * device may or may not be electrically present. If it is present, the driver
  * stops device processing. Any resources used on behalf of this device are
  * freed.
  */
 static int dwc2_driver_remove(struct platform_device *dev)
 {
 	struct dwc2_hsotg *hsotg = platform_get_drvdata(dev);

 	dwc2_debugfs_exit(hsotg);
 	if (hsotg->hcd_enabled)
 		dwc2_hcd_remove(hsotg);
 	if (hsotg->gadget_enabled)
 		dwc2_hsotg_remove(hsotg);

 	if (hsotg->ll_hw_enabled)
 		dwc2_lowlevel_hw_disable(hsotg);

 	reset_control_assert(hsotg->reset);
 	reset_control_assert(hsotg->reset_ecc);

 	return 0;
 }

 /**
  * dwc2_driver_shutdown() - Called on device shutdown
  *
  * @dev: Platform device
  *
  * In specific conditions (involving usb hubs) dwc2 devices can create a
  * lot of interrupts, even to the point of overwhelming devices running
  * at low frequencies. Some devices need to do special clock handling
  * at shutdown-time which may bring the system clock below the threshold
  * of being able to handle the dwc2 interrupts. Disabling dwc2-irqs
  * prevents reboots/poweroffs from getting stuck in such cases.
  */
 static void dwc2_driver_shutdown(struct platform_device *dev)
 {
 	struct dwc2_hsotg *hsotg = platform_get_drvdata(dev);

 	disable_irq(hsotg->irq);
 }

 /**
  * dwc2_driver_probe() - Called when the DWC_otg core is bound to the DWC_otg
  * driver
  *
  * @dev: Platform device
  *
  * This routine creates the driver components required to control the device
  * (core, HCD, and PCD) and initializes the device. The driver components are
  * stored in a dwc2_hsotg structure. A reference to the dwc2_hsotg is saved
  * in the device private data. This allows the driver to access the dwc2_hsotg
  * structure on subsequent calls to driver methods for this device.
  */
 static int dwc2_driver_probe(struct platform_device *dev)
 {
 	struct dwc2_hsotg *hsotg;
 	struct resource *res;
 	int retval;

 	hsotg = devm_kzalloc(&dev->dev, sizeof(*hsotg), GFP_KERNEL);
 	if (!hsotg)
 		return -ENOMEM;

 	hsotg->dev = &dev->dev;

 	/*
 	 * Use reasonable defaults so platforms don't have to provide these.
 	 */
 	if (!dev->dev.dma_mask)
 		dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
 	retval = dma_set_coherent_mask(&dev->dev, DMA_BIT_MASK(32));
 	if (retval)
 		return retval;

 	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 	hsotg->regs = devm_ioremap_resource(&dev->dev, res);
 	if (IS_ERR(hsotg->regs))
 		return PTR_ERR(hsotg->regs);

 	dev_dbg(&dev->dev, "mapped PA %08lx to VA %p\n",
 		(unsigned long)res->start, hsotg->regs);

 	retval = dwc2_lowlevel_hw_init(hsotg);
 	if (retval)
 		return retval;

 	spin_lock_init(&hsotg->lock);

 	hsotg->irq = platform_get_irq(dev, 0);
 	if (hsotg->irq < 0) {
 		dev_err(&dev->dev, "missing IRQ resource\n");
 		return hsotg->irq;
 	}

 	dev_dbg(hsotg->dev, "registering common handler for irq%d\n",
 		hsotg->irq);
 	retval = devm_request_irq(hsotg->dev, hsotg->irq,
 				  dwc2_handle_common_intr, IRQF_SHARED,
 				  dev_name(hsotg->dev), hsotg);
 	if (retval)
 		return retval;

 	retval = dwc2_lowlevel_hw_enable(hsotg);
 	if (retval)
 		return retval;

 	retval = dwc2_get_dr_mode(hsotg);
 	if (retval)
 		goto error;

 	/*
 	 * Reset before dwc2_get_hwparams() then it could get power-on real
 	 * reset value form registers.
 	 */
 	dwc2_core_reset_and_force_dr_mode(hsotg);

 	/* Detect config values from hardware */
 	retval = dwc2_get_hwparams(hsotg);
 	if (retval)
 		goto error;

 	dwc2_force_dr_mode(hsotg);

 	retval = dwc2_init_params(hsotg);
 	if (retval)
 		goto error;

 	if (hsotg->dr_mode != USB_DR_MODE_HOST) {
 		retval = dwc2_gadget_init(hsotg, hsotg->irq);
 		if (retval)
 			goto error;
 		hsotg->gadget_enabled = 1;
 	}

 	if (hsotg->dr_mode != USB_DR_MODE_PERIPHERAL) {
 		retval = dwc2_hcd_init(hsotg);
 		if (retval) {
 			if (hsotg->gadget_enabled)
 				dwc2_hsotg_remove(hsotg);
 			goto error;
 		}
 		hsotg->hcd_enabled = 1;
 	}

 	platform_set_drvdata(dev, hsotg);

 	dwc2_debugfs_init(hsotg);

 	/* Gadget code manages lowlevel hw on its own */
 	if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)
 		dwc2_lowlevel_hw_disable(hsotg);

 	return 0;

 error:
 	dwc2_lowlevel_hw_disable(hsotg);
 	return retval;
 }

 static int __maybe_unused dwc2_suspend(struct device *dev)
 {
 	struct dwc2_hsotg *dwc2 = dev_get_drvdata(dev);
 	int ret = 0;

 	if (dwc2_is_device_mode(dwc2))
 		dwc2_hsotg_suspend(dwc2);

 	if (dwc2->ll_hw_enabled)
 		ret = __dwc2_lowlevel_hw_disable(dwc2);

 	return ret;
 }

 static int __maybe_unused dwc2_resume(struct device *dev)
 {
 	struct dwc2_hsotg *dwc2 = dev_get_drvdata(dev);
 	int ret = 0;

 	if (dwc2->ll_hw_enabled) {
 		ret = __dwc2_lowlevel_hw_enable(dwc2);
 		if (ret)
 			return ret;
 	}

 	if (dwc2_is_device_mode(dwc2))
 		ret = dwc2_hsotg_resume(dwc2);

 	return ret;
 }

 static const struct dev_pm_ops dwc2_dev_pm_ops = {
 	SET_SYSTEM_SLEEP_PM_OPS(dwc2_suspend, dwc2_resume)
 };

 static struct platform_driver dwc2_platform_driver = {
 	.driver = {
 		.name = dwc2_driver_name,
 		.of_match_table = dwc2_of_match_table,
 		.pm = &dwc2_dev_pm_ops,
 	},
 	.probe = dwc2_driver_probe,
 	.remove = dwc2_driver_remove,
 	.shutdown = dwc2_driver_shutdown,
 };

 module_platform_driver(dwc2_platform_driver);

 MODULE_DESCRIPTION("DESIGNWARE HS OTG Platform Glue");
 MODULE_AUTHOR("Matthijs Kooijman <matthijs@stdin.nl>");
 MODULE_LICENSE("Dual BSD/GPL");
	// SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
	/*
	* platform.c - DesignWare HS OTG Controller platform driver
	*
	* Copyright (C) Matthijs Kooijman <matthijs@stdin.nl>
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions, and the following disclaimer,
	* without modification.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. The names of the above-listed copyright holders may not be used
	* to endorse or promote products derived from this software without
	* specific prior written permission.
	*
	* ALTERNATIVELY, this software may be distributed under the terms of the
	* GNU General Public License ("GPL") as published by the Free Software
	* Foundation; either version 2 of the License, or (at your option) any
	* later version.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
	* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/slab.h>
	#include <linux/clk.h>
	#include <linux/device.h>
	#include <linux/dma-mapping.h>
	#include <linux/of_device.h>
	#include <linux/mutex.h>
	#include <linux/platform_device.h>
	#include <linux/phy/phy.h>
	#include <linux/platform_data/s3c-hsotg.h>
	#include <linux/reset.h>

	#include <linux/usb/of.h>

	#include "core.h"
	#include "hcd.h"
	#include "debug.h"

	static const char dwc2_driver_name[] = "dwc2";

	/*
	* Check the dr_mode against the module configuration and hardware
	* capabilities.
	*
	* The hardware, module, and dr_mode, can each be set to host, device,
	* or otg. Check that all these values are compatible and adjust the
	* value of dr_mode if possible.
	*
	* actual
	* HW MOD dr_mode dr_mode
	* ------------------------------
	* HST HST any : HST
	* HST DEV any : ---
	* HST OTG any : HST
	*
	* DEV HST any : ---
	* DEV DEV any : DEV
	* DEV OTG any : DEV
	*
	* OTG HST any : HST
	* OTG DEV any : DEV
	* OTG OTG any : dr_mode
	*/
	static int dwc2_get_dr_mode(struct dwc2_hsotg *hsotg)
	{
	enum usb_dr_mode mode;

	hsotg->dr_mode = usb_get_dr_mode(hsotg->dev);
	if (hsotg->dr_mode == USB_DR_MODE_UNKNOWN)
	hsotg->dr_mode = USB_DR_MODE_OTG;

	mode = hsotg->dr_mode;

	if (dwc2_hw_is_device(hsotg)) {
	if (IS_ENABLED(CONFIG_USB_DWC2_HOST)) {
	dev_err(hsotg->dev,
	"Controller does not support host mode.\n");
	return -EINVAL;
	}
	mode = USB_DR_MODE_PERIPHERAL;
	} else if (dwc2_hw_is_host(hsotg)) {
	if (IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL)) {
	dev_err(hsotg->dev,
	"Controller does not support device mode.\n");
	return -EINVAL;
	}
	mode = USB_DR_MODE_HOST;
	} else {
	if (IS_ENABLED(CONFIG_USB_DWC2_HOST))
	mode = USB_DR_MODE_HOST;
	else if (IS_ENABLED(CONFIG_USB_DWC2_PERIPHERAL))
	mode = USB_DR_MODE_PERIPHERAL;
	}

	if (mode != hsotg->dr_mode) {
	dev_warn(hsotg->dev,
	"Configuration mismatch. dr_mode forced to %s\n",
	mode == USB_DR_MODE_HOST ? "host" : "device");

	hsotg->dr_mode = mode;
	}

	return 0;
	}

	static int __dwc2_lowlevel_hw_enable(struct dwc2_hsotg *hsotg)
	{
	struct platform_device *pdev = to_platform_device(hsotg->dev);
	int ret;

	ret = regulator_bulk_enable(ARRAY_SIZE(hsotg->supplies),
	hsotg->supplies);
	if (ret)
	return ret;

	if (hsotg->clk) {
	ret = clk_prepare_enable(hsotg->clk);
	if (ret)
	return ret;
	}

	if (hsotg->uphy) {
	ret = usb_phy_init(hsotg->uphy);
	} else if (hsotg->plat && hsotg->plat->phy_init) {
	ret = hsotg->plat->phy_init(pdev, hsotg->plat->phy_type);
	} else {
	ret = phy_power_on(hsotg->phy);
	if (ret == 0)
	ret = phy_init(hsotg->phy);
	}

	return ret;
	}

	/**
	* dwc2_lowlevel_hw_enable - enable platform lowlevel hw resources
	* @hsotg: The driver state
	*
	* A wrapper for platform code responsible for controlling
	* low-level USB platform resources (phy, clock, regulators)
	*/
	int dwc2_lowlevel_hw_enable(struct dwc2_hsotg *hsotg)
	{
	int ret = __dwc2_lowlevel_hw_enable(hsotg);

	if (ret == 0)
	hsotg->ll_hw_enabled = true;
	return ret;
	}

	static int __dwc2_lowlevel_hw_disable(struct dwc2_hsotg *hsotg)
	{
	struct platform_device *pdev = to_platform_device(hsotg->dev);
	int ret = 0;

	if (hsotg->uphy) {
	usb_phy_shutdown(hsotg->uphy);
	} else if (hsotg->plat && hsotg->plat->phy_exit) {
	ret = hsotg->plat->phy_exit(pdev, hsotg->plat->phy_type);
	} else {
	ret = phy_exit(hsotg->phy);
	if (ret == 0)
	ret = phy_power_off(hsotg->phy);
	}
	if (ret)
	return ret;

	if (hsotg->clk)
	clk_disable_unprepare(hsotg->clk);

	ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
	hsotg->supplies);

	return ret;
	}

	/**
	* dwc2_lowlevel_hw_disable - disable platform lowlevel hw resources
	* @hsotg: The driver state
	*
	* A wrapper for platform code responsible for controlling
	* low-level USB platform resources (phy, clock, regulators)
	*/
	int dwc2_lowlevel_hw_disable(struct dwc2_hsotg *hsotg)
	{
	int ret = __dwc2_lowlevel_hw_disable(hsotg);

	if (ret == 0)
	hsotg->ll_hw_enabled = false;
	return ret;
	}

	static int dwc2_lowlevel_hw_init(struct dwc2_hsotg *hsotg)
	{
	int i, ret;

	hsotg->reset = devm_reset_control_get_optional(hsotg->dev, "dwc2");
	if (IS_ERR(hsotg->reset)) {
	ret = PTR_ERR(hsotg->reset);
	dev_err(hsotg->dev, "error getting reset control %d\n", ret);
	return ret;
	}

	reset_control_deassert(hsotg->reset);

	hsotg->reset_ecc = devm_reset_control_get_optional(hsotg->dev, "dwc2-ecc");
	if (IS_ERR(hsotg->reset_ecc)) {
	ret = PTR_ERR(hsotg->reset_ecc);
	dev_err(hsotg->dev, "error getting reset control for ecc %d\n", ret);
	return ret;
	}

	reset_control_deassert(hsotg->reset_ecc);

	/* Set default UTMI width */
	hsotg->phyif = GUSBCFG_PHYIF16;

	/*
	* Attempt to find a generic PHY, then look for an old style
	* USB PHY and then fall back to pdata
	*/
	hsotg->phy = devm_phy_get(hsotg->dev, "usb2-phy");
	if (IS_ERR(hsotg->phy)) {
	ret = PTR_ERR(hsotg->phy);
	switch (ret) {
	case -ENODEV:
	case -ENOSYS:
	hsotg->phy = NULL;
	break;
	case -EPROBE_DEFER:
	return ret;
	default:
	dev_err(hsotg->dev, "error getting phy %d\n", ret);
	return ret;
	}
	}

	if (!hsotg->phy) {
	hsotg->uphy = devm_usb_get_phy(hsotg->dev, USB_PHY_TYPE_USB2);
	if (IS_ERR(hsotg->uphy)) {
	ret = PTR_ERR(hsotg->uphy);
	switch (ret) {
	case -ENODEV:
	case -ENXIO:
	hsotg->uphy = NULL;
	break;
	case -EPROBE_DEFER:
	return ret;
	default:
	dev_err(hsotg->dev, "error getting usb phy %d\n",
	ret);
	return ret;
	}
	}
	}

	hsotg->plat = dev_get_platdata(hsotg->dev);

	if (hsotg->phy) {
	/*
	* If using the generic PHY framework, check if the PHY bus
	* width is 8-bit and set the phyif appropriately.
	*/
	if (phy_get_bus_width(hsotg->phy) == 8)
	hsotg->phyif = GUSBCFG_PHYIF8;
	}

	/* Clock */
	hsotg->clk = devm_clk_get(hsotg->dev, "otg");
	if (IS_ERR(hsotg->clk)) {
	hsotg->clk = NULL;
	dev_dbg(hsotg->dev, "cannot get otg clock\n");
	}

	/* Regulators */
	for (i = 0; i < ARRAY_SIZE(hsotg->supplies); i++)
	hsotg->supplies[i].supply = dwc2_hsotg_supply_names[i];

	ret = devm_regulator_bulk_get(hsotg->dev, ARRAY_SIZE(hsotg->supplies),
	hsotg->supplies);
	if (ret) {
	dev_err(hsotg->dev, "failed to request supplies: %d\n", ret);
	return ret;
	}
	return 0;
	}

	/**
	* dwc2_driver_remove() - Called when the DWC_otg core is unregistered with the
	* DWC_otg driver
	*
	* @dev: Platform device
	*
	* This routine is called, for example, when the rmmod command is executed. The
	* device may or may not be electrically present. If it is present, the driver
	* stops device processing. Any resources used on behalf of this device are
	* freed.
	*/
	static int dwc2_driver_remove(struct platform_device *dev)
	{
	struct dwc2_hsotg *hsotg = platform_get_drvdata(dev);

	dwc2_debugfs_exit(hsotg);
	if (hsotg->hcd_enabled)
	dwc2_hcd_remove(hsotg);
	if (hsotg->gadget_enabled)
	dwc2_hsotg_remove(hsotg);

	if (hsotg->ll_hw_enabled)
	dwc2_lowlevel_hw_disable(hsotg);

	reset_control_assert(hsotg->reset);
	reset_control_assert(hsotg->reset_ecc);

	return 0;
	}

	/**
	* dwc2_driver_shutdown() - Called on device shutdown
	*
	* @dev: Platform device
	*
	* In specific conditions (involving usb hubs) dwc2 devices can create a
	* lot of interrupts, even to the point of overwhelming devices running
	* at low frequencies. Some devices need to do special clock handling
	* at shutdown-time which may bring the system clock below the threshold
	* of being able to handle the dwc2 interrupts. Disabling dwc2-irqs
	* prevents reboots/poweroffs from getting stuck in such cases.
	*/
	static void dwc2_driver_shutdown(struct platform_device *dev)
	{
	struct dwc2_hsotg *hsotg = platform_get_drvdata(dev);

	disable_irq(hsotg->irq);
	}

	/**
	* dwc2_driver_probe() - Called when the DWC_otg core is bound to the DWC_otg
	* driver
	*
	* @dev: Platform device
	*
	* This routine creates the driver components required to control the device
	* (core, HCD, and PCD) and initializes the device. The driver components are
	* stored in a dwc2_hsotg structure. A reference to the dwc2_hsotg is saved
	* in the device private data. This allows the driver to access the dwc2_hsotg
	* structure on subsequent calls to driver methods for this device.
	*/
	static int dwc2_driver_probe(struct platform_device *dev)
	{
	struct dwc2_hsotg *hsotg;
	struct resource *res;
	int retval;

	hsotg = devm_kzalloc(&dev->dev, sizeof(*hsotg), GFP_KERNEL);
	if (!hsotg)
	return -ENOMEM;

	hsotg->dev = &dev->dev;

	/*
	* Use reasonable defaults so platforms don't have to provide these.
	*/
	if (!dev->dev.dma_mask)
	dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
	retval = dma_set_coherent_mask(&dev->dev, DMA_BIT_MASK(32));
	if (retval)
	return retval;

	res = platform_get_resource(dev, IORESOURCE_MEM, 0);
	hsotg->regs = devm_ioremap_resource(&dev->dev, res);
	if (IS_ERR(hsotg->regs))
	return PTR_ERR(hsotg->regs);

	dev_dbg(&dev->dev, "mapped PA %08lx to VA %p\n",
	(unsigned long)res->start, hsotg->regs);

	retval = dwc2_lowlevel_hw_init(hsotg);
	if (retval)
	return retval;

	spin_lock_init(&hsotg->lock);

	hsotg->irq = platform_get_irq(dev, 0);
	if (hsotg->irq < 0) {
	dev_err(&dev->dev, "missing IRQ resource\n");
	return hsotg->irq;
	}

	dev_dbg(hsotg->dev, "registering common handler for irq%d\n",
	hsotg->irq);
	retval = devm_request_irq(hsotg->dev, hsotg->irq,
	dwc2_handle_common_intr, IRQF_SHARED,
	dev_name(hsotg->dev), hsotg);
	if (retval)
	return retval;

	retval = dwc2_lowlevel_hw_enable(hsotg);
	if (retval)
	return retval;

	retval = dwc2_get_dr_mode(hsotg);
	if (retval)
	goto error;

	/*
	* Reset before dwc2_get_hwparams() then it could get power-on real
	* reset value form registers.
	*/
	dwc2_core_reset_and_force_dr_mode(hsotg);

	/* Detect config values from hardware */
	retval = dwc2_get_hwparams(hsotg);
	if (retval)
	goto error;

	dwc2_force_dr_mode(hsotg);

	retval = dwc2_init_params(hsotg);
	if (retval)
	goto error;

	if (hsotg->dr_mode != USB_DR_MODE_HOST) {
	retval = dwc2_gadget_init(hsotg, hsotg->irq);
	if (retval)
	goto error;
	hsotg->gadget_enabled = 1;
	}

	if (hsotg->dr_mode != USB_DR_MODE_PERIPHERAL) {
	retval = dwc2_hcd_init(hsotg);
	if (retval) {
	if (hsotg->gadget_enabled)
	dwc2_hsotg_remove(hsotg);
	goto error;
	}
	hsotg->hcd_enabled = 1;
	}

	platform_set_drvdata(dev, hsotg);

	dwc2_debugfs_init(hsotg);

	/* Gadget code manages lowlevel hw on its own */
	if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)
	dwc2_lowlevel_hw_disable(hsotg);

	return 0;

	error:
	dwc2_lowlevel_hw_disable(hsotg);
	return retval;
	}

	static int __maybe_unused dwc2_suspend(struct device *dev)
	{
	struct dwc2_hsotg *dwc2 = dev_get_drvdata(dev);
	int ret = 0;

	if (dwc2_is_device_mode(dwc2))
	dwc2_hsotg_suspend(dwc2);

	if (dwc2->ll_hw_enabled)
	ret = __dwc2_lowlevel_hw_disable(dwc2);

	return ret;
	}

	static int __maybe_unused dwc2_resume(struct device *dev)
	{
	struct dwc2_hsotg *dwc2 = dev_get_drvdata(dev);
	int ret = 0;

	if (dwc2->ll_hw_enabled) {
	ret = __dwc2_lowlevel_hw_enable(dwc2);
	if (ret)
	return ret;
	}

	if (dwc2_is_device_mode(dwc2))
	ret = dwc2_hsotg_resume(dwc2);

	return ret;
	}

	static const struct dev_pm_ops dwc2_dev_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(dwc2_suspend, dwc2_resume)
	};

	static struct platform_driver dwc2_platform_driver = {
	.driver = {
	.name = dwc2_driver_name,
	.of_match_table = dwc2_of_match_table,
	.pm = &dwc2_dev_pm_ops,
	},
	.probe = dwc2_driver_probe,
	.remove = dwc2_driver_remove,
	.shutdown = dwc2_driver_shutdown,
	};

	module_platform_driver(dwc2_platform_driver);

	MODULE_DESCRIPTION("DESIGNWARE HS OTG Platform Glue");
	MODULE_AUTHOR("Matthijs Kooijman <matthijs@stdin.nl>");
	MODULE_LICENSE("Dual BSD/GPL");