Merge "usb: xhci: use bus->sysdev for DMA configuration" into msm-4.9 (e38ff2b6) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/usb/host/xhci-mem.c

+9 −9

Original line number	Diff line number	Diff line
		@@ -586,7 +586,7 @@ static void xhci_free_stream_ctx(struct xhci_hcd *xhci,
		unsigned int num_stream_ctxs,
		struct xhci_stream_ctx *stream_ctx, dma_addr_t dma)
		{
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
		size_t size = sizeof(struct xhci_stream_ctx) * num_stream_ctxs;

		if (size > MEDIUM_STREAM_ARRAY_SIZE)
		@@ -614,7 +614,7 @@ static struct xhci_stream_ctx xhci_alloc_stream_ctx(struct xhci_hcd xhci,
		unsigned int num_stream_ctxs, dma_addr_t *dma,
		gfp_t mem_flags)
		{
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
		size_t size = sizeof(struct xhci_stream_ctx) * num_stream_ctxs;

		if (size > MEDIUM_STREAM_ARRAY_SIZE)
		@@ -1678,7 +1678,7 @@ void xhci_slot_copy(struct xhci_hcd *xhci,
		static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
		{
		int i;
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
		int num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2);

		xhci_dbg_trace(xhci, trace_xhci_dbg_init,
		@@ -1750,7 +1750,7 @@ static void scratchpad_free(struct xhci_hcd *xhci)
		{
		int num_sp;
		int i;
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;

		if (!xhci->scratchpad)
		return;
		@@ -1903,7 +1903,7 @@ int xhci_sec_event_ring_cleanup(struct usb_hcd *hcd, unsigned int intr_num)
		{
		int size;
		struct xhci_hcd *xhci = hcd_to_xhci(hcd);
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;

		if (intr_num >= xhci->max_interrupters) {
		xhci_err(xhci, "invalid secondary interrupter num %d\n",
		@@ -1935,7 +1935,7 @@ void xhci_event_ring_cleanup(struct xhci_hcd *xhci)
		{
		int size;
		unsigned int i;
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;

		/* sec event ring clean up */
		for (i = 1; i < xhci->max_interrupters; i++)
		@@ -1963,7 +1963,7 @@ void xhci_event_ring_cleanup(struct xhci_hcd *xhci)

		void xhci_mem_cleanup(struct xhci_hcd *xhci)
		{
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
		int i, j, num_ports;

		cancel_delayed_work_sync(&xhci->cmd_timer);
		@@ -2475,7 +2475,7 @@ int xhci_event_ring_setup(struct xhci_hcd xhci, struct xhci_ring *er,
		u64 val_64;
		unsigned int val;
		struct xhci_segment *seg;
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;

		*er = xhci_ring_alloc(xhci, ERST_NUM_SEGS, 1, TYPE_EVENT, 0, flags);
		if (!*er)
		@@ -2641,7 +2641,7 @@ int xhci_event_ring_init(struct xhci_hcd *xhci, gfp_t flags)
		int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
		{
		dma_addr_t dma;
		struct device *dev = xhci_to_hcd(xhci)->self.controller;
		struct device *dev = xhci_to_hcd(xhci)->self.sysdev;
		unsigned int val, val2;
		u64 val_64;
		u32 page_size, temp;

drivers/usb/host/xhci-plat.c

+27 −8

Original line number	Diff line number	Diff line
		@@ -14,6 +14,7 @@
		#include <linux/clk.h>
		#include <linux/dma-mapping.h>
		#include <linux/module.h>
		#include <linux/pci.h>
		#include <linux/of.h>
		#include <linux/platform_device.h>
		#include <linux/usb/phy.h>
		@@ -139,6 +140,7 @@ static int xhci_plat_probe(struct platform_device *pdev)
		{
		const struct of_device_id *match;
		const struct hc_driver *driver;
		struct device *sysdev;
		struct xhci_hcd *xhci;
		struct resource *res;
		struct usb_hcd *hcd;
		@@ -155,22 +157,39 @@ static int xhci_plat_probe(struct platform_device *pdev)
		if (irq < 0)
		return -ENODEV;

		/*
		* sysdev must point to a device that is known to the system firmware
		* or PCI hardware. We handle these three cases here:
		* 1. xhci_plat comes from firmware
		* 2. xhci_plat is child of a device from firmware (dwc3-plat)
		* 3. xhci_plat is grandchild of a pci device (dwc3-pci)
		*/
		sysdev = &pdev->dev;
		if (sysdev->parent && !sysdev->of_node && sysdev->parent->of_node)
		sysdev = sysdev->parent;
		#ifdef CONFIG_PCI
		else if (sysdev->parent && sysdev->parent->parent &&
		sysdev->parent->parent->bus == &pci_bus_type)
		sysdev = sysdev->parent->parent;
		#endif

		/* Try to set 64-bit DMA first */
		if (WARN_ON(!pdev->dev.dma_mask))
		if (WARN_ON(!sysdev->dma_mask))
		/* Platform did not initialize dma_mask */
		ret = dma_coerce_mask_and_coherent(&pdev->dev,
		ret = dma_coerce_mask_and_coherent(sysdev,
		DMA_BIT_MASK(64));
		else
		ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
		ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(64));

		/* If seting 64-bit DMA mask fails, fall back to 32-bit DMA mask */
		if (ret) {
		ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
		ret = dma_set_mask_and_coherent(sysdev, DMA_BIT_MASK(32));
		if (ret)
		return ret;
		}

		hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
		hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
		dev_name(&pdev->dev), NULL);
		if (!hcd)
		return -ENOMEM;

		@@ -224,7 +243,7 @@ static int xhci_plat_probe(struct platform_device *pdev)

		xhci->clk = clk;
		xhci->main_hcd = hcd;
		xhci->shared_hcd = usb_create_shared_hcd(driver, &pdev->dev,
		xhci->shared_hcd = __usb_create_hcd(driver, sysdev, &pdev->dev,
		dev_name(&pdev->dev), hcd);
		if (!xhci->shared_hcd) {
		ret = -ENOMEM;
		@@ -233,10 +252,10 @@ static int xhci_plat_probe(struct platform_device *pdev)

		hcd_to_bus(xhci->shared_hcd)->skip_resume = true;

		if (device_property_read_bool(&pdev->dev, "usb3-lpm-capable"))
		if (device_property_read_bool(sysdev, "usb3-lpm-capable"))
		xhci->quirks \|= XHCI_LPM_SUPPORT;

		hcd->usb_phy = devm_usb_get_phy_by_phandle(&pdev->dev, "usb-phy", 0);
		hcd->usb_phy = devm_usb_get_phy_by_phandle(sysdev, "usb-phy", 0);
		if (IS_ERR(hcd->usb_phy)) {
		ret = PTR_ERR(hcd->usb_phy);
		if (ret == -EPROBE_DEFER)

drivers/usb/host/xhci.c

+11 −4

Original line number	Diff line number	Diff line
		@@ -231,6 +231,9 @@ static int xhci_free_msi(struct xhci_hcd *xhci)
		static int xhci_setup_msi(struct xhci_hcd *xhci)
		{
		int ret;
		/*
		* TODO:Check with MSI Soc for sysdev
		*/
		struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);

		ret = pci_enable_msi(pdev);
		@@ -257,7 +260,7 @@ static int xhci_setup_msi(struct xhci_hcd *xhci)
		*/
		static void xhci_free_irq(struct xhci_hcd *xhci)
		{
		struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
		struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.sysdev);
		int ret;

		/* return if using legacy interrupt */
		@@ -743,7 +746,7 @@ void xhci_shutdown(struct usb_hcd *hcd)
		struct xhci_hcd *xhci = hcd_to_xhci(hcd);

		if (xhci->quirks & XHCI_SPURIOUS_REBOOT)
		usb_disable_xhci_ports(to_pci_dev(hcd->self.controller));
		usb_disable_xhci_ports(to_pci_dev(hcd->self.sysdev));

		spin_lock_irq(&xhci->lock);
		xhci_halt(xhci);
		@@ -760,7 +763,7 @@ void xhci_shutdown(struct usb_hcd *hcd)

		/* Yet another workaround for spurious wakeups at shutdown with HSW */
		if (xhci->quirks & XHCI_SPURIOUS_WAKEUP)
		pci_set_power_state(to_pci_dev(hcd->self.controller), PCI_D3hot);
		pci_set_power_state(to_pci_dev(hcd->self.sysdev), PCI_D3hot);
		}

		#ifdef CONFIG_PM
		@@ -4821,7 +4824,11 @@ int xhci_get_frame(struct usb_hcd *hcd)
		int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
		{
		struct xhci_hcd *xhci;
		struct device *dev = hcd->self.controller;
		/*
		* TODO: Check with DWC3 clients for sysdev according to
		* quirks
		*/
		struct device *dev = hcd->self.sysdev;
		int retval;

		/* Accept arbitrarily long scatter-gather lists */