drivers/usb/host/ohci-pxa27x.c

   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 pxa27x
   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  *
  16  * Modified for pxa27x from ohci-lh7a404.c
  17  *  by Nick Bane <nick@cecomputing.co.uk> 26-8-2004
  18  *
  19  * This file is licenced under the GPL.
  20  */
  21
  22 #include <linux/device.h>
  23 #include <asm/mach-types.h>
  24 #include <asm/hardware.h>
  25 #include <asm/arch/pxa-regs.h>
  26
  27
  28 #define PMM_NPS_MODE           1
  29 #define PMM_GLOBAL_MODE        2
  30 #define PMM_PERPORT_MODE       3
  31
  32 #define PXA_UHC_MAX_PORTNUM    3
  33
  34 #define UHCRHPS(x)              __REG2( 0x4C000050, (x)<<2 )
  35
  36 static int pxa27x_ohci_pmm_state;
  37
  38 /*
  39   PMM_NPS_MODE -- PMM Non-power switching mode
  40       Ports are powered continuously.
  41
  42   PMM_GLOBAL_MODE -- PMM global switching mode
  43       All ports are powered at the same time.
  44
  45   PMM_PERPORT_MODE -- PMM per port switching mode
  46       Ports are powered individually.
  47  */
  48 static int pxa27x_ohci_select_pmm( int mode )
  49 {
  50         pxa27x_ohci_pmm_state = mode;
  51
  52         switch ( mode ) {
  53         case PMM_NPS_MODE:
  54                 UHCRHDA |= RH_A_NPS;
  55                 break;
  56         case PMM_GLOBAL_MODE:
  57                 UHCRHDA &= ~(RH_A_NPS & RH_A_PSM);
  58                 break;
  59         case PMM_PERPORT_MODE:
  60                 UHCRHDA &= ~(RH_A_NPS);
  61                 UHCRHDA |= RH_A_PSM;
  62
  63                 /* Set port power control mask bits, only 3 ports. */
  64                 UHCRHDB |= (0x7<<17);
  65                 break;
  66         default:
  67                 printk( KERN_ERR
  68                         "Invalid mode %d, set to non-power switch mode.\n",
  69                         mode );
  70
  71                 pxa27x_ohci_pmm_state = PMM_NPS_MODE;
  72                 UHCRHDA |= RH_A_NPS;
  73         }
  74
  75         return 0;
  76 }
  77
  78 /*
  79   If you select PMM_PERPORT_MODE, you should set the port power
  80  */
  81 static int pxa27x_ohci_set_port_power( int port )
  82 {
  83         if ( (pxa27x_ohci_pmm_state==PMM_PERPORT_MODE)
  84              && (port>0) && (port<PXA_UHC_MAX_PORTNUM) ) {
  85                 UHCRHPS(port) |= 0x100;
  86                 return 0;
  87         }
  88         return -1;
  89 }
  90
  91 /*
  92   If you select PMM_PERPORT_MODE, you should set the port power
  93  */
  94 static int pxa27x_ohci_clear_port_power( int port )
  95 {
  96         if ( (pxa27x_ohci_pmm_state==PMM_PERPORT_MODE)
  97              && (port>0) && (port<PXA_UHC_MAX_PORTNUM) ) {
  98                 UHCRHPS(port) |= 0x200;
  99                 return 0;
 100         }
 101
 102         return -1;
 103 }
 104
 105 extern int usb_disabled(void);
 106
 107 /*-------------------------------------------------------------------------*/
 108
 109 static void pxa27x_start_hc(struct platform_device *dev)
 110 {
 111         pxa_set_cken(CKEN10_USBHOST, 1);
 112
 113         UHCHR |= UHCHR_FHR;
 114         udelay(11);
 115         UHCHR &= ~UHCHR_FHR;
 116
 117         UHCHR |= UHCHR_FSBIR;
 118         while (UHCHR & UHCHR_FSBIR)
 119                 cpu_relax();
 120
 121         /* This could be properly abstracted away through the
 122            device data the day more machines are supported and
 123            their differences can be figured out correctly. */
 124         if (machine_is_mainstone()) {
 125                 /* setup Port1 GPIO pin. */
 126                 pxa_gpio_mode( 88 | GPIO_ALT_FN_1_IN);  /* USBHPWR1 */
 127                 pxa_gpio_mode( 89 | GPIO_ALT_FN_2_OUT); /* USBHPEN1 */
 128
 129                 /* Set the Power Control Polarity Low and Power Sense
 130                    Polarity Low to active low. Supply power to USB ports. */
 131                 UHCHR = (UHCHR | UHCHR_PCPL | UHCHR_PSPL) &
 132                         ~(UHCHR_SSEP1 | UHCHR_SSEP2 | UHCHR_SSEP3 | UHCHR_SSE);
 133         }
 134
 135         UHCHR &= ~UHCHR_SSE;
 136
 137         UHCHIE = (UHCHIE_UPRIE | UHCHIE_RWIE);
 138 }
 139
 140 static void pxa27x_stop_hc(struct platform_device *dev)
 141 {
 142         UHCHR |= UHCHR_FHR;
 143         udelay(11);
 144         UHCHR &= ~UHCHR_FHR;
 145
 146         UHCCOMS |= 1;
 147         udelay(10);
 148
 149         pxa_set_cken(CKEN10_USBHOST, 0);
 150 }
 151
 152
 153 /*-------------------------------------------------------------------------*/
 154
 155 /* configure so an HC device and id are always provided */
 156 /* always called with process context; sleeping is OK */
 157
 158
 159 /**
 160  * usb_hcd_pxa27x_probe - initialize pxa27x-based HCDs
 161  * Context: !in_interrupt()
 162  *
 163  * Allocates basic resources for this USB host controller, and
 164  * then invokes the start() method for the HCD associated with it
 165  * through the hotplug entry's driver_data.
 166  *
 167  */
 168 int usb_hcd_pxa27x_probe (const struct hc_driver *driver,
 169                           struct platform_device *dev)
 170 {
 171         int retval;
 172         struct usb_hcd *hcd;
 173
 174         if (dev->resource[1].flags != IORESOURCE_IRQ) {
 175                 pr_debug ("resource[1] is not IORESOURCE_IRQ");
 176                 return -ENOMEM;
 177         }
 178
 179         hcd = usb_create_hcd (driver, &dev->dev, "pxa27x");
 180         if (!hcd)
 181                 return -ENOMEM;
 182         hcd->rsrc_start = dev->resource[0].start;
 183         hcd->rsrc_len = dev->resource[0].end - dev->resource[0].start + 1;
 184
 185         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
 186                 pr_debug("request_mem_region failed");
 187                 retval = -EBUSY;
 188                 goto err1;
 189         }
 190
 191         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
 192         if (!hcd->regs) {
 193                 pr_debug("ioremap failed");
 194                 retval = -ENOMEM;
 195                 goto err2;
 196         }
 197
 198         pxa27x_start_hc(dev);
 199
 200         /* Select Power Management Mode */
 201         pxa27x_ohci_select_pmm( PMM_PERPORT_MODE );
 202
 203         /* If choosing PMM_PERPORT_MODE, we should set the port power before we use it. */
 204         if (pxa27x_ohci_set_port_power(1) < 0)
 205                 printk(KERN_ERR "Setting port 1 power failed.\n");
 206
 207         if (pxa27x_ohci_clear_port_power(2) < 0)
 208                 printk(KERN_ERR "Setting port 2 power failed.\n");
 209
 210         if (pxa27x_ohci_clear_port_power(3) < 0)
 211                 printk(KERN_ERR "Setting port 3 power failed.\n");
 212
 213         ohci_hcd_init(hcd_to_ohci(hcd));
 214
 215         retval = usb_add_hcd(hcd, dev->resource[1].start, SA_INTERRUPT);
 216         if (retval == 0)
 217                 return retval;
 218
 219         pxa27x_stop_hc(dev);
 220         iounmap(hcd->regs);
 221  err2:
 222         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 223  err1:
 224         usb_put_hcd(hcd);
 225         return retval;
 226 }
 227
 228
 229 /* may be called without controller electrically present */
 230 /* may be called with controller, bus, and devices active */
 231
 232 /**
 233  * usb_hcd_pxa27x_remove - shutdown processing for pxa27x-based HCDs
 234  * @dev: USB Host Controller being removed
 235  * Context: !in_interrupt()
 236  *
 237  * Reverses the effect of usb_hcd_pxa27x_probe(), first invoking
 238  * the HCD's stop() method.  It is always called from a thread
 239  * context, normally "rmmod", "apmd", or something similar.
 240  *
 241  */
 242 void usb_hcd_pxa27x_remove (struct usb_hcd *hcd, struct platform_device *dev)
 243 {
 244         usb_remove_hcd(hcd);
 245         pxa27x_stop_hc(dev);
 246         iounmap(hcd->regs);
 247         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 248         usb_put_hcd(hcd);
 249 }
 250
 251 /*-------------------------------------------------------------------------*/
 252
 253 static int __devinit
 254 ohci_pxa27x_start (struct usb_hcd *hcd)
 255 {
 256         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
 257         int             ret;
 258
 259         ohci_dbg (ohci, "ohci_pxa27x_start, ohci:%p", ohci);
 260
 261         if ((ret = ohci_init(ohci)) < 0)
 262                 return ret;
 263
 264         if ((ret = ohci_run (ohci)) < 0) {
 265                 err ("can't start %s", hcd->self.bus_name);
 266                 ohci_stop (hcd);
 267                 return ret;
 268         }
 269
 270         return 0;
 271 }
 272
 273 /*-------------------------------------------------------------------------*/
 274
 275 static const struct hc_driver ohci_pxa27x_hc_driver = {
 276         .description =          hcd_name,
 277         .product_desc =         "PXA27x OHCI",
 278         .hcd_priv_size =        sizeof(struct ohci_hcd),
 279
 280         /*
 281          * generic hardware linkage
 282          */
 283         .irq =                  ohci_irq,
 284         .flags =                HCD_USB11 | HCD_MEMORY,
 285
 286         /*
 287          * basic lifecycle operations
 288          */
 289         .start =                ohci_pxa27x_start,
 290         .stop =                 ohci_stop,
 291
 292         /*
 293          * managing i/o requests and associated device resources
 294          */
 295         .urb_enqueue =          ohci_urb_enqueue,
 296         .urb_dequeue =          ohci_urb_dequeue,
 297         .endpoint_disable =     ohci_endpoint_disable,
 298
 299         /*
 300          * scheduling support
 301          */
 302         .get_frame_number =     ohci_get_frame,
 303
 304         /*
 305          * root hub support
 306          */
 307         .hub_status_data =      ohci_hub_status_data,
 308         .hub_control =          ohci_hub_control,
 309 #ifdef  CONFIG_USB_SUSPEND
 310         .hub_suspend =          ohci_hub_suspend,
 311         .hub_resume =           ohci_hub_resume,
 312 #endif
 313 };
 314
 315 /*-------------------------------------------------------------------------*/
 316
 317 static int ohci_hcd_pxa27x_drv_probe(struct device *dev)
 318 {
 319         struct platform_device *pdev = to_platform_device(dev);
 320         int ret;
 321
 322         pr_debug ("In ohci_hcd_pxa27x_drv_probe");
 323
 324         if (usb_disabled())
 325                 return -ENODEV;
 326
 327         ret = usb_hcd_pxa27x_probe(&ohci_pxa27x_hc_driver, pdev);
 328         return ret;
 329 }
 330
 331 static int ohci_hcd_pxa27x_drv_remove(struct device *dev)
 332 {
 333         struct platform_device *pdev = to_platform_device(dev);
 334         struct usb_hcd *hcd = dev_get_drvdata(dev);
 335
 336         usb_hcd_pxa27x_remove(hcd, pdev);
 337         return 0;
 338 }
 339
 340 static int ohci_hcd_pxa27x_drv_suspend(struct device *dev, pm_message_t state, u32 level)
 341 {
 342 //      struct platform_device *pdev = to_platform_device(dev);
 343 //      struct usb_hcd *hcd = dev_get_drvdata(dev);
 344         printk("%s: not implemented yet\n", __FUNCTION__);
 345
 346         return 0;
 347 }
 348
 349 static int ohci_hcd_pxa27x_drv_resume(struct device *dev, u32 level)
 350 {
 351 //      struct platform_device *pdev = to_platform_device(dev);
 352 //      struct usb_hcd *hcd = dev_get_drvdata(dev);
 353         printk("%s: not implemented yet\n", __FUNCTION__);
 354
 355         return 0;
 356 }
 357
 358
 359 static struct device_driver ohci_hcd_pxa27x_driver = {
 360         .name           = "pxa27x-ohci",
 361         .bus            = &platform_bus_type,
 362         .probe          = ohci_hcd_pxa27x_drv_probe,
 363         .remove         = ohci_hcd_pxa27x_drv_remove,
 364         .suspend        = ohci_hcd_pxa27x_drv_suspend,
 365         .resume         = ohci_hcd_pxa27x_drv_resume,
 366 };
 367
 368 static int __init ohci_hcd_pxa27x_init (void)
 369 {
 370         pr_debug (DRIVER_INFO " (pxa27x)");
 371         pr_debug ("block sizes: ed %d td %d\n",
 372                 sizeof (struct ed), sizeof (struct td));
 373
 374         return driver_register(&ohci_hcd_pxa27x_driver);
 375 }
 376
 377 static void __exit ohci_hcd_pxa27x_cleanup (void)
 378 {
 379         driver_unregister(&ohci_hcd_pxa27x_driver);
 380 }
 381
 382 module_init (ohci_hcd_pxa27x_init);
 383 module_exit (ohci_hcd_pxa27x_cleanup);