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 Rusell 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#ifndef CONFIG_SOC_AU1200 27 28#define USBH_ENABLE_BE (1<<0) 29#define USBH_ENABLE_C (1<<1) 30#define USBH_ENABLE_E (1<<2) 31#define USBH_ENABLE_CE (1<<3) 32#define USBH_ENABLE_RD (1<<4) 33 34#ifdef __LITTLE_ENDIAN 35#define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C) 36#elif __BIG_ENDIAN 37#define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C | USBH_ENABLE_BE) 38#else 39#error not byte order defined 40#endif 41 42#else /* Au1200 */ 43 44#define USB_HOST_CONFIG (USB_MSR_BASE + USB_MSR_MCFG) 45#define USB_MCFG_PFEN (1<<31) 46#define USB_MCFG_RDCOMB (1<<30) 47#define USB_MCFG_SSDEN (1<<23) 48#define USB_MCFG_OHCCLKEN (1<<16) 49#define USB_MCFG_UCAM (1<<7) 50#define USB_MCFG_OBMEN (1<<1) 51#define USB_MCFG_OMEMEN (1<<0) 52 53#define USBH_ENABLE_CE USB_MCFG_OHCCLKEN 54#ifdef CONFIG_DMA_COHERENT 55#define USBH_ENABLE_INIT (USB_MCFG_OHCCLKEN \ 56 | USB_MCFG_PFEN | USB_MCFG_RDCOMB \ 57 | USB_MCFG_SSDEN | USB_MCFG_UCAM \ 58 | USB_MCFG_OBMEN | USB_MCFG_OMEMEN) 59#else 60#define USBH_ENABLE_INIT (USB_MCFG_OHCCLKEN \ 61 | USB_MCFG_PFEN | USB_MCFG_RDCOMB \ 62 | USB_MCFG_SSDEN \ 63 | USB_MCFG_OBMEN | USB_MCFG_OMEMEN) 64#endif 65#define USBH_DISABLE (USB_MCFG_OBMEN | USB_MCFG_OMEMEN) 66 67#endif /* Au1200 */ 68 69extern int usb_disabled(void); 70 71/*-------------------------------------------------------------------------*/ 72 73static void au1xxx_start_ohc(struct platform_device *dev) 74{ 75 printk(KERN_DEBUG __FILE__ 76 ": starting Au1xxx OHCI USB Controller\n"); 77 78 /* enable host controller */ 79 80#ifndef CONFIG_SOC_AU1200 81 82 au_writel(USBH_ENABLE_CE, USB_HOST_CONFIG); 83 udelay(1000); 84 au_writel(USBH_ENABLE_INIT, USB_HOST_CONFIG); 85 udelay(1000); 86 87#else /* Au1200 */ 88 89 /* write HW defaults again in case Yamon cleared them */ 90 if (au_readl(USB_HOST_CONFIG) == 0) { 91 au_writel(0x00d02000, USB_HOST_CONFIG); 92 au_readl(USB_HOST_CONFIG); 93 udelay(1000); 94 } 95 au_writel(USBH_ENABLE_CE | au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG); 96 au_readl(USB_HOST_CONFIG); 97 udelay(1000); 98 au_writel(USBH_ENABLE_INIT | au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG); 99 au_readl(USB_HOST_CONFIG); 100 udelay(1000); 101 102#endif /* Au1200 */ 103 104#ifndef CONFIG_SOC_AU1200 105 /* wait for reset complete (read register twice; see au1500 errata) */ 106 while (au_readl(USB_HOST_CONFIG), 107 !(au_readl(USB_HOST_CONFIG) & USBH_ENABLE_RD)) 108#endif 109 udelay(1000); 110 111 printk(KERN_DEBUG __FILE__ 112 ": Clock to USB host has been enabled \n"); 113} 114 115static void au1xxx_stop_ohc(struct platform_device *dev) 116{ 117 printk(KERN_DEBUG __FILE__ 118 ": stopping Au1xxx OHCI USB Controller\n"); 119 120#ifndef CONFIG_SOC_AU1200 121 122 /* Disable clock */ 123 au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_ENABLE_CE, USB_HOST_CONFIG); 124 125#else /* Au1200 */ 126 127 /* Disable mem */ 128 au_writel(~USBH_DISABLE & au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG); 129 udelay(1000); 130 /* Disable clock */ 131 au_writel(~USBH_ENABLE_CE & au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG); 132 au_readl(USB_HOST_CONFIG); 133#endif /* Au1200 */ 134} 135 136 137/*-------------------------------------------------------------------------*/ 138 139/* configure so an HC device and id are always provided */ 140/* always called with process context; sleeping is OK */ 141 142 143/** 144 * usb_ohci_au1xxx_probe - initialize Au1xxx-based HCDs 145 * Context: !in_interrupt() 146 * 147 * Allocates basic resources for this USB host controller, and 148 * then invokes the start() method for the HCD associated with it 149 * through the hotplug entry's driver_data. 150 * 151 */ 152static int usb_ohci_au1xxx_probe(const struct hc_driver *driver, 153 struct platform_device *dev) 154{ 155 int retval; 156 struct usb_hcd *hcd; 157 158#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT) 159 /* Au1200 AB USB does not support coherent memory */ 160 if (!(read_c0_prid() & 0xff)) { 161 pr_info("%s: this is chip revision AB !!\n", 162 dev->name); 163 pr_info("%s: update your board or re-configure the kernel\n", 164 dev->name); 165 return -ENODEV; 166 } 167#endif 168 169 if (dev->resource[1].flags != IORESOURCE_IRQ) { 170 pr_debug("resource[1] is not IORESOURCE_IRQ\n"); 171 return -ENOMEM; 172 } 173 174 hcd = usb_create_hcd(driver, &dev->dev, "au1xxx"); 175 if (!hcd) 176 return -ENOMEM; 177 hcd->rsrc_start = dev->resource[0].start; 178 hcd->rsrc_len = dev->resource[0].end - dev->resource[0].start + 1; 179 180 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) { 181 pr_debug("request_mem_region failed\n"); 182 retval = -EBUSY; 183 goto err1; 184 } 185 186 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); 187 if (!hcd->regs) { 188 pr_debug("ioremap failed\n"); 189 retval = -ENOMEM; 190 goto err2; 191 } 192 193 au1xxx_start_ohc(dev); 194 ohci_hcd_init(hcd_to_ohci(hcd)); 195 196 retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED | IRQF_SHARED); 197 if (retval == 0) 198 return retval; 199 200 au1xxx_stop_ohc(dev); 201 iounmap(hcd->regs); 202 err2: 203 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 204 err1: 205 usb_put_hcd(hcd); 206 return retval; 207} 208 209 210/* may be called without controller electrically present */ 211/* may be called with controller, bus, and devices active */ 212 213/** 214 * usb_hcd_au1xxx_remove - shutdown processing for Au1xxx-based HCDs 215 * @dev: USB Host Controller being removed 216 * Context: !in_interrupt() 217 * 218 * Reverses the effect of usb_hcd_au1xxx_probe(), first invoking 219 * the HCD's stop() method. It is always called from a thread 220 * context, normally "rmmod", "apmd", or something similar. 221 * 222 */ 223static void usb_ohci_au1xxx_remove(struct usb_hcd *hcd, struct platform_device *dev) 224{ 225 usb_remove_hcd(hcd); 226 au1xxx_stop_ohc(dev); 227 iounmap(hcd->regs); 228 release_mem_region(hcd->rsrc_start, hcd->rsrc_len); 229 usb_put_hcd(hcd); 230} 231 232/*-------------------------------------------------------------------------*/ 233 234static int __devinit 235ohci_au1xxx_start (struct usb_hcd *hcd) 236{ 237 struct ohci_hcd *ohci = hcd_to_ohci (hcd); 238 int ret; 239 240 ohci_dbg (ohci, "ohci_au1xxx_start, ohci:%p", ohci); 241 242 if ((ret = ohci_init (ohci)) < 0) 243 return ret; 244 245 if ((ret = ohci_run (ohci)) < 0) { 246 err ("can't start %s", hcd->self.bus_name); 247 ohci_stop (hcd); 248 return ret; 249 } 250 251 return 0; 252} 253 254/*-------------------------------------------------------------------------*/ 255 256static const struct hc_driver ohci_au1xxx_hc_driver = { 257 .description = hcd_name, 258 .product_desc = "Au1xxx OHCI", 259 .hcd_priv_size = sizeof(struct ohci_hcd), 260 261 /* 262 * generic hardware linkage 263 */ 264 .irq = ohci_irq, 265 .flags = HCD_USB11 | HCD_MEMORY, 266 267 /* 268 * basic lifecycle operations 269 */ 270 .start = ohci_au1xxx_start, 271 .stop = ohci_stop, 272 .shutdown = ohci_shutdown, 273 274 /* 275 * managing i/o requests and associated device resources 276 */ 277 .urb_enqueue = ohci_urb_enqueue, 278 .urb_dequeue = ohci_urb_dequeue, 279 .endpoint_disable = ohci_endpoint_disable, 280 281 /* 282 * scheduling support 283 */ 284 .get_frame_number = ohci_get_frame, 285 286 /* 287 * root hub support 288 */ 289 .hub_status_data = ohci_hub_status_data, 290 .hub_control = ohci_hub_control, 291 .hub_irq_enable = ohci_rhsc_enable, 292#ifdef CONFIG_PM 293 .bus_suspend = ohci_bus_suspend, 294 .bus_resume = ohci_bus_resume, 295#endif 296 .start_port_reset = ohci_start_port_reset, 297}; 298 299/*-------------------------------------------------------------------------*/ 300 301static int ohci_hcd_au1xxx_drv_probe(struct platform_device *pdev) 302{ 303 int ret; 304 305 pr_debug ("In ohci_hcd_au1xxx_drv_probe"); 306 307 if (usb_disabled()) 308 return -ENODEV; 309 310 ret = usb_ohci_au1xxx_probe(&ohci_au1xxx_hc_driver, pdev); 311 return ret; 312} 313 314static int ohci_hcd_au1xxx_drv_remove(struct platform_device *pdev) 315{ 316 struct usb_hcd *hcd = platform_get_drvdata(pdev); 317 318 usb_ohci_au1xxx_remove(hcd, pdev); 319 return 0; 320} 321 /*TBD*/ 322/*static int ohci_hcd_au1xxx_drv_suspend(struct platform_device *dev) 323{ 324 struct usb_hcd *hcd = platform_get_drvdata(dev); 325 326 return 0; 327} 328static int ohci_hcd_au1xxx_drv_resume(struct platform_device *dev) 329{ 330 struct usb_hcd *hcd = platform_get_drvdata(dev); 331 332 return 0; 333} 334*/ 335 336static struct platform_driver ohci_hcd_au1xxx_driver = { 337 .probe = ohci_hcd_au1xxx_drv_probe, 338 .remove = ohci_hcd_au1xxx_drv_remove, 339 .shutdown = usb_hcd_platform_shutdown, 340 /*.suspend = ohci_hcd_au1xxx_drv_suspend, */ 341 /*.resume = ohci_hcd_au1xxx_drv_resume, */ 342 .driver = { 343 .name = "au1xxx-ohci", 344 .owner = THIS_MODULE, 345 }, 346}; 347