1/* 2 * Copyright (c) 2008 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix 3 * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de> 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License as published by the 7 * Free Software Foundation; either version 2 of the License, or (at your 8 * option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 12 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software Foundation, 17 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 18 */ 19 20#include <linux/platform_device.h> 21#include <linux/clk.h> 22#include <linux/delay.h> 23#include <linux/usb/otg.h> 24#include <linux/slab.h> 25 26#include <mach/mxc_ehci.h> 27 28#define ULPI_VIEWPORT_OFFSET 0x170 29#define PORTSC_OFFSET 0x184 30#define USBMODE_OFFSET 0x1a8 31#define USBMODE_CM_HOST 3 32 33struct ehci_mxc_priv { 34 struct clk *usbclk, *ahbclk; 35 struct usb_hcd *hcd; 36}; 37 38/* called during probe() after chip reset completes */ 39static int ehci_mxc_setup(struct usb_hcd *hcd) 40{ 41 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 42 int retval; 43 44 /* EHCI registers start at offset 0x100 */ 45 ehci->caps = hcd->regs + 0x100; 46 ehci->regs = hcd->regs + 0x100 + 47 HC_LENGTH(ehci_readl(ehci, &ehci->caps->hc_capbase)); 48 dbg_hcs_params(ehci, "reset"); 49 dbg_hcc_params(ehci, "reset"); 50 51 /* cache this readonly data; minimize chip reads */ 52 ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params); 53 54 retval = ehci_halt(ehci); 55 if (retval) 56 return retval; 57 58 /* data structure init */ 59 retval = ehci_init(hcd); 60 if (retval) 61 return retval; 62 63 hcd->has_tt = 1; 64 65 ehci->sbrn = 0x20; 66 67 ehci_reset(ehci); 68 69 ehci_port_power(ehci, 0); 70 return 0; 71} 72 73static const struct hc_driver ehci_mxc_hc_driver = { 74 .description = hcd_name, 75 .product_desc = "Freescale On-Chip EHCI Host Controller", 76 .hcd_priv_size = sizeof(struct ehci_hcd), 77 78 /* 79 * generic hardware linkage 80 */ 81 .irq = ehci_irq, 82 .flags = HCD_USB2 | HCD_MEMORY, 83 84 /* 85 * basic lifecycle operations 86 */ 87 .reset = ehci_mxc_setup, 88 .start = ehci_run, 89 .stop = ehci_stop, 90 .shutdown = ehci_shutdown, 91 92 /* 93 * managing i/o requests and associated device resources 94 */ 95 .urb_enqueue = ehci_urb_enqueue, 96 .urb_dequeue = ehci_urb_dequeue, 97 .endpoint_disable = ehci_endpoint_disable, 98 99 /* 100 * scheduling support 101 */ 102 .get_frame_number = ehci_get_frame, 103 104 /* 105 * root hub support 106 */ 107 .hub_status_data = ehci_hub_status_data, 108 .hub_control = ehci_hub_control, 109 .bus_suspend = ehci_bus_suspend, 110 .bus_resume = ehci_bus_resume, 111 .relinquish_port = ehci_relinquish_port, 112 .port_handed_over = ehci_port_handed_over, 113}; 114 115static int ehci_mxc_drv_probe(struct platform_device *pdev) 116{ 117 struct mxc_usbh_platform_data *pdata = pdev->dev.platform_data; 118 struct usb_hcd *hcd; 119 struct resource *res; 120 int irq, ret, temp; 121 struct ehci_mxc_priv *priv; 122 struct device *dev = &pdev->dev; 123 124 dev_info(&pdev->dev, "initializing i.MX USB Controller\n"); 125 126 if (!pdata) { 127 dev_err(dev, "No platform data given, bailing out.\n"); 128 return -EINVAL; 129 } 130 131 irq = platform_get_irq(pdev, 0); 132 133 hcd = usb_create_hcd(&ehci_mxc_hc_driver, dev, dev_name(dev)); 134 if (!hcd) 135 return -ENOMEM; 136 137 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 138 if (!priv) { 139 ret = -ENOMEM; 140 goto err_alloc; 141 } 142 143 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 144 if (!res) { 145 dev_err(dev, "Found HC with no register addr. Check setup!\n"); 146 ret = -ENODEV; 147 goto err_get_resource; 148 } 149 150 hcd->rsrc_start = res->start; 151 hcd->rsrc_len = resource_size(res); 152 153 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { 154 dev_dbg(dev, "controller already in use\n"); 155 ret = -EBUSY; 156 goto err_request_mem; 157 } 158 159 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); 160 if (!hcd->regs) { 161 dev_err(dev, "error mapping memory\n"); 162 ret = -EFAULT; 163 goto err_ioremap; 164 } 165 166 /* call platform specific init function */ 167 if (pdata->init) { 168 ret = pdata->init(pdev); 169 if (ret) { 170 dev_err(dev, "platform init failed\n"); 171 goto err_init; 172 } 173 /* platforms need some time to settle changed IO settings */ 174 mdelay(10); 175 } 176 177 /* enable clocks */ 178 priv->usbclk = clk_get(dev, "usb"); 179 if (IS_ERR(priv->usbclk)) { 180 ret = PTR_ERR(priv->usbclk); 181 goto err_clk; 182 } 183 clk_enable(priv->usbclk); 184 185 if (!cpu_is_mx35() && !cpu_is_mx25()) { 186 priv->ahbclk = clk_get(dev, "usb_ahb"); 187 if (IS_ERR(priv->ahbclk)) { 188 ret = PTR_ERR(priv->ahbclk); 189 goto err_clk_ahb; 190 } 191 clk_enable(priv->ahbclk); 192 } 193 194 /* set USBMODE to host mode */ 195 temp = readl(hcd->regs + USBMODE_OFFSET); 196 writel(temp | USBMODE_CM_HOST, hcd->regs + USBMODE_OFFSET); 197 198 /* set up the PORTSCx register */ 199 writel(pdata->portsc, hcd->regs + PORTSC_OFFSET); 200 mdelay(10); 201 202 /* setup specific usb hw */ 203 ret = mxc_initialize_usb_hw(pdev->id, pdata->flags); 204 if (ret < 0) 205 goto err_init; 206 207 /* Initialize the transceiver */ 208 if (pdata->otg) { 209 pdata->otg->io_priv = hcd->regs + ULPI_VIEWPORT_OFFSET; 210 ret = otg_init(pdata->otg); 211 if (ret) { 212 dev_err(dev, "unable to init transceiver, probably missing\n"); 213 ret = -ENODEV; 214 goto err_add; 215 } 216 ret = otg_set_vbus(pdata->otg, 1); 217 if (ret) { 218 dev_err(dev, "unable to enable vbus on transceiver\n"); 219 goto err_add; 220 } 221 } 222 223 priv->hcd = hcd; 224 platform_set_drvdata(pdev, priv); 225 226 ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED); 227 if (ret) 228 goto err_add; 229 230 return 0; 231 232err_add: 233 if (pdata && pdata->exit) 234 pdata->exit(pdev); 235err_init: 236 if (priv->ahbclk) { 237 clk_disable(priv->ahbclk); 238 clk_put(priv->ahbclk); 239 } 240err_clk_ahb: 241 clk_disable(priv->usbclk); 242 clk_put(priv->usbclk); 243err_clk: 244 iounmap(hcd->regs); 245err_ioremap: 246 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 247err_request_mem: 248err_get_resource: 249 kfree(priv); 250err_alloc: 251 usb_put_hcd(hcd); 252 return ret; 253} 254 255static int __exit ehci_mxc_drv_remove(struct platform_device *pdev) 256{ 257 struct mxc_usbh_platform_data *pdata = pdev->dev.platform_data; 258 struct ehci_mxc_priv *priv = platform_get_drvdata(pdev); 259 struct usb_hcd *hcd = priv->hcd; 260 261 if (pdata && pdata->exit) 262 pdata->exit(pdev); 263 264 if (pdata->otg) 265 otg_shutdown(pdata->otg); 266 267 usb_remove_hcd(hcd); 268 iounmap(hcd->regs); 269 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 270 usb_put_hcd(hcd); 271 platform_set_drvdata(pdev, NULL); 272 273 clk_disable(priv->usbclk); 274 clk_put(priv->usbclk); 275 if (priv->ahbclk) { 276 clk_disable(priv->ahbclk); 277 clk_put(priv->ahbclk); 278 } 279 280 kfree(priv); 281 282 return 0; 283} 284 285static void ehci_mxc_drv_shutdown(struct platform_device *pdev) 286{ 287 struct ehci_mxc_priv *priv = platform_get_drvdata(pdev); 288 struct usb_hcd *hcd = priv->hcd; 289 290 if (hcd->driver->shutdown) 291 hcd->driver->shutdown(hcd); 292} 293 294MODULE_ALIAS("platform:mxc-ehci"); 295 296static struct platform_driver ehci_mxc_driver = { 297 .probe = ehci_mxc_drv_probe, 298 .remove = __exit_p(ehci_mxc_drv_remove), 299 .shutdown = ehci_mxc_drv_shutdown, 300 .driver = { 301 .name = "mxc-ehci", 302 }, 303}; 304