ohci-platform.c

Go to the documentation of this file.

/*
 * Generic platform ohci driver
 *
 * Copyright 2007 Michael Buesch <[email protected]>
 * Copyright 2011-2012 Hauke Mehrtens <[email protected]>
 *
 * Derived from the OCHI-SSB driver
 * Derived from the OHCI-PCI driver
 * Copyright 1999 Roman Weissgaerber
 * Copyright 2000-2002 David Brownell
 * Copyright 1999 Linus Torvalds
 * Copyright 1999 Gregory P. Smith
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */
#include <linux/platform_device.h>
#include <linux/usb/ohci_pdriver.h>

static int ohci_platform_reset(struct usb_hcd *hcd)
{
    struct platform_device *pdev = to_platform_device(hcd->self.controller);
    struct usb_ohci_pdata *pdata = pdev->dev.platform_data;
    struct ohci_hcd *ohci = hcd_to_ohci(hcd);
    int err;

    if (pdata->big_endian_desc)
        ohci->flags |= OHCI_QUIRK_BE_DESC;
    if (pdata->big_endian_mmio)
        ohci->flags |= OHCI_QUIRK_BE_MMIO;
    if (pdata->no_big_frame_no)
        ohci->flags |= OHCI_QUIRK_FRAME_NO;

    ohci_hcd_init(ohci);
    err = ohci_init(ohci);

    return err;
}

static int ohci_platform_start(struct usb_hcd *hcd)
{
    struct ohci_hcd *ohci = hcd_to_ohci(hcd);
    int err;

    err = ohci_run(ohci);
    if (err < 0) {
        ohci_err(ohci, "can't start\n");
        ohci_stop(hcd);
    }

    return err;
}

static const struct hc_driver ohci_platform_hc_driver = {
    .description        = hcd_name,
    .product_desc       = "Generic Platform OHCI Controller",
    .hcd_priv_size      = sizeof(struct ohci_hcd),

    .irq            = ohci_irq,
    .flags          = HCD_MEMORY | HCD_USB11,

    .reset          = ohci_platform_reset,
    .start          = ohci_platform_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 __devinit ohci_platform_probe(struct platform_device *dev)
{
    struct usb_hcd *hcd;
    struct resource *res_mem;
    struct usb_ohci_pdata *pdata = dev->dev.platform_data;
    int irq;
    int err = -ENOMEM;

    if (!pdata) {
        WARN_ON(1);
        return -ENODEV;
    }

    if (usb_disabled())
        return -ENODEV;

    irq = platform_get_irq(dev, 0);
    if (irq < 0) {
        pr_err("no irq provided");
        return irq;
    }

    res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
    if (!res_mem) {
        pr_err("no memory recourse provided");
        return -ENXIO;
    }

    if (pdata->power_on) {
        err = pdata->power_on(dev);
        if (err < 0)
            return err;
    }

    hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
            dev_name(&dev->dev));
    if (!hcd) {
        err = -ENOMEM;
        goto err_power;
    }

    hcd->rsrc_start = res_mem->start;
    hcd->rsrc_len = resource_size(res_mem);

    if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
        pr_err("controller already in use");
        err = -EBUSY;
        goto err_put_hcd;
    }

    hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
    if (!hcd->regs) {
        err = -ENOMEM;
        goto err_release_region;
    }
    err = usb_add_hcd(hcd, irq, IRQF_SHARED);
    if (err)
        goto err_iounmap;

    platform_set_drvdata(dev, hcd);

    return err;

err_iounmap:
    iounmap(hcd->regs);
err_release_region:
    release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
err_put_hcd:
    usb_put_hcd(hcd);
err_power:
    if (pdata->power_off)
        pdata->power_off(dev);

    return err;
}

static int __devexit ohci_platform_remove(struct platform_device *dev)
{
    struct usb_hcd *hcd = platform_get_drvdata(dev);
    struct usb_ohci_pdata *pdata = dev->dev.platform_data;

    usb_remove_hcd(hcd);
    iounmap(hcd->regs);
    release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
    usb_put_hcd(hcd);
    platform_set_drvdata(dev, NULL);

    if (pdata->power_off)
        pdata->power_off(dev);

    return 0;
}

#ifdef CONFIG_PM

static int ohci_platform_suspend(struct device *dev)
{
    struct usb_ohci_pdata *pdata = dev->platform_data;
    struct platform_device *pdev =
        container_of(dev, struct platform_device, dev);

    if (pdata->power_suspend)
        pdata->power_suspend(pdev);

    return 0;
}

static int ohci_platform_resume(struct device *dev)
{
    struct usb_hcd *hcd = dev_get_drvdata(dev);
    struct usb_ohci_pdata *pdata = dev->platform_data;
    struct platform_device *pdev =
        container_of(dev, struct platform_device, dev);

    if (pdata->power_on) {
        int err = pdata->power_on(pdev);
        if (err < 0)
            return err;
    }

    ohci_finish_controller_resume(hcd);
    return 0;
}

#else /* !CONFIG_PM */
#define ohci_platform_suspend   NULL
#define ohci_platform_resume    NULL
#endif /* CONFIG_PM */

static const struct platform_device_id ohci_platform_table[] = {
    { "ohci-platform", 0 },
    { }
};
MODULE_DEVICE_TABLE(platform, ohci_platform_table);

static const struct dev_pm_ops ohci_platform_pm_ops = {
    .suspend    = ohci_platform_suspend,
    .resume     = ohci_platform_resume,
};

static struct platform_driver ohci_platform_driver = {
    .id_table   = ohci_platform_table,
    .probe      = ohci_platform_probe,
    .remove     = __devexit_p(ohci_platform_remove),
    .shutdown   = usb_hcd_platform_shutdown,
    .driver     = {
        .owner  = THIS_MODULE,
        .name   = "ohci-platform",
        .pm = &ohci_platform_pm_ops,
    }
};