USB: EHCI: Add a generic platform device driver (7a7a4a59) · Commits · 戴 / test

drivers/usb/host/Kconfig

+10 −0

Original line number	Diff line number	Diff line
		@@ -407,6 +407,16 @@ config USB_OHCI_HCD_PLATFORM

		If unsure, say N.

		config USB_EHCI_HCD_PLATFORM
		bool "Generic EHCI driver for a platform device"
		depends on USB_EHCI_HCD && EXPERIMENTAL
		default n
		---help---
		Adds an EHCI host driver for a generic platform device, which
		provieds a memory space and an irq.

		If unsure, say N.

		config USB_OHCI_BIG_ENDIAN_DESC
		bool
		depends on USB_OHCI_HCD

drivers/usb/host/ehci-hcd.c

+5 −0

Original line number	Diff line number	Diff line
		@@ -1376,6 +1376,11 @@ MODULE_LICENSE ("GPL");
		#define PLATFORM_DRIVER ehci_ls1x_driver
		#endif

		#ifdef CONFIG_USB_EHCI_HCD_PLATFORM
		#include "ehci-platform.c"
		#define PLATFORM_DRIVER ehci_platform_driver
		#endif

		#if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER) && \
		!defined(PS3_SYSTEM_BUS_DRIVER) && !defined(OF_PLATFORM_DRIVER) && \
		!defined(XILINX_OF_PLATFORM_DRIVER)

drivers/usb/host/ehci-platform.c

0 → 100644

+198 −0

Original line number	Diff line number	Diff line
		/*
		* Generic platform ehci driver
		*
		* Copyright 2007 Steven Brown <sbrown@cortland.com>
		* Copyright 2010-2012 Hauke Mehrtens <hauke@hauke-m.de>
		*
		* Derived from the ohci-ssb driver
		* Copyright 2007 Michael Buesch <m@bues.ch>
		*
		* Derived from the EHCI-PCI driver
		* Copyright (c) 2000-2004 by David Brownell
		*
		* 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/ehci_pdriver.h>

		static int ehci_platform_reset(struct usb_hcd *hcd)
		{
		struct platform_device *pdev = to_platform_device(hcd->self.controller);
		struct usb_ehci_pdata *pdata = pdev->dev.platform_data;
		struct ehci_hcd *ehci = hcd_to_ehci(hcd);
		int retval;

		hcd->has_tt = pdata->has_tt;
		ehci->has_synopsys_hc_bug = pdata->has_synopsys_hc_bug;
		ehci->big_endian_desc = pdata->big_endian_desc;
		ehci->big_endian_mmio = pdata->big_endian_mmio;

		ehci->caps = hcd->regs + pdata->caps_offset;
		retval = ehci_setup(hcd);
		if (retval)
		return retval;

		if (pdata->port_power_on)
		ehci_port_power(ehci, 1);
		if (pdata->port_power_off)
		ehci_port_power(ehci, 0);

		return 0;
		}

		static const struct hc_driver ehci_platform_hc_driver = {
		.description = hcd_name,
		.product_desc = "Generic Platform EHCI Controller",
		.hcd_priv_size = sizeof(struct ehci_hcd),

		.irq = ehci_irq,
		.flags = HCD_MEMORY \| HCD_USB2,

		.reset = ehci_platform_reset,
		.start = ehci_run,
		.stop = ehci_stop,
		.shutdown = ehci_shutdown,

		.urb_enqueue = ehci_urb_enqueue,
		.urb_dequeue = ehci_urb_dequeue,
		.endpoint_disable = ehci_endpoint_disable,
		.endpoint_reset = ehci_endpoint_reset,

		.get_frame_number = ehci_get_frame,

		.hub_status_data = ehci_hub_status_data,
		.hub_control = ehci_hub_control,
		#if defined(CONFIG_PM)
		.bus_suspend = ehci_bus_suspend,
		.bus_resume = ehci_bus_resume,
		#endif
		.relinquish_port = ehci_relinquish_port,
		.port_handed_over = ehci_port_handed_over,

		.update_device = ehci_update_device,

		.clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
		};

		static int __devinit ehci_platform_probe(struct platform_device *dev)
		{
		struct usb_hcd *hcd;
		struct resource *res_mem;
		int irq;
		int err = -ENOMEM;

		BUG_ON(!dev->dev.platform_data);

		if (usb_disabled())
		return -ENODEV;

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

		hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
		dev_name(&dev->dev));
		if (!hcd)
		return -ENOMEM;

		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)
		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);
		return err;
		}

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

		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);

		return 0;
		}

		#ifdef CONFIG_PM

		static int ehci_platform_suspend(struct device *dev)
		{
		struct usb_hcd *hcd = dev_get_drvdata(dev);
		bool wakeup = device_may_wakeup(dev);

		ehci_prepare_ports_for_controller_suspend(hcd_to_ehci(hcd), wakeup);
		return 0;
		}

		static int ehci_platform_resume(struct device *dev)
		{
		struct usb_hcd *hcd = dev_get_drvdata(dev);

		ehci_prepare_ports_for_controller_resume(hcd_to_ehci(hcd));
		return 0;
		}

		#else /* !CONFIG_PM */
		#define ehci_platform_suspend NULL
		#define ehci_platform_resume NULL
		#endif /* CONFIG_PM */

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

		static const struct dev_pm_ops ehci_platform_pm_ops = {
		.suspend = ehci_platform_suspend,
		.resume = ehci_platform_resume,
		};

		static struct platform_driver ehci_platform_driver = {
		.id_table = ehci_platform_table,
		.probe = ehci_platform_probe,
		.remove = __devexit_p(ehci_platform_remove),
		.shutdown = usb_hcd_platform_shutdown,
		.driver = {
		.owner = THIS_MODULE,
		.name = "ehci-platform",
		.pm = &ehci_platform_pm_ops,
		}
		};

include/linux/usb/ehci_pdriver.h

0 → 100644

+46 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012 Hauke Mehrtens <hauke@hauke-m.de>
		*
		* 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.
		*
		* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
		*/

		#ifndef __USB_CORE_EHCI_PDRIVER_H
		#define __USB_CORE_EHCI_PDRIVER_H

		/**
		* struct usb_ehci_pdata - platform_data for generic ehci driver
		*
		* @caps_offset: offset of the EHCI Capability Registers to the start of
		* the io memory region provided to the driver.
		* @has_tt: set to 1 if TT is integrated in root hub.
		* @port_power_on: set to 1 if the controller needs a power up after
		* initialization.
		* @port_power_off: set to 1 if the controller needs to be powered down
		* after initialization.
		*
		* These are general configuration options for the EHCI controller. All of
		* these options are activating more or less workarounds for some hardware.
		*/
		struct usb_ehci_pdata {
		int caps_offset;
		unsigned has_tt:1;
		unsigned has_synopsys_hc_bug:1;
		unsigned big_endian_desc:1;
		unsigned big_endian_mmio:1;
		unsigned port_power_on:1;
		unsigned port_power_off:1;
		};

		#endif /* __USB_CORE_EHCI_PDRIVER_H */

Admin message