usb: isp1760: Merge platform and OF glue codes (c3cc40cc) · Commits · jan.koester / Linux

drivers/usb/host/isp1760-if.c

+55 −135

Original line number	Original line	Diff line number	Diff line
	@@ -12,121 +12,18 @@
	#include <linux/usb.h>		#include <linux/usb.h>
	#include <linux/io.h>		#include <linux/io.h>
	#include <linux/module.h>		#include <linux/module.h>
			#include <linux/of.h>
	#include <linux/platform_device.h>		#include <linux/platform_device.h>
			#include <linux/slab.h>
	#include <linux/usb/isp1760.h>		#include <linux/usb/isp1760.h>
	#include <linux/usb/hcd.h>		#include <linux/usb/hcd.h>

	#include "isp1760-hcd.h"		#include "isp1760-hcd.h"

	#if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ)
	#include <linux/slab.h>
	#include <linux/of.h>
	#include <linux/of_platform.h>
	#include <linux/of_address.h>
	#include <linux/of_irq.h>
	#endif

	#ifdef CONFIG_PCI		#ifdef CONFIG_PCI
	#include <linux/pci.h>		#include <linux/pci.h>
	#endif		#endif

	#if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ)
	static int of_isp1760_probe(struct platform_device *dev)
	{
	struct usb_hcd *hcd;
	struct device_node *dp = dev->dev.of_node;
	struct resource *res;
	struct resource memory;
	int virq;
	resource_size_t res_len;
	int ret;
	unsigned int devflags = 0;
	u32 bus_width = 0;

	ret = of_address_to_resource(dp, 0, &memory);
	if (ret)
	return -ENXIO;

	res_len = resource_size(&memory);

	res = request_mem_region(memory.start, res_len, dev_name(&dev->dev));
	if (!res)
	return -EBUSY;

	virq = irq_of_parse_and_map(dp, 0);
	if (!virq) {
	ret = -ENODEV;
	goto release_reg;
	}

	if (of_device_is_compatible(dp, "nxp,usb-isp1761"))
	devflags \|= ISP1760_FLAG_ISP1761;

	/* Some systems wire up only 16 of the 32 data lines */
	of_property_read_u32(dp, "bus-width", &bus_width);
	if (bus_width == 16)
	devflags \|= ISP1760_FLAG_BUS_WIDTH_16;

	if (of_get_property(dp, "port1-otg", NULL) != NULL)
	devflags \|= ISP1760_FLAG_OTG_EN;

	if (of_get_property(dp, "analog-oc", NULL) != NULL)
	devflags \|= ISP1760_FLAG_ANALOG_OC;

	if (of_get_property(dp, "dack-polarity", NULL) != NULL)
	devflags \|= ISP1760_FLAG_DACK_POL_HIGH;

	if (of_get_property(dp, "dreq-polarity", NULL) != NULL)
	devflags \|= ISP1760_FLAG_DREQ_POL_HIGH;

	hcd = isp1760_register(memory.start, res_len, virq, IRQF_SHARED,
	&dev->dev, dev_name(&dev->dev), devflags);
	if (IS_ERR(hcd)) {
	ret = PTR_ERR(hcd);
	goto release_reg;
	}

	platform_set_drvdata(dev, hcd);
	return ret;

	release_reg:
	release_mem_region(memory.start, res_len);
	return ret;
	}

	static int of_isp1760_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);

	return 0;
	}

	static const struct of_device_id of_isp1760_match[] = {
	{
	.compatible = "nxp,usb-isp1760",
	},
	{
	.compatible = "nxp,usb-isp1761",
	},
	{ },
	};
	MODULE_DEVICE_TABLE(of, of_isp1760_match);

	static struct platform_driver isp1760_of_driver = {
	.driver = {
	.name = "nxp-isp1760",
	.of_match_table = of_isp1760_match,
	},
	.probe = of_isp1760_probe,
	.remove = of_isp1760_remove,
	};
	#endif

	#ifdef CONFIG_PCI		#ifdef CONFIG_PCI
	static int isp1761_pci_probe(struct pci_dev *dev,		static int isp1761_pci_probe(struct pci_dev *dev,
	const struct pci_device_id *id)		const struct pci_device_id *id)
	@@ -304,26 +201,23 @@ static struct pci_driver isp1761_pci_driver = {

	static int isp1760_plat_probe(struct platform_device *pdev)		static int isp1760_plat_probe(struct platform_device *pdev)
	{		{
	int ret = 0;		unsigned long irqflags = IRQF_SHARED;
	struct usb_hcd *hcd;		unsigned int devflags = 0;
	struct resource *mem_res;		struct resource *mem_res;
	struct resource *irq_res;		struct resource *irq_res;
	resource_size_t mem_size;		resource_size_t mem_size;
	struct isp1760_platform_data *priv = dev_get_platdata(&pdev->dev);		struct usb_hcd *hcd;
	unsigned int devflags = 0;		int ret;
	unsigned long irqflags = IRQF_SHARED;

	mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);		mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!mem_res) {		if (!mem_res) {
	pr_warning("isp1760: Memory resource not available\n");		pr_warning("isp1760: Memory resource not available\n");
	ret = -ENODEV;		return -ENODEV;
	goto out;
	}		}
	mem_size = resource_size(mem_res);		mem_size = resource_size(mem_res);
	if (!request_mem_region(mem_res->start, mem_size, "isp1760")) {		if (!request_mem_region(mem_res->start, mem_size, "isp1760")) {
	pr_warning("isp1760: Cannot reserve the memory resource\n");		pr_warning("isp1760: Cannot reserve the memory resource\n");
	ret = -EBUSY;		return -EBUSY;
	goto out;
	}		}

	irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);		irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	@@ -335,39 +229,63 @@ static int isp1760_plat_probe(struct platform_device *pdev)

	irqflags \|= irq_res->flags & IRQF_TRIGGER_MASK;		irqflags \|= irq_res->flags & IRQF_TRIGGER_MASK;

	if (priv) {		if (IS_ENABLED(CONFIG_OF) && pdev->dev.of_node) {
	if (priv->is_isp1761)		struct device_node *dp = pdev->dev.of_node;
			u32 bus_width = 0;

			if (of_device_is_compatible(dp, "nxp,usb-isp1761"))
	devflags \|= ISP1760_FLAG_ISP1761;		devflags \|= ISP1760_FLAG_ISP1761;
	if (priv->bus_width_16)
			/* Some systems wire up only 16 of the 32 data lines */
			of_property_read_u32(dp, "bus-width", &bus_width);
			if (bus_width == 16)
	devflags \|= ISP1760_FLAG_BUS_WIDTH_16;		devflags \|= ISP1760_FLAG_BUS_WIDTH_16;
	if (priv->port1_otg)
			if (of_property_read_bool(dp, "port1-otg"))
	devflags \|= ISP1760_FLAG_OTG_EN;		devflags \|= ISP1760_FLAG_OTG_EN;
	if (priv->analog_oc)
			if (of_property_read_bool(dp, "analog-oc"))
			devflags \|= ISP1760_FLAG_ANALOG_OC;

			if (of_property_read_bool(dp, "dack-polarity"))
			devflags \|= ISP1760_FLAG_DACK_POL_HIGH;

			if (of_property_read_bool(dp, "dreq-polarity"))
			devflags \|= ISP1760_FLAG_DREQ_POL_HIGH;
			} else if (dev_get_platdata(&pdev->dev)) {
			struct isp1760_platform_data *pdata =
			dev_get_platdata(&pdev->dev);

			if (pdata->is_isp1761)
			devflags \|= ISP1760_FLAG_ISP1761;
			if (pdata->bus_width_16)
			devflags \|= ISP1760_FLAG_BUS_WIDTH_16;
			if (pdata->port1_otg)
			devflags \|= ISP1760_FLAG_OTG_EN;
			if (pdata->analog_oc)
	devflags \|= ISP1760_FLAG_ANALOG_OC;		devflags \|= ISP1760_FLAG_ANALOG_OC;
	if (priv->dack_polarity_high)		if (pdata->dack_polarity_high)
	devflags \|= ISP1760_FLAG_DACK_POL_HIGH;		devflags \|= ISP1760_FLAG_DACK_POL_HIGH;
	if (priv->dreq_polarity_high)		if (pdata->dreq_polarity_high)
	devflags \|= ISP1760_FLAG_DREQ_POL_HIGH;		devflags \|= ISP1760_FLAG_DREQ_POL_HIGH;
	}		}

	hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,		hcd = isp1760_register(mem_res->start, mem_size, irq_res->start,
	irqflags, &pdev->dev, dev_name(&pdev->dev),		irqflags, &pdev->dev, dev_name(&pdev->dev),
	devflags);		devflags);

	platform_set_drvdata(pdev, hcd);

	if (IS_ERR(hcd)) {		if (IS_ERR(hcd)) {
	pr_warning("isp1760: Failed to register the HCD device\n");		pr_warning("isp1760: Failed to register the HCD device\n");
	ret = -ENODEV;		ret = PTR_ERR(hcd);
	goto cleanup;		goto cleanup;
	}		}

			platform_set_drvdata(pdev, hcd);

	pr_info("ISP1760 USB device initialised\n");		pr_info("ISP1760 USB device initialised\n");
	return ret;		return 0;

	cleanup:		cleanup:
	release_mem_region(mem_res->start, mem_size);		release_mem_region(mem_res->start, mem_size);
	out:
	return ret;		return ret;
	}		}

	@@ -383,11 +301,21 @@ static int isp1760_plat_remove(struct platform_device *pdev)
	return 0;		return 0;
	}		}

			#ifdef CONFIG_OF
			static const struct of_device_id isp1760_of_match[] = {
			{ .compatible = "nxp,usb-isp1760", },
			{ .compatible = "nxp,usb-isp1761", },
			{ },
			};
			MODULE_DEVICE_TABLE(of, isp1760_of_match);
			#endif

	static struct platform_driver isp1760_plat_driver = {		static struct platform_driver isp1760_plat_driver = {
	.probe = isp1760_plat_probe,		.probe = isp1760_plat_probe,
	.remove = isp1760_plat_remove,		.remove = isp1760_plat_remove,
	.driver = {		.driver = {
	.name = "isp1760",		.name = "isp1760",
			.of_match_table = of_match_ptr(isp1760_of_match),
	},		},
	};		};

	@@ -400,11 +328,6 @@ static int __init isp1760_init(void)
	ret = platform_driver_register(&isp1760_plat_driver);		ret = platform_driver_register(&isp1760_plat_driver);
	if (!ret)		if (!ret)
	any_ret = 0;		any_ret = 0;
	#if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ)
	ret = platform_driver_register(&isp1760_of_driver);
	if (!ret)
	any_ret = 0;
	#endif
	#ifdef CONFIG_PCI		#ifdef CONFIG_PCI
	ret = pci_register_driver(&isp1761_pci_driver);		ret = pci_register_driver(&isp1761_pci_driver);
	if (!ret)		if (!ret)
	@@ -420,9 +343,6 @@ module_init(isp1760_init);
	static void __exit isp1760_exit(void)		static void __exit isp1760_exit(void)
	{		{
	platform_driver_unregister(&isp1760_plat_driver);		platform_driver_unregister(&isp1760_plat_driver);
	#if defined(CONFIG_OF) && defined(CONFIG_OF_IRQ)
	platform_driver_unregister(&isp1760_of_driver);
	#endif
	#ifdef CONFIG_PCI		#ifdef CONFIG_PCI
	pci_unregister_driver(&isp1761_pci_driver);		pci_unregister_driver(&isp1761_pci_driver);
	#endif		#endif