ohci-cns3xxx.c

Go to the documentation of this file.

/*
 * Copyright 2008 Cavium Networks
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, Version 2, as
 * published by the Free Software Foundation.
 */

#include <linux/platform_device.h>
#include <linux/atomic.h>
#include <mach/cns3xxx.h>
#include <mach/pm.h>

static int __devinit
cns3xxx_ohci_start(struct usb_hcd *hcd)
{
    struct ohci_hcd *ohci = hcd_to_ohci(hcd);
    int ret;

    /*
     * EHCI and OHCI share the same clock and power,
     * resetting twice would cause the 1st controller been reset.
     * Therefore only do power up  at the first up device, and
     * power down at the last down device.
     *
     * Set USB AHB INCR length to 16
     */
    if (atomic_inc_return(&usb_pwr_ref) == 1) {
        cns3xxx_pwr_power_up(1 << PM_PLL_HM_PD_CTRL_REG_OFFSET_PLL_USB);
        cns3xxx_pwr_clk_en(1 << PM_CLK_GATE_REG_OFFSET_USB_HOST);
        cns3xxx_pwr_soft_rst(1 << PM_SOFT_RST_REG_OFFST_USB_HOST);
        __raw_writel((__raw_readl(MISC_CHIP_CONFIG_REG) | (0X2 << 24)),
            MISC_CHIP_CONFIG_REG);
    }

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

    ohci->num_ports = 1;

    ret = ohci_run(ohci);
    if (ret < 0) {
        dev_err(hcd->self.controller, "can't start %s\n",
            hcd->self.bus_name);
        ohci_stop(hcd);
        return ret;
    }
    return 0;
}

static const struct hc_driver cns3xxx_ohci_hc_driver = {
    .description        = hcd_name,
    .product_desc       = "CNS3XXX OHCI Host controller",
    .hcd_priv_size      = sizeof(struct ohci_hcd),
    .irq            = ohci_irq,
    .flags          = HCD_USB11 | HCD_MEMORY,
    .start          = cns3xxx_ohci_start,
    .stop           = ohci_stop,
    .shutdown       = ohci_shutdown,
    .urb_enqueue        = ohci_urb_enqueue,
    .urb_dequeue        = ohci_urb_dequeue,
    .endpoint_disable   = ohci_endpoint_disable,
    .get_frame_number   = ohci_get_frame,
    .hub_status_data    = ohci_hub_status_data,
    .hub_control        = ohci_hub_control,
#ifdef CONFIG_PM
    .bus_suspend        = ohci_bus_suspend,
    .bus_resume     = ohci_bus_resume,
#endif
    .start_port_reset   = ohci_start_port_reset,
};

static int cns3xxx_ohci_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    struct usb_hcd *hcd;
    const struct hc_driver *driver = &cns3xxx_ohci_hc_driver;
    struct resource *res;
    int irq;
    int retval;

    if (usb_disabled())
        return -ENODEV;

    res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
    if (!res) {
        dev_err(dev, "Found HC with no IRQ.\n");
        return -ENODEV;
    }
    irq = res->start;

    hcd = usb_create_hcd(driver, dev, dev_name(dev));
    if (!hcd)
        return -ENOMEM;

    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    if (!res) {
        dev_err(dev, "Found HC with no register addr.\n");
        retval = -ENODEV;
        goto err1;
    }
    hcd->rsrc_start = res->start;
    hcd->rsrc_len = resource_size(res);

    if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
            driver->description)) {
        dev_dbg(dev, "controller already in use\n");
        retval = -EBUSY;
        goto err1;
    }

    hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
    if (!hcd->regs) {
        dev_dbg(dev, "error mapping memory\n");
        retval = -EFAULT;
        goto err2;
    }

    ohci_hcd_init(hcd_to_ohci(hcd));

    retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
    if (retval == 0)
        return retval;

    iounmap(hcd->regs);
err2:
    release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
err1:
    usb_put_hcd(hcd);
    return retval;
}

static int cns3xxx_ohci_remove(struct platform_device *pdev)
{
    struct usb_hcd *hcd = platform_get_drvdata(pdev);

    usb_remove_hcd(hcd);
    iounmap(hcd->regs);
    release_mem_region(hcd->rsrc_start, hcd->rsrc_len);

    /*
     * EHCI and OHCI share the same clock and power,
     * resetting twice would cause the 1st controller been reset.
     * Therefore only do power up  at the first up device, and
     * power down at the last down device.
     */
    if (atomic_dec_return(&usb_pwr_ref) == 0)
        cns3xxx_pwr_clk_dis(1 << PM_CLK_GATE_REG_OFFSET_USB_HOST);

    usb_put_hcd(hcd);

    platform_set_drvdata(pdev, NULL);

    return 0;
}

MODULE_ALIAS("platform:cns3xxx-ohci");

static struct platform_driver ohci_hcd_cns3xxx_driver = {
    .probe = cns3xxx_ohci_probe,
    .remove = cns3xxx_ohci_remove,
    .driver = {
        .name = "cns3xxx-ohci",
    },
};