[POWERPC] Uartlite: Add of-platform-bus binding (852e1ea7) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/serial/uartlite.c

+92 −4

Original line number	Diff line number	Diff line
		/*
		* uartlite.c: Serial driver for Xilinx uartlite serial controller
		*
		* Peter Korsgaard <jacmet@sunsite.dk>
		* Copyright (C) 2006 Peter Korsgaard <jacmet@sunsite.dk>
		* Copyright (C) 2007 Secret Lab Technologies Ltd.
		*
		* This file is licensed under the terms of the GNU General Public License
		* version 2. This program is licensed "as is" without any warranty of any
		@@ -17,6 +18,10 @@
		#include <linux/delay.h>
		#include <linux/interrupt.h>
		#include <asm/io.h>
		#if defined(CONFIG_OF)
		#include <linux/of_device.h>
		#include <linux/of_platform.h>
		#endif

		#define ULITE_NAME "ttyUL"
		#define ULITE_MAJOR 204
		@@ -382,8 +387,10 @@ static int __init ulite_console_setup(struct console co, char options)
		port = &ulite_ports[co->index];

		/* not initialized yet? */
		if (!port->membase)
		if (!port->membase) {
		pr_debug("console on ttyUL%i not initialized\n", co->index);
		return -ENODEV;
		}

		if (options)
		uart_parse_options(options, &baud, &parity, &bits, &flow);
		@@ -541,6 +548,72 @@ static struct platform_driver ulite_platform_driver = {
		},
		};

		/* ---------------------------------------------------------------------
		* OF bus bindings
		*/
		#if defined(CONFIG_OF)
		static int __devinit
		ulite_of_probe(struct of_device op, const struct of_device_id match)
		{
		struct resource res;
		const unsigned int *id;
		int irq, rc;

		dev_dbg(&op->dev, "%s(%p, %p)\n", __FUNCTION__, op, match);

		rc = of_address_to_resource(op->node, 0, &res);
		if (rc) {
		dev_err(&op->dev, "invalide address\n");
		return rc;
		}

		irq = irq_of_parse_and_map(op->node, 0);

		id = of_get_property(op->node, "port-number", NULL);

		return ulite_assign(&op->dev, id ? *id : -1, res.start, irq);
		}

		static int __devexit ulite_of_remove(struct of_device *op)
		{
		return ulite_release(&op->dev);
		}

		/* Match table for of_platform binding */
		static struct of_device_id __devinit ulite_of_match[] = {
		{ .type = "serial", .compatible = "xilinx,uartlite", },
		{},
		};
		MODULE_DEVICE_TABLE(of, ulite_of_match);

		static struct of_platform_driver ulite_of_driver = {
		.owner = THIS_MODULE,
		.name = "uartlite",
		.match_table = ulite_of_match,
		.probe = ulite_of_probe,
		.remove = __devexit_p(ulite_of_remove),
		.driver = {
		.name = "uartlite",
		},
		};

		/* Registration helpers to keep the number of #ifdefs to a minimum */
		static inline int __init ulite_of_register(void)
		{
		pr_debug("uartlite: calling of_register_platform_driver()\n");
		return of_register_platform_driver(&ulite_of_driver);
		}

		static inline void __exit ulite_of_unregister(void)
		{
		of_unregister_platform_driver(&ulite_of_driver);
		}
		#else /* CONFIG_OF */
		/* CONFIG_OF not enabled; do nothing helpers */
		static inline int __init ulite_of_register(void) { return 0; }
		static inline void __exit ulite_of_unregister(void) { }
		#endif /* CONFIG_OF */

		/* ---------------------------------------------------------------------
		* Module setup/teardown
		*/
		@@ -549,20 +622,35 @@ int __init ulite_init(void)
		{
		int ret;

		pr_debug("uartlite: calling uart_register_driver()\n");
		ret = uart_register_driver(&ulite_uart_driver);
		if (ret)
		return ret;
		goto err_uart;

		ret = ulite_of_register();
		if (ret)
		goto err_of;

		pr_debug("uartlite: calling platform_driver_register()\n");
		ret = platform_driver_register(&ulite_platform_driver);
		if (ret)
		uart_unregister_driver(&ulite_uart_driver);
		goto err_plat;

		return 0;

		err_plat:
		ulite_of_unregister();
		err_of:
		uart_unregister_driver(&ulite_uart_driver);
		err_uart:
		printk(KERN_ERR "registering uartlite driver failed: err=%i", ret);
		return ret;
		}

		void __exit ulite_exit(void)
		{
		platform_driver_unregister(&ulite_platform_driver);
		ulite_of_unregister();
		uart_unregister_driver(&ulite_uart_driver);
		}