drivers/usb/host/ehci-ath.c - kernel/windcharger - Git at Google

 /*
  *  Copyright (c) 2013 Qualcomm Atheros, Inc.
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

 /*
  * EHCI Host Controller Driver
  *
  * Atheros USB Controller
  *
  */

 #include "../gadget/ath_defs.h"

 #ifdef CONFIG_USB_ATH_OTG_MODULE
 #warning "OTG enabled in host"
 #define CONFIG_USB_ATH_OTG
 #endif

 static inline void ath_usb_host_reset(u32 ath_host_to_reset)
 {
 	ath_usb_reg_rmw_set(ath_host_to_reset,
 			ATH_RESET_USBSUS_OVRIDE |
 			ATH_RESET_USB_PHY_ANALOG);
 	mdelay(10);

 	ath_usb_reg_wr(ath_host_to_reset,
 			((ath_usb_reg_rd(ath_host_to_reset) & ~(ATH_USB_RESET_USB_HOST))
 			 | ATH_RESET_USBSUS_OVRIDE));
 	mdelay(10);

 	ath_usb_reg_wr(ath_host_to_reset,
 			((ath_usb_reg_rd(ath_host_to_reset) &
 			  ~(ATH_USB_RESET_USB_PHY | ATH_RESET_USB_PHY_ANALOG)) |
 			 ATH_RESET_USBSUS_OVRIDE));
 	mdelay(10);

 	return;
 }


 #ifdef	CONFIG_USB_ATH_OTG
 static int ath_usb_start_hc(struct ehci_hcd *ehci, struct device *dev)
 {
 	printk("%s: %p, %p\n", __func__, ehci_to_hcd(ehci),
 	       &ehci_to_hcd(ehci)->self);
 	if (ehci->transceiver) {
 		int status = otg_set_host(ehci->transceiver,
 					  &ehci_to_hcd(ehci)->self);
 		dev_info(dev, "init %s transceiver, status %d\n",
 			 ehci->transceiver->label, status);
 		if (status) {
 			if (ehci->transceiver)
 				put_device(ehci->transceiver->dev);
 		}
 		return status;
 	} else {
 		dev_err(dev, "can't find transceiver\n");
 		return -ENODEV;
 	}
 }
 #endif

 #ifdef	CONFIG_USB_OTG
 void start_hnp(struct ehci_hcd *ehci)
 {
 	unsigned long flags;
 	otg_start_hnp(ehci->transceiver);

 	local_irq_save(flags);
 	ehci->transceiver->state = OTG_STATE_A_SUSPEND;
 	local_irq_restore(flags);
 }
 #endif

 static int ath_usb_ehci_init(struct usb_hcd *hcd)
 {
 	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 	int ret;

 	ath_usb_debug_fn("__enter %s\n", __FUNCTION__);

 	/*
 	 * EHCI Capability Register offset at 0x100      - Info from ChipIdea
  	 * EHCI Operational Register offset at 0x140     - Info from ChipIdea
 	 */
 	ehci->caps = hcd->regs + 0x100;	/* Device/Host Capa Reg */
 	ehci->regs = hcd->regs + 0x100 +	/* Device/Host Oper Reg */
 			HC_LENGTH(readl(&ehci->caps->hc_capbase));

 	/*Reading HC Structural Parameters */
 	ehci->hcs_params = readl(&ehci->caps->hcs_params);
 	ath_usb_debug_dev("HCS Params %x\n", ehci->hcs_params);
 	ath_usb_debug_dev("HCC Params %x\n", readl(&ehci->caps->hcc_params));

 	ret = ehci_init(hcd);
 	if (ret) {
 		return ret;
 	}
 	/*
 	 * Informs USB Subsystem abt embedded TT.
 	 * Sets to host mode
 	 */
 	hcd->has_tt = 1;
 	ehci->sbrn = 0x20;
 	ehci_reset(ehci);

 	return ret;
 }

 static struct hc_driver ath_usb_ehci_driver = {
 	.description = hcd_name,
 	.product_desc = "ATH EHCI",
 	.hcd_priv_size = sizeof(struct ehci_hcd),

 	/*
 	 * generic hardware linkage
 	 */
 #ifndef CONFIG_USB_ATH_OTG
 	.irq = ehci_irq,
 #endif
 	.flags = HCD_MEMORY | HCD_USB2,
 	/*
 	 * basic lifecycle operations
 	 */
 	.reset = ath_usb_ehci_init,
 	.start = ehci_run,
 #ifdef CONFIG_PM
 	.suspend = ehci_bus_suspend,
 	.resume = ehci_bus_resume,
 #endif
 	.stop = ehci_stop,
 	/*
 	 * managing i/o requests and associated device resources
 	 */
 	.urb_enqueue = ehci_urb_enqueue,
 	.urb_dequeue = ehci_urb_dequeue,
 	.endpoint_disable = ehci_endpoint_disable,
 	/*
 	 * scheduling support
 	 */
 	.get_frame_number = ehci_get_frame,
 	/*
 	 * root hub support
 	 */
 	.hub_status_data = ehci_hub_status_data,
 	.hub_control = ehci_hub_control,
 	.bus_suspend = ehci_bus_suspend,
 	.bus_resume = ehci_bus_resume,

 	.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
 };

 #ifndef CONFIG_USB_ATH_OTG
 int ath_usb_ehci_probe(struct hc_driver *driver,
 			  struct usb_hcd **hcd_out,
 			  struct platform_device *pdev)
 {
 	struct usb_hcd *hcd;
 	int ret;
 	struct ehci_hcd *ehci;

 	ath_usb_debug_dev("No of Resources %d \n", pdev->num_resources);

 	/* Verify the Host Mode of the Driver */
 	if (pdev->resource[1].flags != IORESOURCE_IRQ) {
 		printk("resource[1] is not IORESOURCE_IRQ");
 		ret = -ENOMEM;
 	}

 	hcd = usb_create_hcd(driver, &pdev->dev, pdev->dev.bus->name);
 	if (!hcd) {
 		ret = -ENOMEM;
 		goto err;
 	}
 	hcd->rsrc_start = pdev->resource[0].start;
 	hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;

 	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
 				driver->description)) {
 		dev_dbg(&pdev->dev, "controller already in use\n");
 		ret = -EBUSY;
 		goto err1;
 	}

 	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
 	if (hcd->regs == NULL) {
 		dev_dbg(&pdev->dev, "error mapping memory \n");
 		ret = -EFAULT;
 		goto err2;
 	}

 	/*
 	 * EHCI Capability Register offset at 0x100      - Info from ChipIdea
 	 * EHCI Operational Register offset at 0x140     - Info from ChipIdea
 	 */
 	ehci = hcd_to_ehci(hcd);
 	ehci->caps = hcd->regs + 0x100;	/* Device/Host Capa Reg */
 	ehci->regs = hcd->regs + 0x140;	/* Device/Host Oper Reg */

 	ath_usb_debug_dev("hcd->regs %p \n", hcd->regs);
 	ath_usb_debug_dev("Host Capability Reg %p \n", ehci->caps);
 	ath_usb_debug_dev("Host Operational Reg %p \n", ehci->regs);

 	/* Added 5_29_07 */
 #ifdef CONFIG_MACH_AR933x
 	ath_usb_reg_rmw_set(ATH_USB_RESET, ATH_RESET_USBSUS_OVRIDE);
 	mdelay(10);

 	ath_usb_reg_wr(ATH_USB_RESET,
 		      ((ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_USB_RESET_USB_HOST))
 		       | ATH_RESET_USBSUS_OVRIDE));
 	mdelay(10);

 	ath_usb_reg_wr(ATH_USB_RESET,
 		      ((ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_USB_RESET_USB_PHY)) |
 		       ATH_RESET_USBSUS_OVRIDE));
 	mdelay(10);
 #elif defined(CONFIG_MACH_AR934x)
 	if (is_ar934x_13_or_later()) {
 		ath_reg_rmw_clear(PHY_CTRL1_ADDRESS, (PHY_CTRL1_USE_PLL_LOCKDETECT_MASK |
 					PHY_CTRL1_RX_LOWR_PDET_MASK));
 	}
 	/* USB Soft Reset Sequence - Power Down the USB PHY PLL */
 	ath_usb_reg_rmw_set(ATH_USB_RESET,
 				ATH_RESET_USBSUS_OVRIDE | ATH_RESET_USB_PHY_ANALOG |
 				ATH_RESET_USB_PHY_PLL_PWD_EXT);
 	mdelay(10);

 	/* USB Soft Reset Sequence - Power Up the USB PHY PLL */
 	ath_usb_reg_wr(ATH_USB_RESET,(ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_RESET_USB_PHY_PLL_PWD_EXT)));
 	mdelay(10);

 	ath_usb_reg_wr(ATH_USB_RESET,
 			((ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_USB_RESET_USB_HOST))
 				| ATH_RESET_USBSUS_OVRIDE));
 	mdelay(10);

 	ath_usb_reg_wr(ATH_USB_RESET,
 			((ath_usb_reg_rd(ATH_USB_RESET) &
 			~(ATH_USB_RESET_USB_PHY | ATH_RESET_USB_PHY_ANALOG)) |
 			ATH_RESET_USBSUS_OVRIDE));
 	mdelay(10);
 #elif defined(CONFIG_MACH_QCA955x) || defined(CONFIG_MACH_QCA953x) || defined(CONFIG_MACH_QCA956x)
 	//
 	// This WAR is not needed for Scorpion (now). Will uncomment
 	// this if necessary
 	//
 	//if(pdev->id == ATH_USB_HOST0) {
 	//	ath_reg_rmw_clear(USB_PHY_CTRL1_ADDRESS, (USB_PHY_CTRL1_USE_PLL_LOCKDETECT_MASK |
 	//				USB_PHY_CTRL1_RX_LOWR_PDET_MASK));
 	//	ath_usb_host_reset(ATH_USB_RESET);
 	//} else if(pdev->id == ATH_USB_HOST1) {
 	//	ath_reg_rmw_clear(USB2_PHY_CTRL1_ADDRESS, (USB2_PHY_CTRL1_USE_PLL_LOCKDETECT_MASK |
 	//				USB2_PHY_CTRL1_RX_LOWR_PDET_MASK));
 	//	ath_usb_host_reset(ATH_USB2_RESET);
 	//} else {
 	//	dev_dbg(&pdev->id, "error in host selection\n");
 	//}
 #else
 	#error :Host selection need to be defined.
 #endif

 	/*
 	 * Reset host controller
 	 */

 	printk("Port Status %x \n", readl(&ehci->regs->port_status[0]));
 	ret = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);

 	if (ret != 0) {
 		goto err3;
 	}
 	return ret;

 err3:
 	iounmap(hcd->regs);
 err2:
 	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err1:
 	usb_put_hcd(hcd);
 err:
 	dev_err(&pdev->dev, "init %s fail, %d \n", pdev->dev.bus->name, ret);
 	return ret;
 }

 static int ath_usb_ehci_drv_probe(struct platform_device *pdev)
 {
 	struct usb_hcd *hcd = platform_get_drvdata(pdev);

 	if (usb_disabled()) {
 		ath_usb_error("USB_DISABLED \n");
 		return -ENODEV;
 	}
 	return ath_usb_ehci_probe(&ath_usb_ehci_driver, &hcd, pdev);
 }

 static int ath_usb_ehci_drv_remove(struct platform_device *pdev)
 {
 	struct usb_hcd *hcd = platform_get_drvdata(pdev);

 	usb_remove_hcd(hcd);
 	iounmap(hcd->regs);
 	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 	usb_put_hcd(hcd);
 	return 0;
 }

 static struct platform_driver ath_usb_ehci_hcd_driver = {
 	.probe = ath_usb_ehci_drv_probe,
 	.remove = ath_usb_ehci_drv_remove,
 	.driver = {
 		   .name = "ath-ehci",
 	},
 };

 #if defined(CONFIG_MACH_QCA955x)||defined(CONFIG_MACH_QCA956x)
 static struct platform_driver ath_usb_ehci_hcd_driver_1 = {
 	.probe = ath_usb_ehci_drv_probe,
 	.remove = ath_usb_ehci_drv_remove,
 	.driver = {
 		   .name = "ath-ehci1",
 		   .mod_name = "ath-ehci-host2",
 	},
 };
 #endif /* CONFIG_MACH_QCA955x CONFIG_MACH_QCA956x*/
 #else

 int usb_otg_ath_usb_probe(struct hc_driver *driver)
 {
 	struct ath_usb_otg *ath_usb_otg;
 	struct usb_hcd *hcd;
 	struct ehci_hcd *ehci;
 	struct device *dev;
 	int ret;

 	printk(" %s \n", __func__);
 	ath_usb_otg = ath_usb_get_otg();
 	if (ath_usb_otg == NULL) {
 		return -EINVAL;
 	}
 	dev = ath_usb_otg->dev;

 	hcd = usb_create_hcd(driver, dev, dev->bus->name);
 	if (!hcd) {
 		ret = -ENOMEM;
 		goto err;
 	}
 	hcd->rsrc_start = 0;
 	hcd->rsrc_len = 0;

 	hcd->regs = ath_usb_otg->reg_base;
 	if (hcd->regs == NULL) {
 		dev_dbg(dev, "error mapping memory \n");
 		ret = -EFAULT;
 		goto err1;
 	}

 	/*
 	 * EHCI Capability Register offset at 0x100      - Info from ChipIdea
 	 * EHCI Operational Register offset at 0x140     - Info from ChipIdea
 	 */
 	ehci = hcd_to_ehci(hcd);
 	ehci->caps = hcd->regs + 0x100;	/* Device/Host Capa Reg */
 	ehci->regs = hcd->regs + 0x140;	/* Device/Host Oper Reg */

 	ath_usb_otg->ehci = ehci;	/* Temp To Test HNP */

 	printk("hcd->regs %p, %p \n", hcd, hcd->regs);
 	printk("Host Capability Reg %p \n", ehci->caps);
 	printk("Host Operational Reg %p \n", ehci->regs);

 	ehci->transceiver = &ath_usb_otg->otg;

 	printk("usb_add_hcd\n");
 	ret = usb_add_hcd(hcd, 0, 0);
 	if (ret != 0) {
 		goto err1;
 	}
 	dev_set_drvdata(dev, hcd);

 	ehci_hc_ath_usb_driver.irq = ehci_irq;
 	ret = ath_usb_start_hc(ehci, dev);
 	if (ret != 0) {
 		goto err1;
 	}

 	return ret;

       err1:
 	usb_put_hcd(hcd);
       err:
 	dev_err(dev, "init %s fail, %d \n", dev->bus_id, ret);
 	return ret;
 }
 #endif
	/*
	* Copyright (c) 2013 Qualcomm Atheros, Inc.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	/*
	* EHCI Host Controller Driver
	*
	* Atheros USB Controller
	*
	*/

	#include "../gadget/ath_defs.h"

	#ifdef CONFIG_USB_ATH_OTG_MODULE
	#warning "OTG enabled in host"
	#define CONFIG_USB_ATH_OTG
	#endif

	static inline void ath_usb_host_reset(u32 ath_host_to_reset)
	{
	ath_usb_reg_rmw_set(ath_host_to_reset,
	ATH_RESET_USBSUS_OVRIDE \|
	ATH_RESET_USB_PHY_ANALOG);
	mdelay(10);

	ath_usb_reg_wr(ath_host_to_reset,
	((ath_usb_reg_rd(ath_host_to_reset) & ~(ATH_USB_RESET_USB_HOST))
	\| ATH_RESET_USBSUS_OVRIDE));
	mdelay(10);

	ath_usb_reg_wr(ath_host_to_reset,
	((ath_usb_reg_rd(ath_host_to_reset) &
	~(ATH_USB_RESET_USB_PHY \| ATH_RESET_USB_PHY_ANALOG)) \|
	ATH_RESET_USBSUS_OVRIDE));
	mdelay(10);

	return;
	}



	#ifdef CONFIG_USB_ATH_OTG
	static int ath_usb_start_hc(struct ehci_hcd ehci, struct device dev)
	{
	printk("%s: %p, %p\n", __func__, ehci_to_hcd(ehci),
	&ehci_to_hcd(ehci)->self);
	if (ehci->transceiver) {
	int status = otg_set_host(ehci->transceiver,
	&ehci_to_hcd(ehci)->self);
	dev_info(dev, "init %s transceiver, status %d\n",
	ehci->transceiver->label, status);
	if (status) {
	if (ehci->transceiver)
	put_device(ehci->transceiver->dev);
	}
	return status;
	} else {
	dev_err(dev, "can't find transceiver\n");
	return -ENODEV;
	}
	}
	#endif

	#ifdef CONFIG_USB_OTG
	void start_hnp(struct ehci_hcd *ehci)
	{
	unsigned long flags;
	otg_start_hnp(ehci->transceiver);

	local_irq_save(flags);
	ehci->transceiver->state = OTG_STATE_A_SUSPEND;
	local_irq_restore(flags);
	}
	#endif

	static int ath_usb_ehci_init(struct usb_hcd *hcd)
	{
	struct ehci_hcd *ehci = hcd_to_ehci(hcd);
	int ret;

	ath_usb_debug_fn("__enter %s\n", __FUNCTION__);

	/*
	* EHCI Capability Register offset at 0x100 - Info from ChipIdea
	* EHCI Operational Register offset at 0x140 - Info from ChipIdea
	*/
	ehci->caps = hcd->regs + 0x100; /* Device/Host Capa Reg */
	ehci->regs = hcd->regs + 0x100 + /* Device/Host Oper Reg */
	HC_LENGTH(readl(&ehci->caps->hc_capbase));

	/Reading HC Structural Parameters /
	ehci->hcs_params = readl(&ehci->caps->hcs_params);
	ath_usb_debug_dev("HCS Params %x\n", ehci->hcs_params);
	ath_usb_debug_dev("HCC Params %x\n", readl(&ehci->caps->hcc_params));

	ret = ehci_init(hcd);
	if (ret) {
	return ret;
	}
	/*
	* Informs USB Subsystem abt embedded TT.
	* Sets to host mode
	*/
	hcd->has_tt = 1;
	ehci->sbrn = 0x20;
	ehci_reset(ehci);

	return ret;
	}

	static struct hc_driver ath_usb_ehci_driver = {
	.description = hcd_name,
	.product_desc = "ATH EHCI",
	.hcd_priv_size = sizeof(struct ehci_hcd),

	/*
	* generic hardware linkage
	*/
	#ifndef CONFIG_USB_ATH_OTG
	.irq = ehci_irq,
	#endif
	.flags = HCD_MEMORY \| HCD_USB2,
	/*
	* basic lifecycle operations
	*/
	.reset = ath_usb_ehci_init,
	.start = ehci_run,
	#ifdef CONFIG_PM
	.suspend = ehci_bus_suspend,
	.resume = ehci_bus_resume,
	#endif
	.stop = ehci_stop,
	/*
	* managing i/o requests and associated device resources
	*/
	.urb_enqueue = ehci_urb_enqueue,
	.urb_dequeue = ehci_urb_dequeue,
	.endpoint_disable = ehci_endpoint_disable,
	/*
	* scheduling support
	*/
	.get_frame_number = ehci_get_frame,
	/*
	* root hub support
	*/
	.hub_status_data = ehci_hub_status_data,
	.hub_control = ehci_hub_control,
	.bus_suspend = ehci_bus_suspend,
	.bus_resume = ehci_bus_resume,

	.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
	};

	#ifndef CONFIG_USB_ATH_OTG
	int ath_usb_ehci_probe(struct hc_driver *driver,
	struct usb_hcd **hcd_out,
	struct platform_device *pdev)
	{
	struct usb_hcd *hcd;
	int ret;
	struct ehci_hcd *ehci;

	ath_usb_debug_dev("No of Resources %d \n", pdev->num_resources);

	/* Verify the Host Mode of the Driver */
	if (pdev->resource[1].flags != IORESOURCE_IRQ) {
	printk("resource[1] is not IORESOURCE_IRQ");
	ret = -ENOMEM;
	}

	hcd = usb_create_hcd(driver, &pdev->dev, pdev->dev.bus->name);
	if (!hcd) {
	ret = -ENOMEM;
	goto err;
	}
	hcd->rsrc_start = pdev->resource[0].start;
	hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;

	if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
	driver->description)) {
	dev_dbg(&pdev->dev, "controller already in use\n");
	ret = -EBUSY;
	goto err1;
	}

	hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
	if (hcd->regs == NULL) {
	dev_dbg(&pdev->dev, "error mapping memory \n");
	ret = -EFAULT;
	goto err2;
	}

	/*
	* EHCI Capability Register offset at 0x100 - Info from ChipIdea
	* EHCI Operational Register offset at 0x140 - Info from ChipIdea
	*/
	ehci = hcd_to_ehci(hcd);
	ehci->caps = hcd->regs + 0x100; /* Device/Host Capa Reg */
	ehci->regs = hcd->regs + 0x140; /* Device/Host Oper Reg */

	ath_usb_debug_dev("hcd->regs %p \n", hcd->regs);
	ath_usb_debug_dev("Host Capability Reg %p \n", ehci->caps);
	ath_usb_debug_dev("Host Operational Reg %p \n", ehci->regs);

	/* Added 5_29_07 */
	#ifdef CONFIG_MACH_AR933x
	ath_usb_reg_rmw_set(ATH_USB_RESET, ATH_RESET_USBSUS_OVRIDE);
	mdelay(10);

	ath_usb_reg_wr(ATH_USB_RESET,
	((ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_USB_RESET_USB_HOST))
	\| ATH_RESET_USBSUS_OVRIDE));
	mdelay(10);

	ath_usb_reg_wr(ATH_USB_RESET,
	((ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_USB_RESET_USB_PHY)) \|
	ATH_RESET_USBSUS_OVRIDE));
	mdelay(10);
	#elif defined(CONFIG_MACH_AR934x)
	if (is_ar934x_13_or_later()) {
	ath_reg_rmw_clear(PHY_CTRL1_ADDRESS, (PHY_CTRL1_USE_PLL_LOCKDETECT_MASK \|
	PHY_CTRL1_RX_LOWR_PDET_MASK));
	}
	/* USB Soft Reset Sequence - Power Down the USB PHY PLL */
	ath_usb_reg_rmw_set(ATH_USB_RESET,
	ATH_RESET_USBSUS_OVRIDE \| ATH_RESET_USB_PHY_ANALOG \|
	ATH_RESET_USB_PHY_PLL_PWD_EXT);
	mdelay(10);

	/* USB Soft Reset Sequence - Power Up the USB PHY PLL */
	ath_usb_reg_wr(ATH_USB_RESET,(ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_RESET_USB_PHY_PLL_PWD_EXT)));
	mdelay(10);

	ath_usb_reg_wr(ATH_USB_RESET,
	((ath_usb_reg_rd(ATH_USB_RESET) & ~(ATH_USB_RESET_USB_HOST))
	\| ATH_RESET_USBSUS_OVRIDE));
	mdelay(10);

	ath_usb_reg_wr(ATH_USB_RESET,
	((ath_usb_reg_rd(ATH_USB_RESET) &
	~(ATH_USB_RESET_USB_PHY \| ATH_RESET_USB_PHY_ANALOG)) \|
	ATH_RESET_USBSUS_OVRIDE));
	mdelay(10);
	#elif defined(CONFIG_MACH_QCA955x) \|\| defined(CONFIG_MACH_QCA953x) \|\| defined(CONFIG_MACH_QCA956x)
	//
	// This WAR is not needed for Scorpion (now). Will uncomment
	// this if necessary
	//
	//if(pdev->id == ATH_USB_HOST0) {
	// ath_reg_rmw_clear(USB_PHY_CTRL1_ADDRESS, (USB_PHY_CTRL1_USE_PLL_LOCKDETECT_MASK \|
	// USB_PHY_CTRL1_RX_LOWR_PDET_MASK));
	// ath_usb_host_reset(ATH_USB_RESET);
	//} else if(pdev->id == ATH_USB_HOST1) {
	// ath_reg_rmw_clear(USB2_PHY_CTRL1_ADDRESS, (USB2_PHY_CTRL1_USE_PLL_LOCKDETECT_MASK \|
	// USB2_PHY_CTRL1_RX_LOWR_PDET_MASK));
	// ath_usb_host_reset(ATH_USB2_RESET);
	//} else {
	// dev_dbg(&pdev->id, "error in host selection\n");
	//}
	#else
	#error :Host selection need to be defined.
	#endif

	/*
	* Reset host controller
	*/

	printk("Port Status %x \n", readl(&ehci->regs->port_status[0]));
	ret = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);

	if (ret != 0) {
	goto err3;
	}
	return ret;

	err3:
	iounmap(hcd->regs);
	err2:
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	err1:
	usb_put_hcd(hcd);
	err:
	dev_err(&pdev->dev, "init %s fail, %d \n", pdev->dev.bus->name, ret);
	return ret;
	}

	static int ath_usb_ehci_drv_probe(struct platform_device *pdev)
	{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);

	if (usb_disabled()) {
	ath_usb_error("USB_DISABLED \n");
	return -ENODEV;
	}
	return ath_usb_ehci_probe(&ath_usb_ehci_driver, &hcd, pdev);
	}

	static int ath_usb_ehci_drv_remove(struct platform_device *pdev)
	{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);

	usb_remove_hcd(hcd);
	iounmap(hcd->regs);
	release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
	usb_put_hcd(hcd);
	return 0;
	}

	static struct platform_driver ath_usb_ehci_hcd_driver = {
	.probe = ath_usb_ehci_drv_probe,
	.remove = ath_usb_ehci_drv_remove,
	.driver = {
	.name = "ath-ehci",
	},
	};

	#if defined(CONFIG_MACH_QCA955x)\|\|defined(CONFIG_MACH_QCA956x)
	static struct platform_driver ath_usb_ehci_hcd_driver_1 = {
	.probe = ath_usb_ehci_drv_probe,
	.remove = ath_usb_ehci_drv_remove,
	.driver = {
	.name = "ath-ehci1",
	.mod_name = "ath-ehci-host2",
	},
	};
	#endif /* CONFIG_MACH_QCA955x CONFIG_MACH_QCA956x*/
	#else

	int usb_otg_ath_usb_probe(struct hc_driver *driver)
	{
	struct ath_usb_otg *ath_usb_otg;
	struct usb_hcd *hcd;
	struct ehci_hcd *ehci;
	struct device *dev;
	int ret;

	printk(" %s \n", __func__);
	ath_usb_otg = ath_usb_get_otg();
	if (ath_usb_otg == NULL) {
	return -EINVAL;
	}
	dev = ath_usb_otg->dev;

	hcd = usb_create_hcd(driver, dev, dev->bus->name);
	if (!hcd) {
	ret = -ENOMEM;
	goto err;
	}
	hcd->rsrc_start = 0;
	hcd->rsrc_len = 0;

	hcd->regs = ath_usb_otg->reg_base;
	if (hcd->regs == NULL) {
	dev_dbg(dev, "error mapping memory \n");
	ret = -EFAULT;
	goto err1;
	}

	/*
	* EHCI Capability Register offset at 0x100 - Info from ChipIdea
	* EHCI Operational Register offset at 0x140 - Info from ChipIdea
	*/
	ehci = hcd_to_ehci(hcd);
	ehci->caps = hcd->regs + 0x100; /* Device/Host Capa Reg */
	ehci->regs = hcd->regs + 0x140; /* Device/Host Oper Reg */

	ath_usb_otg->ehci = ehci; /* Temp To Test HNP */

	printk("hcd->regs %p, %p \n", hcd, hcd->regs);
	printk("Host Capability Reg %p \n", ehci->caps);
	printk("Host Operational Reg %p \n", ehci->regs);

	ehci->transceiver = &ath_usb_otg->otg;

	printk("usb_add_hcd\n");
	ret = usb_add_hcd(hcd, 0, 0);
	if (ret != 0) {
	goto err1;
	}
	dev_set_drvdata(dev, hcd);

	ehci_hc_ath_usb_driver.irq = ehci_irq;
	ret = ath_usb_start_hc(ehci, dev);
	if (ret != 0) {
	goto err1;
	}

	return ret;

	err1:
	usb_put_hcd(hcd);
	err:
	dev_err(dev, "init %s fail, %d \n", dev->bus_id, ret);
	return ret;
	}
	#endif