1 // SPDX-License-Identifier: GPL-1.0+ 2 /* 3 * OHCI HCD (Host Controller Driver) for USB. 4 * 5 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> 6 * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net> 7 * (C) Copyright 2002 Hewlett-Packard Company 8 * (C) Copyright 2006 Sylvain Munaut <tnt@246tNt.com> 9 * 10 * Bus glue for OHCI HC on the of_platform bus 11 * 12 * Modified for of_platform bus from ohci-sa1111.c 13 * 14 * This file is licenced under the GPL. 15 */ 16 17 #include <linux/signal.h> 18 #include <linux/of_address.h> 19 #include <linux/of_irq.h> 20 #include <linux/of_platform.h> 21 22 #include <asm/prom.h> 23 24 25 static int 26 ohci_ppc_of_start(struct usb_hcd *hcd) 27 { 28 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 29 int ret; 30 31 if ((ret = ohci_init(ohci)) < 0) 32 return ret; 33 34 if ((ret = ohci_run(ohci)) < 0) { 35 dev_err(hcd->self.controller, "can't start %s\n", 36 hcd->self.bus_name); 37 ohci_stop(hcd); 38 return ret; 39 } 40 41 return 0; 42 } 43 44 static const struct hc_driver ohci_ppc_of_hc_driver = { 45 .description = hcd_name, 46 .product_desc = "OF OHCI", 47 .hcd_priv_size = sizeof(struct ohci_hcd), 48 49 /* 50 * generic hardware linkage 51 */ 52 .irq = ohci_irq, 53 .flags = HCD_USB11 | HCD_MEMORY, 54 55 /* 56 * basic lifecycle operations 57 */ 58 .start = ohci_ppc_of_start, 59 .stop = ohci_stop, 60 .shutdown = ohci_shutdown, 61 62 /* 63 * managing i/o requests and associated device resources 64 */ 65 .urb_enqueue = ohci_urb_enqueue, 66 .urb_dequeue = ohci_urb_dequeue, 67 .endpoint_disable = ohci_endpoint_disable, 68 69 /* 70 * scheduling support 71 */ 72 .get_frame_number = ohci_get_frame, 73 74 /* 75 * root hub support 76 */ 77 .hub_status_data = ohci_hub_status_data, 78 .hub_control = ohci_hub_control, 79 #ifdef CONFIG_PM 80 .bus_suspend = ohci_bus_suspend, 81 .bus_resume = ohci_bus_resume, 82 #endif 83 .start_port_reset = ohci_start_port_reset, 84 }; 85 86 87 static int ohci_hcd_ppc_of_probe(struct platform_device *op) 88 { 89 struct device_node *dn = op->dev.of_node; 90 struct usb_hcd *hcd; 91 struct ohci_hcd *ohci; 92 struct resource res; 93 int irq; 94 95 int rv; 96 int is_bigendian; 97 struct device_node *np; 98 99 if (usb_disabled()) 100 return -ENODEV; 101 102 is_bigendian = 103 of_device_is_compatible(dn, "ohci-bigendian") || 104 of_device_is_compatible(dn, "ohci-be"); 105 106 dev_dbg(&op->dev, "initializing PPC-OF USB Controller\n"); 107 108 rv = of_address_to_resource(dn, 0, &res); 109 if (rv) 110 return rv; 111 112 hcd = usb_create_hcd(&ohci_ppc_of_hc_driver, &op->dev, "PPC-OF USB"); 113 if (!hcd) 114 return -ENOMEM; 115 116 hcd->rsrc_start = res.start; 117 hcd->rsrc_len = resource_size(&res); 118 119 hcd->regs = devm_ioremap_resource(&op->dev, &res); 120 if (IS_ERR(hcd->regs)) { 121 rv = PTR_ERR(hcd->regs); 122 goto err_rmr; 123 } 124 125 irq = irq_of_parse_and_map(dn, 0); 126 if (irq == NO_IRQ) { 127 dev_err(&op->dev, "%s: irq_of_parse_and_map failed\n", 128 __FILE__); 129 rv = -EBUSY; 130 goto err_rmr; 131 } 132 133 ohci = hcd_to_ohci(hcd); 134 if (is_bigendian) { 135 ohci->flags |= OHCI_QUIRK_BE_MMIO | OHCI_QUIRK_BE_DESC; 136 if (of_device_is_compatible(dn, "fsl,mpc5200-ohci")) 137 ohci->flags |= OHCI_QUIRK_FRAME_NO; 138 if (of_device_is_compatible(dn, "mpc5200-ohci")) 139 ohci->flags |= OHCI_QUIRK_FRAME_NO; 140 } 141 142 ohci_hcd_init(ohci); 143 144 rv = usb_add_hcd(hcd, irq, 0); 145 if (rv == 0) { 146 device_wakeup_enable(hcd->self.controller); 147 return 0; 148 } 149 150 /* by now, 440epx is known to show usb_23 erratum */ 151 np = of_find_compatible_node(NULL, NULL, "ibm,usb-ehci-440epx"); 152 153 /* Work around - At this point ohci_run has executed, the 154 * controller is running, everything, the root ports, etc., is 155 * set up. If the ehci driver is loaded, put the ohci core in 156 * the suspended state. The ehci driver will bring it out of 157 * suspended state when / if a non-high speed USB device is 158 * attached to the USB Host port. If the ehci driver is not 159 * loaded, do nothing. request_mem_region is used to test if 160 * the ehci driver is loaded. 161 */ 162 if (np != NULL) { 163 if (!of_address_to_resource(np, 0, &res)) { 164 if (!request_mem_region(res.start, 0x4, hcd_name)) { 165 writel_be((readl_be(&ohci->regs->control) | 166 OHCI_USB_SUSPEND), &ohci->regs->control); 167 (void) readl_be(&ohci->regs->control); 168 } else 169 release_mem_region(res.start, 0x4); 170 } else 171 pr_debug("%s: cannot get ehci offset from fdt\n", __FILE__); 172 } 173 174 irq_dispose_mapping(irq); 175 err_rmr: 176 usb_put_hcd(hcd); 177 178 return rv; 179 } 180 181 static int ohci_hcd_ppc_of_remove(struct platform_device *op) 182 { 183 struct usb_hcd *hcd = platform_get_drvdata(op); 184 185 dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n"); 186 187 usb_remove_hcd(hcd); 188 189 irq_dispose_mapping(hcd->irq); 190 191 usb_put_hcd(hcd); 192 193 return 0; 194 } 195 196 static const struct of_device_id ohci_hcd_ppc_of_match[] = { 197 #ifdef CONFIG_USB_OHCI_HCD_PPC_OF_BE 198 { 199 .name = "usb", 200 .compatible = "ohci-bigendian", 201 }, 202 { 203 .name = "usb", 204 .compatible = "ohci-be", 205 }, 206 #endif 207 #ifdef CONFIG_USB_OHCI_HCD_PPC_OF_LE 208 { 209 .name = "usb", 210 .compatible = "ohci-littledian", 211 }, 212 { 213 .name = "usb", 214 .compatible = "ohci-le", 215 }, 216 #endif 217 {}, 218 }; 219 MODULE_DEVICE_TABLE(of, ohci_hcd_ppc_of_match); 220 221 #if !defined(CONFIG_USB_OHCI_HCD_PPC_OF_BE) && \ 222 !defined(CONFIG_USB_OHCI_HCD_PPC_OF_LE) 223 #error "No endianness selected for ppc-of-ohci" 224 #endif 225 226 227 static struct platform_driver ohci_hcd_ppc_of_driver = { 228 .probe = ohci_hcd_ppc_of_probe, 229 .remove = ohci_hcd_ppc_of_remove, 230 .shutdown = usb_hcd_platform_shutdown, 231 .driver = { 232 .name = "ppc-of-ohci", 233 .of_match_table = ohci_hcd_ppc_of_match, 234 }, 235 }; 236 237