1/* 2 * OHCI HCD (Host Controller Driver) for USB. 3 * 4 * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at> 5 * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net> 6 * (C) Copyright 2002 Hewlett-Packard Company 7 * 8 * Bus Glue for AMD Alchemy Au1xxx 9 * 10 * Written by Christopher Hoover <ch@hpl.hp.com> 11 * Based on fragments of previous driver by Russell King et al. 12 * 13 * Modified for LH7A404 from ohci-sa1111.c 14 * by Durgesh Pattamatta <pattamattad@sharpsec.com> 15 * Modified for AMD Alchemy Au1xxx 16 * by Matt Porter <mporter@kernel.crashing.org> 17 * 18 * This file is licenced under the GPL. 19 */ 20 21#include <linux/platform_device.h> 22#include <linux/signal.h> 23 24#include <asm/mach-au1x00/au1000.h> 25 26 27extern int usb_disabled(void); 28 29static int __devinit ohci_au1xxx_start(struct usb_hcd *hcd) 30{ 31 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 32 int ret; 33 34 ohci_dbg(ohci, "ohci_au1xxx_start, ohci:%p", ohci); 35 36 if ((ret = ohci_init(ohci)) < 0) 37 return ret; 38 39 if ((ret = ohci_run(ohci)) < 0) { 40 err ("can't start %s", hcd->self.bus_name); 41 ohci_stop(hcd); 42 return ret; 43 } 44 45 return 0; 46} 47 48static const struct hc_driver ohci_au1xxx_hc_driver = { 49 .description = hcd_name, 50 .product_desc = "Au1xxx OHCI", 51 .hcd_priv_size = sizeof(struct ohci_hcd), 52 53 /* 54 * generic hardware linkage 55 */ 56 .irq = ohci_irq, 57 .flags = HCD_USB11 | HCD_MEMORY, 58 59 /* 60 * basic lifecycle operations 61 */ 62 .start = ohci_au1xxx_start, 63 .stop = ohci_stop, 64 .shutdown = ohci_shutdown, 65 66 /* 67 * managing i/o requests and associated device resources 68 */ 69 .urb_enqueue = ohci_urb_enqueue, 70 .urb_dequeue = ohci_urb_dequeue, 71 .endpoint_disable = ohci_endpoint_disable, 72 73 /* 74 * scheduling support 75 */ 76 .get_frame_number = ohci_get_frame, 77 78 /* 79 * root hub support 80 */ 81 .hub_status_data = ohci_hub_status_data, 82 .hub_control = ohci_hub_control, 83#ifdef CONFIG_PM 84 .bus_suspend = ohci_bus_suspend, 85 .bus_resume = ohci_bus_resume, 86#endif 87 .start_port_reset = ohci_start_port_reset, 88}; 89 90static int ohci_hcd_au1xxx_drv_probe(struct platform_device *pdev) 91{ 92 int ret, unit; 93 struct usb_hcd *hcd; 94 95 if (usb_disabled()) 96 return -ENODEV; 97 98 if (pdev->resource[1].flags != IORESOURCE_IRQ) { 99 pr_debug("resource[1] is not IORESOURCE_IRQ\n"); 100 return -ENOMEM; 101 } 102 103 hcd = usb_create_hcd(&ohci_au1xxx_hc_driver, &pdev->dev, "au1xxx"); 104 if (!hcd) 105 return -ENOMEM; 106 107 hcd->rsrc_start = pdev->resource[0].start; 108 hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1; 109 110 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { 111 pr_debug("request_mem_region failed\n"); 112 ret = -EBUSY; 113 goto err1; 114 } 115 116 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); 117 if (!hcd->regs) { 118 pr_debug("ioremap failed\n"); 119 ret = -ENOMEM; 120 goto err2; 121 } 122 123 unit = (hcd->rsrc_start == AU1300_USB_OHCI1_PHYS_ADDR) ? 124 ALCHEMY_USB_OHCI1 : ALCHEMY_USB_OHCI0; 125 if (alchemy_usb_control(unit, 1)) { 126 printk(KERN_INFO "%s: controller init failed!\n", pdev->name); 127 ret = -ENODEV; 128 goto err3; 129 } 130 131 ohci_hcd_init(hcd_to_ohci(hcd)); 132 133 ret = usb_add_hcd(hcd, pdev->resource[1].start, 134 IRQF_SHARED); 135 if (ret == 0) { 136 platform_set_drvdata(pdev, hcd); 137 return ret; 138 } 139 140 alchemy_usb_control(unit, 0); 141err3: 142 iounmap(hcd->regs); 143err2: 144 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 145err1: 146 usb_put_hcd(hcd); 147 return ret; 148} 149 150static int ohci_hcd_au1xxx_drv_remove(struct platform_device *pdev) 151{ 152 struct usb_hcd *hcd = platform_get_drvdata(pdev); 153 int unit; 154 155 unit = (hcd->rsrc_start == AU1300_USB_OHCI1_PHYS_ADDR) ? 156 ALCHEMY_USB_OHCI1 : ALCHEMY_USB_OHCI0; 157 usb_remove_hcd(hcd); 158 alchemy_usb_control(unit, 0); 159 iounmap(hcd->regs); 160 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 161 usb_put_hcd(hcd); 162 platform_set_drvdata(pdev, NULL); 163 164 return 0; 165} 166 167#ifdef CONFIG_PM 168static int ohci_hcd_au1xxx_drv_suspend(struct device *dev) 169{ 170 struct usb_hcd *hcd = dev_get_drvdata(dev); 171 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 172 unsigned long flags; 173 int rc; 174 175 rc = 0; 176 177 /* Root hub was already suspended. Disable irq emission and 178 * mark HW unaccessible, bail out if RH has been resumed. Use 179 * the spinlock to properly synchronize with possible pending 180 * RH suspend or resume activity. 181 */ 182 spin_lock_irqsave(&ohci->lock, flags); 183 if (ohci->rh_state != OHCI_RH_SUSPENDED) { 184 rc = -EINVAL; 185 goto bail; 186 } 187 ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable); 188 (void)ohci_readl(ohci, &ohci->regs->intrdisable); 189 190 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 191 192 alchemy_usb_control(ALCHEMY_USB_OHCI0, 0); 193bail: 194 spin_unlock_irqrestore(&ohci->lock, flags); 195 196 return rc; 197} 198 199static int ohci_hcd_au1xxx_drv_resume(struct device *dev) 200{ 201 struct usb_hcd *hcd = dev_get_drvdata(dev); 202 203 alchemy_usb_control(ALCHEMY_USB_OHCI0, 1); 204 205 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags); 206 ohci_finish_controller_resume(hcd); 207 208 return 0; 209} 210 211static const struct dev_pm_ops au1xxx_ohci_pmops = { 212 .suspend = ohci_hcd_au1xxx_drv_suspend, 213 .resume = ohci_hcd_au1xxx_drv_resume, 214}; 215 216#define AU1XXX_OHCI_PMOPS &au1xxx_ohci_pmops 217 218#else 219#define AU1XXX_OHCI_PMOPS NULL 220#endif 221 222static struct platform_driver ohci_hcd_au1xxx_driver = { 223 .probe = ohci_hcd_au1xxx_drv_probe, 224 .remove = ohci_hcd_au1xxx_drv_remove, 225 .shutdown = usb_hcd_platform_shutdown, 226 .driver = { 227 .name = "au1xxx-ohci", 228 .owner = THIS_MODULE, 229 .pm = AU1XXX_OHCI_PMOPS, 230 }, 231}; 232 233MODULE_ALIAS("platform:au1xxx-ohci"); 234