1 /* 2 * OHCI HCD (Host Controller Driver) for USB. 3 * 4 * Copyright (C) 2010 ST Microelectronics. 5 * Deepak Sikri<deepak.sikri@st.com> 6 * 7 * Based on various ohci-*.c drivers 8 * 9 * This file is licensed under the terms of the GNU General Public 10 * License version 2. This program is licensed "as is" without any 11 * warranty of any kind, whether express or implied. 12 */ 13 14 #include <linux/signal.h> 15 #include <linux/platform_device.h> 16 #include <linux/clk.h> 17 #include <linux/of.h> 18 19 struct spear_ohci { 20 struct ohci_hcd ohci; 21 struct clk *clk; 22 }; 23 24 #define to_spear_ohci(hcd) (struct spear_ohci *)hcd_to_ohci(hcd) 25 26 static void spear_start_ohci(struct spear_ohci *ohci) 27 { 28 clk_prepare_enable(ohci->clk); 29 } 30 31 static void spear_stop_ohci(struct spear_ohci *ohci) 32 { 33 clk_disable_unprepare(ohci->clk); 34 } 35 36 static int ohci_spear_start(struct usb_hcd *hcd) 37 { 38 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 39 int ret; 40 41 ret = ohci_init(ohci); 42 if (ret < 0) 43 return ret; 44 ohci->regs = hcd->regs; 45 46 ret = ohci_run(ohci); 47 if (ret < 0) { 48 dev_err(hcd->self.controller, "can't start\n"); 49 ohci_stop(hcd); 50 return ret; 51 } 52 53 create_debug_files(ohci); 54 55 #ifdef DEBUG 56 ohci_dump(ohci, 1); 57 #endif 58 return 0; 59 } 60 61 static const struct hc_driver ohci_spear_hc_driver = { 62 .description = hcd_name, 63 .product_desc = "SPEAr OHCI", 64 .hcd_priv_size = sizeof(struct spear_ohci), 65 66 /* generic hardware linkage */ 67 .irq = ohci_irq, 68 .flags = HCD_USB11 | HCD_MEMORY, 69 70 /* basic lifecycle operations */ 71 .start = ohci_spear_start, 72 .stop = ohci_stop, 73 .shutdown = ohci_shutdown, 74 #ifdef CONFIG_PM 75 .bus_suspend = ohci_bus_suspend, 76 .bus_resume = ohci_bus_resume, 77 #endif 78 79 /* managing i/o requests and associated device resources */ 80 .urb_enqueue = ohci_urb_enqueue, 81 .urb_dequeue = ohci_urb_dequeue, 82 .endpoint_disable = ohci_endpoint_disable, 83 84 /* scheduling support */ 85 .get_frame_number = ohci_get_frame, 86 87 /* root hub support */ 88 .hub_status_data = ohci_hub_status_data, 89 .hub_control = ohci_hub_control, 90 91 .start_port_reset = ohci_start_port_reset, 92 }; 93 94 static int spear_ohci_hcd_drv_probe(struct platform_device *pdev) 95 { 96 const struct hc_driver *driver = &ohci_spear_hc_driver; 97 struct usb_hcd *hcd = NULL; 98 struct clk *usbh_clk; 99 struct spear_ohci *ohci_p; 100 struct resource *res; 101 int retval, irq; 102 103 irq = platform_get_irq(pdev, 0); 104 if (irq < 0) { 105 retval = irq; 106 goto fail; 107 } 108 109 /* 110 * Right now device-tree probed devices don't get dma_mask set. 111 * Since shared usb code relies on it, set it here for now. 112 * Once we have dma capability bindings this can go away. 113 */ 114 if (!pdev->dev.dma_mask) 115 pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask; 116 if (!pdev->dev.coherent_dma_mask) 117 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 118 119 usbh_clk = devm_clk_get(&pdev->dev, NULL); 120 if (IS_ERR(usbh_clk)) { 121 dev_err(&pdev->dev, "Error getting interface clock\n"); 122 retval = PTR_ERR(usbh_clk); 123 goto fail; 124 } 125 126 hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev)); 127 if (!hcd) { 128 retval = -ENOMEM; 129 goto fail; 130 } 131 132 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 133 if (!res) { 134 retval = -ENODEV; 135 goto err_put_hcd; 136 } 137 138 hcd->rsrc_start = pdev->resource[0].start; 139 hcd->rsrc_len = resource_size(res); 140 if (!devm_request_mem_region(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len, 141 hcd_name)) { 142 dev_dbg(&pdev->dev, "request_mem_region failed\n"); 143 retval = -EBUSY; 144 goto err_put_hcd; 145 } 146 147 hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len); 148 if (!hcd->regs) { 149 dev_dbg(&pdev->dev, "ioremap failed\n"); 150 retval = -ENOMEM; 151 goto err_put_hcd; 152 } 153 154 ohci_p = (struct spear_ohci *)hcd_to_ohci(hcd); 155 ohci_p->clk = usbh_clk; 156 spear_start_ohci(ohci_p); 157 ohci_hcd_init(hcd_to_ohci(hcd)); 158 159 retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), 0); 160 if (retval == 0) 161 return retval; 162 163 spear_stop_ohci(ohci_p); 164 err_put_hcd: 165 usb_put_hcd(hcd); 166 fail: 167 dev_err(&pdev->dev, "init fail, %d\n", retval); 168 169 return retval; 170 } 171 172 static int spear_ohci_hcd_drv_remove(struct platform_device *pdev) 173 { 174 struct usb_hcd *hcd = platform_get_drvdata(pdev); 175 struct spear_ohci *ohci_p = to_spear_ohci(hcd); 176 177 usb_remove_hcd(hcd); 178 if (ohci_p->clk) 179 spear_stop_ohci(ohci_p); 180 181 usb_put_hcd(hcd); 182 return 0; 183 } 184 185 #if defined(CONFIG_PM) 186 static int spear_ohci_hcd_drv_suspend(struct platform_device *dev, 187 pm_message_t message) 188 { 189 struct usb_hcd *hcd = platform_get_drvdata(dev); 190 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 191 struct spear_ohci *ohci_p = to_spear_ohci(hcd); 192 193 if (time_before(jiffies, ohci->next_statechange)) 194 msleep(5); 195 ohci->next_statechange = jiffies; 196 197 spear_stop_ohci(ohci_p); 198 return 0; 199 } 200 201 static int spear_ohci_hcd_drv_resume(struct platform_device *dev) 202 { 203 struct usb_hcd *hcd = platform_get_drvdata(dev); 204 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 205 struct spear_ohci *ohci_p = to_spear_ohci(hcd); 206 207 if (time_before(jiffies, ohci->next_statechange)) 208 msleep(5); 209 ohci->next_statechange = jiffies; 210 211 spear_start_ohci(ohci_p); 212 ohci_resume(hcd, false); 213 return 0; 214 } 215 #endif 216 217 static struct of_device_id spear_ohci_id_table[] = { 218 { .compatible = "st,spear600-ohci", }, 219 { }, 220 }; 221 222 /* Driver definition to register with the platform bus */ 223 static struct platform_driver spear_ohci_hcd_driver = { 224 .probe = spear_ohci_hcd_drv_probe, 225 .remove = spear_ohci_hcd_drv_remove, 226 #ifdef CONFIG_PM 227 .suspend = spear_ohci_hcd_drv_suspend, 228 .resume = spear_ohci_hcd_drv_resume, 229 #endif 230 .driver = { 231 .owner = THIS_MODULE, 232 .name = "spear-ohci", 233 .of_match_table = spear_ohci_id_table, 234 }, 235 }; 236 237 MODULE_ALIAS("platform:spear-ohci"); 238