ehci-msm.c revision e299bd93e4fb8e3fa426d30e0a0796b99052a572
1/* ehci-msm.c - HSUSB Host Controller Driver Implementation 2 * 3 * Copyright (c) 2008-2011, Code Aurora Forum. All rights reserved. 4 * 5 * Partly derived from ehci-fsl.c and ehci-hcd.c 6 * Copyright (c) 2000-2004 by David Brownell 7 * Copyright (c) 2005 MontaVista Software 8 * 9 * All source code in this file is licensed under the following license except 10 * where indicated. 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of the GNU General Public License version 2 as published 14 * by the Free Software Foundation. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 19 * 20 * See the GNU General Public License for more details. 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, you can find it at http://www.fsf.org 23 */ 24 25#include <linux/platform_device.h> 26#include <linux/clk.h> 27#include <linux/err.h> 28#include <linux/pm_runtime.h> 29 30#include <linux/usb/otg.h> 31#include <linux/usb/msm_hsusb_hw.h> 32 33#define MSM_USB_BASE (hcd->regs) 34 35static struct usb_phy *phy; 36 37static int ehci_msm_reset(struct usb_hcd *hcd) 38{ 39 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 40 int retval; 41 42 ehci->caps = USB_CAPLENGTH; 43 hcd->has_tt = 1; 44 45 retval = ehci_setup(hcd); 46 if (retval) 47 return retval; 48 49 /* bursts of unspecified length. */ 50 writel(0, USB_AHBBURST); 51 /* Use the AHB transactor */ 52 writel(0, USB_AHBMODE); 53 /* Disable streaming mode and select host mode */ 54 writel(0x13, USB_USBMODE); 55 56 return 0; 57} 58 59static struct hc_driver msm_hc_driver = { 60 .description = hcd_name, 61 .product_desc = "Qualcomm On-Chip EHCI Host Controller", 62 .hcd_priv_size = sizeof(struct ehci_hcd), 63 64 /* 65 * generic hardware linkage 66 */ 67 .irq = ehci_irq, 68 .flags = HCD_USB2 | HCD_MEMORY, 69 70 .reset = ehci_msm_reset, 71 .start = ehci_run, 72 73 .stop = ehci_stop, 74 .shutdown = ehci_shutdown, 75 76 /* 77 * managing i/o requests and associated device resources 78 */ 79 .urb_enqueue = ehci_urb_enqueue, 80 .urb_dequeue = ehci_urb_dequeue, 81 .endpoint_disable = ehci_endpoint_disable, 82 .endpoint_reset = ehci_endpoint_reset, 83 .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, 84 85 /* 86 * scheduling support 87 */ 88 .get_frame_number = ehci_get_frame, 89 90 /* 91 * root hub support 92 */ 93 .hub_status_data = ehci_hub_status_data, 94 .hub_control = ehci_hub_control, 95 .relinquish_port = ehci_relinquish_port, 96 .port_handed_over = ehci_port_handed_over, 97 98 /* 99 * PM support 100 */ 101 .bus_suspend = ehci_bus_suspend, 102 .bus_resume = ehci_bus_resume, 103}; 104 105static int ehci_msm_probe(struct platform_device *pdev) 106{ 107 struct usb_hcd *hcd; 108 struct resource *res; 109 int ret; 110 111 dev_dbg(&pdev->dev, "ehci_msm proble\n"); 112 113 hcd = usb_create_hcd(&msm_hc_driver, &pdev->dev, dev_name(&pdev->dev)); 114 if (!hcd) { 115 dev_err(&pdev->dev, "Unable to create HCD\n"); 116 return -ENOMEM; 117 } 118 119 hcd->irq = platform_get_irq(pdev, 0); 120 if (hcd->irq < 0) { 121 dev_err(&pdev->dev, "Unable to get IRQ resource\n"); 122 ret = hcd->irq; 123 goto put_hcd; 124 } 125 126 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 127 if (!res) { 128 dev_err(&pdev->dev, "Unable to get memory resource\n"); 129 ret = -ENODEV; 130 goto put_hcd; 131 } 132 133 hcd->rsrc_start = res->start; 134 hcd->rsrc_len = resource_size(res); 135 hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len); 136 if (!hcd->regs) { 137 dev_err(&pdev->dev, "ioremap failed\n"); 138 ret = -ENOMEM; 139 goto put_hcd; 140 } 141 142 /* 143 * OTG driver takes care of PHY initialization, clock management, 144 * powering up VBUS, mapping of registers address space and power 145 * management. 146 */ 147 phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2); 148 if (IS_ERR(phy)) { 149 dev_err(&pdev->dev, "unable to find transceiver\n"); 150 ret = -ENODEV; 151 goto put_hcd; 152 } 153 154 ret = otg_set_host(phy->otg, &hcd->self); 155 if (ret < 0) { 156 dev_err(&pdev->dev, "unable to register with transceiver\n"); 157 goto put_hcd; 158 } 159 160 device_init_wakeup(&pdev->dev, 1); 161 /* 162 * OTG device parent of HCD takes care of putting 163 * hardware into low power mode. 164 */ 165 pm_runtime_no_callbacks(&pdev->dev); 166 pm_runtime_enable(&pdev->dev); 167 168 return 0; 169 170put_hcd: 171 usb_put_hcd(hcd); 172 173 return ret; 174} 175 176static int ehci_msm_remove(struct platform_device *pdev) 177{ 178 struct usb_hcd *hcd = platform_get_drvdata(pdev); 179 180 device_init_wakeup(&pdev->dev, 0); 181 pm_runtime_disable(&pdev->dev); 182 pm_runtime_set_suspended(&pdev->dev); 183 184 otg_set_host(phy->otg, NULL); 185 186 usb_put_hcd(hcd); 187 188 return 0; 189} 190 191#ifdef CONFIG_PM 192static int ehci_msm_pm_suspend(struct device *dev) 193{ 194 struct usb_hcd *hcd = dev_get_drvdata(dev); 195 bool do_wakeup = device_may_wakeup(dev); 196 197 dev_dbg(dev, "ehci-msm PM suspend\n"); 198 199 return ehci_suspend(hcd, do_wakeup); 200} 201 202static int ehci_msm_pm_resume(struct device *dev) 203{ 204 struct usb_hcd *hcd = dev_get_drvdata(dev); 205 206 dev_dbg(dev, "ehci-msm PM resume\n"); 207 ehci_resume(hcd, false); 208 209 return 0; 210} 211#else 212#define ehci_msm_pm_suspend NULL 213#define ehci_msm_pm_resume NULL 214#endif 215 216static const struct dev_pm_ops ehci_msm_dev_pm_ops = { 217 .suspend = ehci_msm_pm_suspend, 218 .resume = ehci_msm_pm_resume, 219}; 220 221static struct platform_driver ehci_msm_driver = { 222 .probe = ehci_msm_probe, 223 .remove = ehci_msm_remove, 224 .driver = { 225 .name = "msm_hsusb_host", 226 .pm = &ehci_msm_dev_pm_ops, 227 }, 228}; 229