mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 10:36:42 +07:00
4811f53fad
Two new PHY drivers coming here: one for Samsung, one for OMAP. Both architectures are adding USB3 support to mainline kernel. The PHY layer now allows us to have mulitple PHYs of the same type, which is necessary for platforms which provide more than one USB peripheral port. There's also a few cleanups here: removal of __dev* annotations, conversion of a cast to to_delayed_work(), and mxs-phy learns about ->set_suspend. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.12 (GNU/Linux) iQIcBAABAgAGBQJRAqlWAAoJEIaOsuA1yqREo+0P/AnevihQnUfh1WlICZeHvQMR +XwSZGVlZYMTiThFldDOsV0ZpngMWW7y7iNc/YjCTyYr1skRjdYahRAc9YZtz2aR 2aIdIbdt6gS4wthPhMUGdeGlGuXngmrFCKeo7xD8RQQgeJecGqrD/y629fAfnq0Z /bCOq+BKj3R9oLOVKtBCOE+j4KQKJSDkywz4GRaZ5yyOmn55Ci/FNJH6EAoGQC5Q D1j+PyhlVpqW/XESn9ceRdXIG9i4a9b3PwKFNbO3iCfaLh5JGTW67pTZ+A7+XNcz iT3+WibsZIAF6ya/Eu/1NcBgj8an6rhuRN/Nu7GTIOxwZNuKbqpYfuOXf1/StTiJ rwmPQ4mh3PzqbLSfe4+H3SIkj8IZCh6NuPiREAwge2HGxOSY7FSIdQSGV6jOqa7F 7Qi3K9aFMqJYAkhEelPfNtZZhK1fVlQTn+t/q4Zr7r593xpV1Ur73Kn3EwGDBcM3 5hyKo9DC1Gr1KXtf1B/hzojnMWqmT5BxJhFBSsw7Nj1F0fUaA3G15+vkanvUSWRV /wP8pjZD44T/bguion7LSdscX98S4fCTJSf571UYymmVGKejfpYI0wRWearVbrhm cwdONVyIt0EFqX2gd2pthx2SBTTOEetb5ssqSKXRBCTDiApjdAPdejVGk3iblw7C LOydELt71ER/o2RNVR+h =c796 -----END PGP SIGNATURE----- Merge tag 'xceiv-for-v3.9' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb into usb-next Felipe writes: usb: xceiv: patches for v3.9 merge window Two new PHY drivers coming here: one for Samsung, one for OMAP. Both architectures are adding USB3 support to mainline kernel. The PHY layer now allows us to have mulitple PHYs of the same type, which is necessary for platforms which provide more than one USB peripheral port. There's also a few cleanups here: removal of __dev* annotations, conversion of a cast to to_delayed_work(), and mxs-phy learns about ->set_suspend.
327 lines
7.7 KiB
C
327 lines
7.7 KiB
C
/*
|
|
* SAMSUNG S5P USB HOST EHCI Controller
|
|
*
|
|
* Copyright (C) 2011 Samsung Electronics Co.Ltd
|
|
* Author: Jingoo Han <jg1.han@samsung.com>
|
|
* Author: Joonyoung Shim <jy0922.shim@samsung.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
*/
|
|
|
|
#include <linux/clk.h>
|
|
#include <linux/of.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/platform_data/usb-ehci-s5p.h>
|
|
#include <linux/usb/phy.h>
|
|
#include <linux/usb/samsung_usb_phy.h>
|
|
#include <plat/usb-phy.h>
|
|
|
|
#define EHCI_INSNREG00(base) (base + 0x90)
|
|
#define EHCI_INSNREG00_ENA_INCR16 (0x1 << 25)
|
|
#define EHCI_INSNREG00_ENA_INCR8 (0x1 << 24)
|
|
#define EHCI_INSNREG00_ENA_INCR4 (0x1 << 23)
|
|
#define EHCI_INSNREG00_ENA_INCRX_ALIGN (0x1 << 22)
|
|
#define EHCI_INSNREG00_ENABLE_DMA_BURST \
|
|
(EHCI_INSNREG00_ENA_INCR16 | EHCI_INSNREG00_ENA_INCR8 | \
|
|
EHCI_INSNREG00_ENA_INCR4 | EHCI_INSNREG00_ENA_INCRX_ALIGN)
|
|
|
|
struct s5p_ehci_hcd {
|
|
struct device *dev;
|
|
struct usb_hcd *hcd;
|
|
struct clk *clk;
|
|
struct usb_phy *phy;
|
|
struct usb_otg *otg;
|
|
struct s5p_ehci_platdata *pdata;
|
|
};
|
|
|
|
static const struct hc_driver s5p_ehci_hc_driver = {
|
|
.description = hcd_name,
|
|
.product_desc = "S5P EHCI Host Controller",
|
|
.hcd_priv_size = sizeof(struct ehci_hcd),
|
|
|
|
.irq = ehci_irq,
|
|
.flags = HCD_MEMORY | HCD_USB2,
|
|
|
|
.reset = ehci_setup,
|
|
.start = ehci_run,
|
|
.stop = ehci_stop,
|
|
.shutdown = ehci_shutdown,
|
|
|
|
.get_frame_number = ehci_get_frame,
|
|
|
|
.urb_enqueue = ehci_urb_enqueue,
|
|
.urb_dequeue = ehci_urb_dequeue,
|
|
.endpoint_disable = ehci_endpoint_disable,
|
|
.endpoint_reset = ehci_endpoint_reset,
|
|
|
|
.hub_status_data = ehci_hub_status_data,
|
|
.hub_control = ehci_hub_control,
|
|
.bus_suspend = ehci_bus_suspend,
|
|
.bus_resume = ehci_bus_resume,
|
|
|
|
.relinquish_port = ehci_relinquish_port,
|
|
.port_handed_over = ehci_port_handed_over,
|
|
|
|
.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
|
|
};
|
|
|
|
static void s5p_ehci_phy_enable(struct s5p_ehci_hcd *s5p_ehci)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(s5p_ehci->dev);
|
|
|
|
if (s5p_ehci->phy)
|
|
usb_phy_init(s5p_ehci->phy);
|
|
else if (s5p_ehci->pdata->phy_init)
|
|
s5p_ehci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST);
|
|
}
|
|
|
|
static void s5p_ehci_phy_disable(struct s5p_ehci_hcd *s5p_ehci)
|
|
{
|
|
struct platform_device *pdev = to_platform_device(s5p_ehci->dev);
|
|
|
|
if (s5p_ehci->phy)
|
|
usb_phy_shutdown(s5p_ehci->phy);
|
|
else if (s5p_ehci->pdata->phy_exit)
|
|
s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
|
|
}
|
|
|
|
static void s5p_setup_vbus_gpio(struct platform_device *pdev)
|
|
{
|
|
int err;
|
|
int gpio;
|
|
|
|
if (!pdev->dev.of_node)
|
|
return;
|
|
|
|
gpio = of_get_named_gpio(pdev->dev.of_node,
|
|
"samsung,vbus-gpio", 0);
|
|
if (!gpio_is_valid(gpio))
|
|
return;
|
|
|
|
err = gpio_request_one(gpio, GPIOF_OUT_INIT_HIGH, "ehci_vbus_gpio");
|
|
if (err)
|
|
dev_err(&pdev->dev, "can't request ehci vbus gpio %d", gpio);
|
|
}
|
|
|
|
static u64 ehci_s5p_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
static int s5p_ehci_probe(struct platform_device *pdev)
|
|
{
|
|
struct s5p_ehci_platdata *pdata = pdev->dev.platform_data;
|
|
struct s5p_ehci_hcd *s5p_ehci;
|
|
struct usb_hcd *hcd;
|
|
struct ehci_hcd *ehci;
|
|
struct resource *res;
|
|
struct usb_phy *phy;
|
|
int irq;
|
|
int err;
|
|
|
|
/*
|
|
* Right now device-tree probed devices don't get dma_mask set.
|
|
* Since shared usb code relies on it, set it here for now.
|
|
* Once we move to full device tree support this will vanish off.
|
|
*/
|
|
if (!pdev->dev.dma_mask)
|
|
pdev->dev.dma_mask = &ehci_s5p_dma_mask;
|
|
if (!pdev->dev.coherent_dma_mask)
|
|
pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
s5p_setup_vbus_gpio(pdev);
|
|
|
|
s5p_ehci = devm_kzalloc(&pdev->dev, sizeof(struct s5p_ehci_hcd),
|
|
GFP_KERNEL);
|
|
if (!s5p_ehci)
|
|
return -ENOMEM;
|
|
|
|
phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
|
|
if (IS_ERR_OR_NULL(phy)) {
|
|
/* Fallback to pdata */
|
|
if (!pdata) {
|
|
dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
|
|
return -EPROBE_DEFER;
|
|
} else {
|
|
s5p_ehci->pdata = pdata;
|
|
}
|
|
} else {
|
|
s5p_ehci->phy = phy;
|
|
s5p_ehci->otg = phy->otg;
|
|
}
|
|
|
|
s5p_ehci->dev = &pdev->dev;
|
|
|
|
hcd = usb_create_hcd(&s5p_ehci_hc_driver, &pdev->dev,
|
|
dev_name(&pdev->dev));
|
|
if (!hcd) {
|
|
dev_err(&pdev->dev, "Unable to create HCD\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
s5p_ehci->hcd = hcd;
|
|
s5p_ehci->clk = devm_clk_get(&pdev->dev, "usbhost");
|
|
|
|
if (IS_ERR(s5p_ehci->clk)) {
|
|
dev_err(&pdev->dev, "Failed to get usbhost clock\n");
|
|
err = PTR_ERR(s5p_ehci->clk);
|
|
goto fail_clk;
|
|
}
|
|
|
|
err = clk_prepare_enable(s5p_ehci->clk);
|
|
if (err)
|
|
goto fail_clk;
|
|
|
|
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
if (!res) {
|
|
dev_err(&pdev->dev, "Failed to get I/O memory\n");
|
|
err = -ENXIO;
|
|
goto fail_io;
|
|
}
|
|
|
|
hcd->rsrc_start = res->start;
|
|
hcd->rsrc_len = resource_size(res);
|
|
hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
|
|
if (!hcd->regs) {
|
|
dev_err(&pdev->dev, "Failed to remap I/O memory\n");
|
|
err = -ENOMEM;
|
|
goto fail_io;
|
|
}
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
if (!irq) {
|
|
dev_err(&pdev->dev, "Failed to get IRQ\n");
|
|
err = -ENODEV;
|
|
goto fail_io;
|
|
}
|
|
|
|
if (s5p_ehci->otg)
|
|
s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
|
|
|
|
s5p_ehci_phy_enable(s5p_ehci);
|
|
|
|
ehci = hcd_to_ehci(hcd);
|
|
ehci->caps = hcd->regs;
|
|
|
|
/* DMA burst Enable */
|
|
writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
|
|
|
|
err = usb_add_hcd(hcd, irq, IRQF_SHARED);
|
|
if (err) {
|
|
dev_err(&pdev->dev, "Failed to add USB HCD\n");
|
|
goto fail_add_hcd;
|
|
}
|
|
|
|
platform_set_drvdata(pdev, s5p_ehci);
|
|
|
|
return 0;
|
|
|
|
fail_add_hcd:
|
|
s5p_ehci_phy_disable(s5p_ehci);
|
|
fail_io:
|
|
clk_disable_unprepare(s5p_ehci->clk);
|
|
fail_clk:
|
|
usb_put_hcd(hcd);
|
|
return err;
|
|
}
|
|
|
|
static int s5p_ehci_remove(struct platform_device *pdev)
|
|
{
|
|
struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
|
|
struct usb_hcd *hcd = s5p_ehci->hcd;
|
|
|
|
usb_remove_hcd(hcd);
|
|
|
|
if (s5p_ehci->otg)
|
|
s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
|
|
|
|
s5p_ehci_phy_disable(s5p_ehci);
|
|
|
|
clk_disable_unprepare(s5p_ehci->clk);
|
|
|
|
usb_put_hcd(hcd);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void s5p_ehci_shutdown(struct platform_device *pdev)
|
|
{
|
|
struct s5p_ehci_hcd *s5p_ehci = platform_get_drvdata(pdev);
|
|
struct usb_hcd *hcd = s5p_ehci->hcd;
|
|
|
|
if (hcd->driver->shutdown)
|
|
hcd->driver->shutdown(hcd);
|
|
}
|
|
|
|
#ifdef CONFIG_PM
|
|
static int s5p_ehci_suspend(struct device *dev)
|
|
{
|
|
struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
|
|
struct usb_hcd *hcd = s5p_ehci->hcd;
|
|
bool do_wakeup = device_may_wakeup(dev);
|
|
int rc;
|
|
|
|
rc = ehci_suspend(hcd, do_wakeup);
|
|
|
|
if (s5p_ehci->otg)
|
|
s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
|
|
|
|
s5p_ehci_phy_disable(s5p_ehci);
|
|
|
|
clk_disable_unprepare(s5p_ehci->clk);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int s5p_ehci_resume(struct device *dev)
|
|
{
|
|
struct s5p_ehci_hcd *s5p_ehci = dev_get_drvdata(dev);
|
|
struct usb_hcd *hcd = s5p_ehci->hcd;
|
|
|
|
clk_prepare_enable(s5p_ehci->clk);
|
|
|
|
if (s5p_ehci->otg)
|
|
s5p_ehci->otg->set_host(s5p_ehci->otg, &s5p_ehci->hcd->self);
|
|
|
|
s5p_ehci_phy_enable(s5p_ehci);
|
|
|
|
/* DMA burst Enable */
|
|
writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
|
|
|
|
ehci_resume(hcd, false);
|
|
return 0;
|
|
}
|
|
#else
|
|
#define s5p_ehci_suspend NULL
|
|
#define s5p_ehci_resume NULL
|
|
#endif
|
|
|
|
static const struct dev_pm_ops s5p_ehci_pm_ops = {
|
|
.suspend = s5p_ehci_suspend,
|
|
.resume = s5p_ehci_resume,
|
|
};
|
|
|
|
#ifdef CONFIG_OF
|
|
static const struct of_device_id exynos_ehci_match[] = {
|
|
{ .compatible = "samsung,exynos4210-ehci" },
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, exynos_ehci_match);
|
|
#endif
|
|
|
|
static struct platform_driver s5p_ehci_driver = {
|
|
.probe = s5p_ehci_probe,
|
|
.remove = s5p_ehci_remove,
|
|
.shutdown = s5p_ehci_shutdown,
|
|
.driver = {
|
|
.name = "s5p-ehci",
|
|
.owner = THIS_MODULE,
|
|
.pm = &s5p_ehci_pm_ops,
|
|
.of_match_table = of_match_ptr(exynos_ehci_match),
|
|
}
|
|
};
|
|
|
|
MODULE_ALIAS("platform:s5p-ehci");
|