i2c-eg20t: change timeout value 50msec to 1000msec

[zen-stable.git] / drivers / usb / host / ohci-da8xx.c

/*
 * OHCI HCD (Host Controller Driver) for USB.
 *
 * TI DA8xx (OMAP-L1x) Bus Glue
 *
 * Derived from: ohci-omap.c and ohci-s3c2410.c
 * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com>
 *
 * This file is licensed under the terms of the GNU General Public License
 * version 2. This program is licensed "as is" without any warranty of any
 * kind, whether express or implied.
 */

#include <linux/interrupt.h>
#include <linux/jiffies.h>
#include <linux/platform_device.h>
#include <linux/clk.h>

#include <mach/da8xx.h>
#include <mach/usb.h>

#ifndef CONFIG_ARCH_DAVINCI_DA8XX
#error "This file is DA8xx bus glue.  Define CONFIG_ARCH_DAVINCI_DA8XX."
#endif

#define CFGCHIP2        DA8XX_SYSCFG0_VIRT(DA8XX_CFGCHIP2_REG)

static struct clk *usb11_clk;
static struct clk *usb20_clk;

/* Over-current indicator change bitmask */
static volatile u16 ocic_mask;

static void ohci_da8xx_clock(int on)
{
        u32 cfgchip2;

        cfgchip2 = __raw_readl(CFGCHIP2);
        if (on) {
                clk_enable(usb11_clk);

                /*
                 * If USB 1.1 reference clock is sourced from USB 2.0 PHY, we
                 * need to enable the USB 2.0 module clocking, start its PHY,
                 * and not allow it to stop the clock during USB 2.0 suspend.
                 */
                if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX)) {
                        clk_enable(usb20_clk);

                        cfgchip2 &= ~(CFGCHIP2_RESET | CFGCHIP2_PHYPWRDN);
                        cfgchip2 |= CFGCHIP2_PHY_PLLON;
                        __raw_writel(cfgchip2, CFGCHIP2);

                        pr_info("Waiting for USB PHY clock good...\n");
                        while (!(__raw_readl(CFGCHIP2) & CFGCHIP2_PHYCLKGD))
                                cpu_relax();
                }

                /* Enable USB 1.1 PHY */
                cfgchip2 |= CFGCHIP2_USB1SUSPENDM;
        } else {
                clk_disable(usb11_clk);
                if (!(cfgchip2 & CFGCHIP2_USB1PHYCLKMUX))
                        clk_disable(usb20_clk);

                /* Disable USB 1.1 PHY */
                cfgchip2 &= ~CFGCHIP2_USB1SUSPENDM;
        }
        __raw_writel(cfgchip2, CFGCHIP2);
}

/*
 * Handle the port over-current indicator change.
 */
static void ohci_da8xx_ocic_handler(struct da8xx_ohci_root_hub *hub,
                                    unsigned port)
{
        ocic_mask |= 1 << port;

        /* Once over-current is detected, the port needs to be powered down */
        if (hub->get_oci(port) > 0)
                hub->set_power(port, 0);
}

static int ohci_da8xx_init(struct usb_hcd *hcd)
{
        struct device *dev              = hcd->self.controller;
        struct da8xx_ohci_root_hub *hub = dev->platform_data;
        struct ohci_hcd *ohci           = hcd_to_ohci(hcd);
        int result;
        u32 rh_a;

        dev_dbg(dev, "starting USB controller\n");

        ohci_da8xx_clock(1);

        /*
         * DA8xx only have 1 port connected to the pins but the HC root hub
         * register A reports 2 ports, thus we'll have to override it...
         */
        ohci->num_ports = 1;

        result = ohci_init(ohci);
        if (result < 0)
                return result;

        /*
         * Since we're providing a board-specific root hub port power control
         * and over-current reporting, we have to override the HC root hub A
         * register's default value, so that ohci_hub_control() could return
         * the correct hub descriptor...
         */
        rh_a = ohci_readl(ohci, &ohci->regs->roothub.a);
        if (hub->set_power) {
                rh_a &= ~RH_A_NPS;
                rh_a |=  RH_A_PSM;
        }
        if (hub->get_oci) {
                rh_a &= ~RH_A_NOCP;
                rh_a |=  RH_A_OCPM;
        }
        rh_a &= ~RH_A_POTPGT;
        rh_a |= hub->potpgt << 24;
        ohci_writel(ohci, rh_a, &ohci->regs->roothub.a);

        return result;
}

static void ohci_da8xx_stop(struct usb_hcd *hcd)
{
        ohci_stop(hcd);
        ohci_da8xx_clock(0);
}

static int ohci_da8xx_start(struct usb_hcd *hcd)
{
        struct ohci_hcd *ohci           = hcd_to_ohci(hcd);
        int result;

        result = ohci_run(ohci);
        if (result < 0)
                ohci_da8xx_stop(hcd);

        return result;
}

/*
 * Update the status data from the hub with the over-current indicator change.
 */
static int ohci_da8xx_hub_status_data(struct usb_hcd *hcd, char *buf)
{
        int length              = ohci_hub_status_data(hcd, buf);

        /* See if we have OCIC bit set on port 1 */
        if (ocic_mask & (1 << 1)) {
                dev_dbg(hcd->self.controller, "over-current indicator change "
                        "on port 1\n");

                if (!length)
                        length = 1;

                buf[0] |= 1 << 1;
        }
        return length;
}

/*
 * Look at the control requests to the root hub and see if we need to override.
 */
static int ohci_da8xx_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                  u16 wIndex, char *buf, u16 wLength)
{
        struct device *dev              = hcd->self.controller;
        struct da8xx_ohci_root_hub *hub = dev->platform_data;
        int temp;

        switch (typeReq) {
        case GetPortStatus:
                /* Check the port number */
                if (wIndex != 1)
                        break;

                dev_dbg(dev, "GetPortStatus(%u)\n", wIndex);

                temp = roothub_portstatus(hcd_to_ohci(hcd), wIndex - 1);

                /* The port power status (PPS) bit defaults to 1 */
                if (hub->get_power && hub->get_power(wIndex) == 0)
                        temp &= ~RH_PS_PPS;

                /* The port over-current indicator (POCI) bit is always 0 */
                if (hub->get_oci && hub->get_oci(wIndex) > 0)
                        temp |=  RH_PS_POCI;

                /* The over-current indicator change (OCIC) bit is 0 too */
                if (ocic_mask & (1 << wIndex))
                        temp |=  RH_PS_OCIC;

                put_unaligned(cpu_to_le32(temp), (__le32 *)buf);
                return 0;
        case SetPortFeature:
                temp = 1;
                goto check_port;
        case ClearPortFeature:
                temp = 0;

check_port:
                /* Check the port number */
                if (wIndex != 1)
                        break;

                switch (wValue) {
                case USB_PORT_FEAT_POWER:
                        dev_dbg(dev, "%sPortFeature(%u): %s\n",
                                temp ? "Set" : "Clear", wIndex, "POWER");

                        if (!hub->set_power)
                                return -EPIPE;

                        return hub->set_power(wIndex, temp) ? -EPIPE : 0;
                case USB_PORT_FEAT_C_OVER_CURRENT:
                        dev_dbg(dev, "%sPortFeature(%u): %s\n",
                                temp ? "Set" : "Clear", wIndex,
                                "C_OVER_CURRENT");

                        if (temp)
                                ocic_mask |= 1 << wIndex;
                        else
                                ocic_mask &= ~(1 << wIndex);
                        return 0;
                }
        }

        return ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
}

static const struct hc_driver ohci_da8xx_hc_driver = {
        .description            = hcd_name,
        .product_desc           = "DA8xx OHCI",
        .hcd_priv_size          = sizeof(struct ohci_hcd),

        /*
         * generic hardware linkage
         */
        .irq                    = ohci_irq,
        .flags                  = HCD_USB11 | HCD_MEMORY,

        /*
         * basic lifecycle operations
         */
        .reset                  = ohci_da8xx_init,
        .start                  = ohci_da8xx_start,
        .stop                   = ohci_da8xx_stop,
        .shutdown               = ohci_shutdown,

        /*
         * managing i/o requests and associated device resources
         */
        .urb_enqueue            = ohci_urb_enqueue,
        .urb_dequeue            = ohci_urb_dequeue,
        .endpoint_disable       = ohci_endpoint_disable,

        /*
         * scheduling support
         */
        .get_frame_number       = ohci_get_frame,

        /*
         * root hub support
         */
        .hub_status_data        = ohci_da8xx_hub_status_data,
        .hub_control            = ohci_da8xx_hub_control,

#ifdef  CONFIG_PM
        .bus_suspend            = ohci_bus_suspend,
        .bus_resume             = ohci_bus_resume,
#endif
        .start_port_reset       = ohci_start_port_reset,
};

/*-------------------------------------------------------------------------*/


/**
 * usb_hcd_da8xx_probe - initialize DA8xx-based HCDs
 * Context: !in_interrupt()
 *
 * Allocates basic resources for this USB host controller, and
 * then invokes the start() method for the HCD associated with it
 * through the hotplug entry's driver_data.
 */
static int usb_hcd_da8xx_probe(const struct hc_driver *driver,
                               struct platform_device *pdev)
{
        struct da8xx_ohci_root_hub *hub = pdev->dev.platform_data;
        struct usb_hcd  *hcd;
        struct resource *mem;
        int error, irq;

        if (hub == NULL)
                return -ENODEV;

        usb11_clk = clk_get(&pdev->dev, "usb11");
        if (IS_ERR(usb11_clk))
                return PTR_ERR(usb11_clk);

        usb20_clk = clk_get(&pdev->dev, "usb20");
        if (IS_ERR(usb20_clk)) {
                error = PTR_ERR(usb20_clk);
                goto err0;
        }

        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
        if (!hcd) {
                error = -ENOMEM;
                goto err1;
        }

        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!mem) {
                error = -ENODEV;
                goto err2;
        }
        hcd->rsrc_start = mem->start;
        hcd->rsrc_len = resource_size(mem);

        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                dev_dbg(&pdev->dev, "request_mem_region failed\n");
                error = -EBUSY;
                goto err2;
        }

        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
        if (!hcd->regs) {
                dev_err(&pdev->dev, "ioremap failed\n");
                error = -ENOMEM;
                goto err3;
        }

        ohci_hcd_init(hcd_to_ohci(hcd));

        irq = platform_get_irq(pdev, 0);
        if (irq < 0) {
                error = -ENODEV;
                goto err4;
        }
        error = usb_add_hcd(hcd, irq, 0);
        if (error)
                goto err4;

        if (hub->ocic_notify) {
                error = hub->ocic_notify(ohci_da8xx_ocic_handler);
                if (!error)
                        return 0;
        }

        usb_remove_hcd(hcd);
err4:
        iounmap(hcd->regs);
err3:
        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
err2:
        usb_put_hcd(hcd);
err1:
        clk_put(usb20_clk);
err0:
        clk_put(usb11_clk);
        return error;
}

/**
 * usb_hcd_da8xx_remove - shutdown processing for DA8xx-based HCDs
 * @dev: USB Host Controller being removed
 * Context: !in_interrupt()
 *
 * Reverses the effect of usb_hcd_da8xx_probe(), first invoking
 * the HCD's stop() method.  It is always called from a thread
 * context, normally "rmmod", "apmd", or something similar.
 */
static inline void
usb_hcd_da8xx_remove(struct usb_hcd *hcd, struct platform_device *pdev)
{
        struct da8xx_ohci_root_hub *hub = pdev->dev.platform_data;

        hub->ocic_notify(NULL);
        usb_remove_hcd(hcd);
        iounmap(hcd->regs);
        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
        usb_put_hcd(hcd);
        clk_put(usb20_clk);
        clk_put(usb11_clk);
}

static int ohci_hcd_da8xx_drv_probe(struct platform_device *dev)
{
        return usb_hcd_da8xx_probe(&ohci_da8xx_hc_driver, dev);
}

static int ohci_hcd_da8xx_drv_remove(struct platform_device *dev)
{
        struct usb_hcd  *hcd = platform_get_drvdata(dev);

        usb_hcd_da8xx_remove(hcd, dev);
        platform_set_drvdata(dev, NULL);

        return 0;
}

#ifdef CONFIG_PM
static int ohci_da8xx_suspend(struct platform_device *dev, pm_message_t message)
{
        struct usb_hcd  *hcd    = platform_get_drvdata(dev);
        struct ohci_hcd *ohci   = hcd_to_ohci(hcd);

        if (time_before(jiffies, ohci->next_statechange))
                msleep(5);
        ohci->next_statechange = jiffies;

        ohci_da8xx_clock(0);
        hcd->state = HC_STATE_SUSPENDED;
        dev->dev.power.power_state = PMSG_SUSPEND;
        return 0;
}

static int ohci_da8xx_resume(struct platform_device *dev)
{
        struct usb_hcd  *hcd    = platform_get_drvdata(dev);
        struct ohci_hcd *ohci   = hcd_to_ohci(hcd);

        if (time_before(jiffies, ohci->next_statechange))
                msleep(5);
        ohci->next_statechange = jiffies;

        ohci_da8xx_clock(1);
        dev->dev.power.power_state = PMSG_ON;
        usb_hcd_resume_root_hub(hcd);
        return 0;
}
#endif

/*
 * Driver definition to register with platform structure.
 */
static struct platform_driver ohci_hcd_da8xx_driver = {
        .probe          = ohci_hcd_da8xx_drv_probe,
        .remove         = ohci_hcd_da8xx_drv_remove,
        .shutdown       = usb_hcd_platform_shutdown,
#ifdef  CONFIG_PM
        .suspend        = ohci_da8xx_suspend,
        .resume         = ohci_da8xx_resume,
#endif
        .driver         = {
                .owner  = THIS_MODULE,
                .name   = "ohci",
        },
};