1 /* 2 * Driver for EHCI HCD on SPEAR SOC 3 * 4 * Copyright (C) 2010 ST Micro Electronics, 5 * Deepak Sikri <deepak.sikri@st.com> 6 * 7 * Based on various ehci-*.c drivers 8 * 9 * This file is subject to the terms and conditions of the GNU General Public 10 * License. See the file COPYING in the main directory of this archive for 11 * more details. 12 */ 13 14 #include <linux/clk.h> 15 #include <linux/jiffies.h> 16 #include <linux/of.h> 17 #include <linux/platform_device.h> 18 #include <linux/pm.h> 19 20 struct spear_ehci { 21 struct ehci_hcd ehci; 22 struct clk *clk; 23 }; 24 25 #define to_spear_ehci(hcd) (struct spear_ehci *)hcd_to_ehci(hcd) 26 27 static void spear_start_ehci(struct spear_ehci *ehci) 28 { 29 clk_prepare_enable(ehci->clk); 30 } 31 32 static void spear_stop_ehci(struct spear_ehci *ehci) 33 { 34 clk_disable_unprepare(ehci->clk); 35 } 36 37 static int ehci_spear_setup(struct usb_hcd *hcd) 38 { 39 struct ehci_hcd *ehci = hcd_to_ehci(hcd); 40 41 /* registers start at offset 0x0 */ 42 ehci->caps = hcd->regs; 43 44 return ehci_setup(hcd); 45 } 46 47 static const struct hc_driver ehci_spear_hc_driver = { 48 .description = hcd_name, 49 .product_desc = "SPEAr EHCI", 50 .hcd_priv_size = sizeof(struct spear_ehci), 51 52 /* generic hardware linkage */ 53 .irq = ehci_irq, 54 .flags = HCD_MEMORY | HCD_USB2, 55 56 /* basic lifecycle operations */ 57 .reset = ehci_spear_setup, 58 .start = ehci_run, 59 .stop = ehci_stop, 60 .shutdown = ehci_shutdown, 61 62 /* managing i/o requests and associated device resources */ 63 .urb_enqueue = ehci_urb_enqueue, 64 .urb_dequeue = ehci_urb_dequeue, 65 .endpoint_disable = ehci_endpoint_disable, 66 .endpoint_reset = ehci_endpoint_reset, 67 68 /* scheduling support */ 69 .get_frame_number = ehci_get_frame, 70 71 /* root hub support */ 72 .hub_status_data = ehci_hub_status_data, 73 .hub_control = ehci_hub_control, 74 .bus_suspend = ehci_bus_suspend, 75 .bus_resume = ehci_bus_resume, 76 .relinquish_port = ehci_relinquish_port, 77 .port_handed_over = ehci_port_handed_over, 78 .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete, 79 }; 80 81 #ifdef CONFIG_PM 82 static int ehci_spear_drv_suspend(struct device *dev) 83 { 84 struct usb_hcd *hcd = dev_get_drvdata(dev); 85 bool do_wakeup = device_may_wakeup(dev); 86 87 return ehci_suspend(hcd, do_wakeup); 88 } 89 90 static int ehci_spear_drv_resume(struct device *dev) 91 { 92 struct usb_hcd *hcd = dev_get_drvdata(dev); 93 94 ehci_resume(hcd, false); 95 return 0; 96 } 97 #endif /* CONFIG_PM */ 98 99 static SIMPLE_DEV_PM_OPS(ehci_spear_pm_ops, ehci_spear_drv_suspend, 100 ehci_spear_drv_resume); 101 102 static u64 spear_ehci_dma_mask = DMA_BIT_MASK(32); 103 104 static int spear_ehci_hcd_drv_probe(struct platform_device *pdev) 105 { 106 struct usb_hcd *hcd ; 107 struct spear_ehci *ehci; 108 struct resource *res; 109 struct clk *usbh_clk; 110 const struct hc_driver *driver = &ehci_spear_hc_driver; 111 int irq, retval; 112 113 if (usb_disabled()) 114 return -ENODEV; 115 116 irq = platform_get_irq(pdev, 0); 117 if (irq < 0) { 118 retval = irq; 119 goto fail; 120 } 121 122 /* 123 * Right now device-tree probed devices don't get dma_mask set. 124 * Since shared usb code relies on it, set it here for now. 125 * Once we have dma capability bindings this can go away. 126 */ 127 if (!pdev->dev.dma_mask) 128 pdev->dev.dma_mask = &spear_ehci_dma_mask; 129 130 usbh_clk = devm_clk_get(&pdev->dev, NULL); 131 if (IS_ERR(usbh_clk)) { 132 dev_err(&pdev->dev, "Error getting interface clock\n"); 133 retval = PTR_ERR(usbh_clk); 134 goto fail; 135 } 136 137 hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); 138 if (!hcd) { 139 retval = -ENOMEM; 140 goto fail; 141 } 142 143 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 144 if (!res) { 145 retval = -ENODEV; 146 goto err_put_hcd; 147 } 148 149 hcd->rsrc_start = res->start; 150 hcd->rsrc_len = resource_size(res); 151 if (!devm_request_mem_region(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len, 152 driver->description)) { 153 retval = -EBUSY; 154 goto err_put_hcd; 155 } 156 157 hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len); 158 if (hcd->regs == NULL) { 159 dev_dbg(&pdev->dev, "error mapping memory\n"); 160 retval = -ENOMEM; 161 goto err_put_hcd; 162 } 163 164 ehci = (struct spear_ehci *)hcd_to_ehci(hcd); 165 ehci->clk = usbh_clk; 166 167 spear_start_ehci(ehci); 168 retval = usb_add_hcd(hcd, irq, IRQF_SHARED); 169 if (retval) 170 goto err_stop_ehci; 171 172 return retval; 173 174 err_stop_ehci: 175 spear_stop_ehci(ehci); 176 err_put_hcd: 177 usb_put_hcd(hcd); 178 fail: 179 dev_err(&pdev->dev, "init fail, %d\n", retval); 180 181 return retval ; 182 } 183 184 static int spear_ehci_hcd_drv_remove(struct platform_device *pdev) 185 { 186 struct usb_hcd *hcd = platform_get_drvdata(pdev); 187 struct spear_ehci *ehci_p = to_spear_ehci(hcd); 188 189 if (!hcd) 190 return 0; 191 if (in_interrupt()) 192 BUG(); 193 usb_remove_hcd(hcd); 194 195 if (ehci_p->clk) 196 spear_stop_ehci(ehci_p); 197 usb_put_hcd(hcd); 198 199 return 0; 200 } 201 202 static struct of_device_id spear_ehci_id_table[] = { 203 { .compatible = "st,spear600-ehci", }, 204 { }, 205 }; 206 207 static struct platform_driver spear_ehci_hcd_driver = { 208 .probe = spear_ehci_hcd_drv_probe, 209 .remove = spear_ehci_hcd_drv_remove, 210 .shutdown = usb_hcd_platform_shutdown, 211 .driver = { 212 .name = "spear-ehci", 213 .bus = &platform_bus_type, 214 .pm = &ehci_spear_pm_ops, 215 .of_match_table = of_match_ptr(spear_ehci_id_table), 216 } 217 }; 218 219 MODULE_ALIAS("platform:spear-ehci"); 220