drivers/usb/host/usb-brcm.c - kernel/lockdown - Git at Google

 /*
  * Copyright (C) 2010 Broadcom Corporation
  *
  * This program 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */

 #include <linux/usb.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
 #include <linux/of_platform.h>
 #include <linux/usb/hcd.h>

 #include "usb-brcm-common-init.h"

 struct brcm_usb_instance {
 	void __iomem		*ctrl_regs;
 	void __iomem		*xhci_ec_regs;
 	int			ioc;
 	int			ipp;
 	int			has_xhci;
 	struct clk		*usb_clk;
 };

 static const char msg_clk_not_found[] = "Clock not found in Device Tree\n";

 /***********************************************************************
  * Library functions
  ***********************************************************************/

 int brcm_usb_probe(struct platform_device *pdev,
 		const struct hc_driver *hc_driver,
 		struct usb_hcd **hcdptr,
 		struct clk **hcd_clk_ptr)
 {
 	struct resource *res_mem;
 	int irq;
 	struct usb_hcd *hcd;
 	struct device_node *dn = pdev->dev.of_node;
 	struct clk *usb_clk;
 	int err;

 	if (usb_disabled())
 		return -ENODEV;

 	res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res_mem) {
 		dev_err(&pdev->dev, "platform_get_resource error.\n");
 		return -ENODEV;
 	}

 	irq = platform_get_irq(pdev, 0);
 	if (irq < 0) {
 		dev_err(&pdev->dev, "platform_get_irq error.\n");
 		return -ENODEV;
 	}

 	usb_clk = of_clk_get_by_name(dn, "sw_usb");
 	if (IS_ERR(usb_clk)) {
 		dev_err(&pdev->dev, msg_clk_not_found);
 		usb_clk = NULL;
 	}
 	err = clk_prepare_enable(usb_clk);
 	if (err)
 		return err;
 	*hcd_clk_ptr = usb_clk;

 	/* initialize hcd */
 	hcd = usb_create_hcd(hc_driver, &pdev->dev, dev_name(&pdev->dev));
 	if (!hcd) {
 		dev_err(&pdev->dev, "Failed to create hcd\n");
 		clk_disable(usb_clk);
 		return -ENOMEM;
 	}
 	*hcdptr = hcd;
 	hcd->rsrc_start = res_mem->start;
 	hcd->rsrc_len = resource_size(res_mem);

 	hcd->regs = devm_ioremap_resource(&pdev->dev, res_mem);
 	if (IS_ERR(hcd->regs)) {
 		err = PTR_ERR(hcd->regs);
 		goto err_put_hcd;
 	}
 	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
 	if (err)
 		goto err_put_hcd;

 	device_wakeup_enable(hcd->self.controller);
 	platform_set_drvdata(pdev, hcd);
 	return err;

 err_put_hcd:
 	clk_disable(usb_clk);
 	usb_put_hcd(hcd);

 	return err;
 }
 EXPORT_SYMBOL(brcm_usb_probe);

 int brcm_usb_remove(struct platform_device *pdev, struct clk *hcd_clk)
 {
 	struct usb_hcd *hcd = platform_get_drvdata(pdev);
 	usb_remove_hcd(hcd);
 	usb_put_hcd(hcd);
 	clk_disable(hcd_clk);

 	return 0;
 }
 EXPORT_SYMBOL(brcm_usb_remove);


 #ifdef CONFIG_OF

 /***********************************************************************
  * DT support for USB instances
  ***********************************************************************/

 static int brcm_usb_instance_probe(struct platform_device *pdev)
 {
 	struct device_node *dn = pdev->dev.of_node;
 	struct resource ctrl_res;
 	struct resource xhci_ec_res;
 	const u32 *prop;
 	struct brcm_usb_instance *priv;
 	struct device_node *node;
 	struct brcm_usb_common_init_params params;
 	int err;

 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 	dev_set_drvdata(&pdev->dev, priv);

 	if (of_address_to_resource(dn, 0, &ctrl_res)) {
 		dev_err(&pdev->dev, "can't get USB_CTRL base address\n");
 		return -EINVAL;
 	}

 	priv->ctrl_regs = devm_request_and_ioremap(&pdev->dev, &ctrl_res);
 	if (!priv->ctrl_regs) {
 		dev_err(&pdev->dev, "can't map register space\n");
 		return -EINVAL;
 	}

 	if (!of_address_to_resource(dn, 1, &xhci_ec_res))
 		priv->xhci_ec_regs =
 			devm_request_and_ioremap(&pdev->dev, &xhci_ec_res);
 	prop = of_get_property(dn, "ipp", NULL);
 	if (prop)
 		priv->ipp = be32_to_cpup(prop);

 	prop = of_get_property(dn, "ioc", NULL);
 	if (prop)
 		priv->ioc = be32_to_cpup(prop);

 	node = of_find_compatible_node(dn, NULL, "xhci-platform");
 	of_node_put(node);
 	priv->has_xhci = node != NULL;
 	priv->usb_clk = of_clk_get_by_name(dn, "sw_usb");
 	if (IS_ERR(priv->usb_clk)) {
 		dev_err(&pdev->dev, msg_clk_not_found);
 		priv->usb_clk = NULL;
 	}
 	err = clk_prepare_enable(priv->usb_clk);
 	if (err)
 		return err;
 	params.ctrl_regs = (uintptr_t)priv->ctrl_regs;
 	params.ioc = priv->ioc;
 	params.ipp = priv->ipp;
 	params.has_xhci = priv->has_xhci;
 	params.xhci_ec_regs = (uintptr_t)priv->xhci_ec_regs;
 	brcm_usb_common_init(&params);
 	return of_platform_populate(dn, NULL, NULL, NULL);
 }

 #ifdef CONFIG_PM_SLEEP
 static int brcm_usb_instance_suspend(struct device *dev)
 {
 	struct brcm_usb_instance *priv = dev_get_drvdata(dev);

 	clk_disable(priv->usb_clk);
 	return 0;
 }

 static int brcm_usb_instance_resume(struct device *dev)
 {
 	struct brcm_usb_instance *priv = dev_get_drvdata(dev);
 	struct brcm_usb_common_init_params params;

 	clk_enable(priv->usb_clk);
 	params.ctrl_regs = (uintptr_t)priv->ctrl_regs;
 	params.ioc = priv->ioc;
 	params.ipp = priv->ipp;
 	params.has_xhci = priv->has_xhci;
 	params.xhci_ec_regs = (uintptr_t)priv->xhci_ec_regs;
 	brcm_usb_common_init(&params);
 	return 0;
 }
 #endif /* CONFIG_PM_SLEEP */

 static SIMPLE_DEV_PM_OPS(brcm_usb_instance_pm_ops, brcm_usb_instance_suspend,
 		brcm_usb_instance_resume);

 static const struct of_device_id brcm_usb_instance_match[] = {
 	{ .compatible = "brcm,usb-instance" },
 	{},
 };

 static struct platform_driver brcm_usb_instance_driver = {
 	.driver = {
 		.name = "usb-brcm",
 		.bus = &platform_bus_type,
 		.of_match_table = of_match_ptr(brcm_usb_instance_match),
 		.pm = &brcm_usb_instance_pm_ops,
 	}
 };

 /*
  * We really don't want to try to undo of_platform_populate(), so it
  * is not possible to unbind/deregister this driver.
  */
 static int __init brcm_usb_instance_init(void)
 {
 	return platform_driver_probe(&brcm_usb_instance_driver,
 				     brcm_usb_instance_probe);
 }
 module_init(brcm_usb_instance_init);

 #endif

 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Broadcom Corporation");
 MODULE_DESCRIPTION("Broadcom USB common functions");
	/*
	* Copyright (C) 2010 Broadcom Corporation
	*
	* This program 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.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	*/

	#include <linux/usb.h>
	#include <linux/platform_device.h>
	#include <linux/clk.h>
	#include <linux/module.h>
	#include <linux/of.h>
	#include <linux/of_address.h>
	#include <linux/of_platform.h>
	#include <linux/usb/hcd.h>

	#include "usb-brcm-common-init.h"

	struct brcm_usb_instance {
	void __iomem *ctrl_regs;
	void __iomem *xhci_ec_regs;
	int ioc;
	int ipp;
	int has_xhci;
	struct clk *usb_clk;
	};

	static const char msg_clk_not_found[] = "Clock not found in Device Tree\n";

	/***********************************************************************
	* Library functions
	***********************************************************************/

	int brcm_usb_probe(struct platform_device *pdev,
	const struct hc_driver *hc_driver,
	struct usb_hcd **hcdptr,
	struct clk **hcd_clk_ptr)
	{
	struct resource *res_mem;
	int irq;
	struct usb_hcd *hcd;
	struct device_node *dn = pdev->dev.of_node;
	struct clk *usb_clk;
	int err;

	if (usb_disabled())
	return -ENODEV;

	res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res_mem) {
	dev_err(&pdev->dev, "platform_get_resource error.\n");
	return -ENODEV;
	}

	irq = platform_get_irq(pdev, 0);
	if (irq < 0) {
	dev_err(&pdev->dev, "platform_get_irq error.\n");
	return -ENODEV;
	}

	usb_clk = of_clk_get_by_name(dn, "sw_usb");
	if (IS_ERR(usb_clk)) {
	dev_err(&pdev->dev, msg_clk_not_found);
	usb_clk = NULL;
	}
	err = clk_prepare_enable(usb_clk);
	if (err)
	return err;
	*hcd_clk_ptr = usb_clk;

	/* initialize hcd */
	hcd = usb_create_hcd(hc_driver, &pdev->dev, dev_name(&pdev->dev));
	if (!hcd) {
	dev_err(&pdev->dev, "Failed to create hcd\n");
	clk_disable(usb_clk);
	return -ENOMEM;
	}
	*hcdptr = hcd;
	hcd->rsrc_start = res_mem->start;
	hcd->rsrc_len = resource_size(res_mem);

	hcd->regs = devm_ioremap_resource(&pdev->dev, res_mem);
	if (IS_ERR(hcd->regs)) {
	err = PTR_ERR(hcd->regs);
	goto err_put_hcd;
	}
	err = usb_add_hcd(hcd, irq, IRQF_SHARED);
	if (err)
	goto err_put_hcd;

	device_wakeup_enable(hcd->self.controller);
	platform_set_drvdata(pdev, hcd);
	return err;

	err_put_hcd:
	clk_disable(usb_clk);
	usb_put_hcd(hcd);

	return err;
	}
	EXPORT_SYMBOL(brcm_usb_probe);

	int brcm_usb_remove(struct platform_device pdev, struct clk hcd_clk)
	{
	struct usb_hcd *hcd = platform_get_drvdata(pdev);
	usb_remove_hcd(hcd);
	usb_put_hcd(hcd);
	clk_disable(hcd_clk);

	return 0;
	}
	EXPORT_SYMBOL(brcm_usb_remove);


	#ifdef CONFIG_OF

	/***********************************************************************
	* DT support for USB instances
	***********************************************************************/

	static int brcm_usb_instance_probe(struct platform_device *pdev)
	{
	struct device_node *dn = pdev->dev.of_node;
	struct resource ctrl_res;
	struct resource xhci_ec_res;
	const u32 *prop;
	struct brcm_usb_instance *priv;
	struct device_node *node;
	struct brcm_usb_common_init_params params;
	int err;

	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
	return -ENOMEM;
	dev_set_drvdata(&pdev->dev, priv);

	if (of_address_to_resource(dn, 0, &ctrl_res)) {
	dev_err(&pdev->dev, "can't get USB_CTRL base address\n");
	return -EINVAL;
	}

	priv->ctrl_regs = devm_request_and_ioremap(&pdev->dev, &ctrl_res);
	if (!priv->ctrl_regs) {
	dev_err(&pdev->dev, "can't map register space\n");
	return -EINVAL;
	}

	if (!of_address_to_resource(dn, 1, &xhci_ec_res))
	priv->xhci_ec_regs =
	devm_request_and_ioremap(&pdev->dev, &xhci_ec_res);
	prop = of_get_property(dn, "ipp", NULL);
	if (prop)
	priv->ipp = be32_to_cpup(prop);

	prop = of_get_property(dn, "ioc", NULL);
	if (prop)
	priv->ioc = be32_to_cpup(prop);

	node = of_find_compatible_node(dn, NULL, "xhci-platform");
	of_node_put(node);
	priv->has_xhci = node != NULL;
	priv->usb_clk = of_clk_get_by_name(dn, "sw_usb");
	if (IS_ERR(priv->usb_clk)) {
	dev_err(&pdev->dev, msg_clk_not_found);
	priv->usb_clk = NULL;
	}
	err = clk_prepare_enable(priv->usb_clk);
	if (err)
	return err;
	params.ctrl_regs = (uintptr_t)priv->ctrl_regs;
	params.ioc = priv->ioc;
	params.ipp = priv->ipp;
	params.has_xhci = priv->has_xhci;
	params.xhci_ec_regs = (uintptr_t)priv->xhci_ec_regs;
	brcm_usb_common_init(&params);
	return of_platform_populate(dn, NULL, NULL, NULL);
	}

	#ifdef CONFIG_PM_SLEEP
	static int brcm_usb_instance_suspend(struct device *dev)
	{
	struct brcm_usb_instance *priv = dev_get_drvdata(dev);

	clk_disable(priv->usb_clk);
	return 0;
	}

	static int brcm_usb_instance_resume(struct device *dev)
	{
	struct brcm_usb_instance *priv = dev_get_drvdata(dev);
	struct brcm_usb_common_init_params params;

	clk_enable(priv->usb_clk);
	params.ctrl_regs = (uintptr_t)priv->ctrl_regs;
	params.ioc = priv->ioc;
	params.ipp = priv->ipp;
	params.has_xhci = priv->has_xhci;
	params.xhci_ec_regs = (uintptr_t)priv->xhci_ec_regs;
	brcm_usb_common_init(&params);
	return 0;
	}
	#endif /* CONFIG_PM_SLEEP */

	static SIMPLE_DEV_PM_OPS(brcm_usb_instance_pm_ops, brcm_usb_instance_suspend,
	brcm_usb_instance_resume);

	static const struct of_device_id brcm_usb_instance_match[] = {
	{ .compatible = "brcm,usb-instance" },
	{},
	};

	static struct platform_driver brcm_usb_instance_driver = {
	.driver = {
	.name = "usb-brcm",
	.bus = &platform_bus_type,
	.of_match_table = of_match_ptr(brcm_usb_instance_match),
	.pm = &brcm_usb_instance_pm_ops,
	}
	};

	/*
	* We really don't want to try to undo of_platform_populate(), so it
	* is not possible to unbind/deregister this driver.
	*/
	static int __init brcm_usb_instance_init(void)
	{
	return platform_driver_probe(&brcm_usb_instance_driver,
	brcm_usb_instance_probe);
	}
	module_init(brcm_usb_instance_init);

	#endif

	MODULE_LICENSE("GPL");
	MODULE_AUTHOR("Broadcom Corporation");
	MODULE_DESCRIPTION("Broadcom USB common functions");