path: root/target/linux/ubicom32/files/drivers/serial/ubi32_serdes.c

/*
 * drivers/serial/ubi32_serdes.c
 *   Ubicom32 On-Chip Serial Driver
 *
 * (C) Copyright 2009, Ubicom, Inc.
 *
 * This file is part of the Ubicom32 Linux Kernel Port.
 *
 * The Ubicom32 Linux Kernel Port 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.
 *
 * The Ubicom32 Linux Kernel Port 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 the Ubicom32 Linux Kernel Port.  If not,
 * see <http://www.gnu.org/licenses/>.
 *
 * Ubicom32 implementation derived from (with many thanks):
 *   arch/m68knommu
 *   arch/blackfin
 *   arch/parisc
 */
#include <linux/module.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/console.h>
#include <linux/sysrq.h>
#include <linux/platform_device.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/serial_core.h>

#include <asm/ip5000.h>
#include <asm/ubicom32suart.h>


#define SERIAL_UBICOM_PIN_RXD	(1 << 0)
#define SERIAL_UBICOM_PIN_TXD	(1 << 6)
#define SERIAL_UBICOM_CTL0	0x8b300000
#define SERIAL_UBICOM_CTL1	0x00000009

#define SERIAL_UBICOM_DATA_BIT	8	/* Fixed parameter - do not change */
#define SERIAL_UBICOM_PAR_BIT	0	/* Fixed parameter - do not change */
#define SERIAL_UBICOM_STOP_BIT	1	/* Fixed parameter - do not change */

/* UART name and device definitions */
#define UBI32_SERDES_NAME	"ttyUS" // XXX
#define UBI32_SERDES_MAJOR	206 // XXX
#define UBI32_SERDES_MINOR	64 // XXX

#define PORT_UBI32_SERDES	1234
#define NR_PORTS 1

struct uart_port ubi32_serdes_ports[NR_PORTS];

struct ubi32_serdes_resource {
	void *uart_base_addr;
	int uart_irq;
	int uart_clock;
} ubi32_serdes_resource[NR_PORTS] = {
	/*
	 * Get params from kernel command line (required for early printk)
	 * or from platform resources.
	 */
	{0, 0, 0}
};

/*
 * Can get overridden by 'serdes=' kernel command line.
 */
static int ubi32_serdes_default_baud_rate = 115200;


#define IO_PORT(port) ((struct ubicom32_io_port *)port->membase)
#define IO_PORT_INT_STATUS(port) (IO_PORT(port)->int_status)
#define IO_PORT_INT_MASK(port) (IO_PORT(port)->int_mask)
#define IO_PORT_INT_CLR(port) (IO_PORT(port)->int_clr)


/*
 * ubi32_serdes_get_char()
 */
static u8_t ubi32_serdes_get_char(struct ubicom32_io_port *io_port)
{
	/*
	 * Read from hardware (forced 32-bit atomic read).
	 */
	u32_t data = 0;

	if ( io_port ) {
		io_port->int_clr = IO_PORTX_INT_SERDES_RXBF;
		asm volatile (
			"move.4		%0, %1		\n\t"
			: "=r" (data)
			: "m" (*(u32_t *)&(io_port->rx_fifo))
			);
	}

	return (u8_t)(data & 0x000000ff);
}

/*
 * ubi32_serdes_put_char()
 */
static void ubi32_serdes_put_char(struct ubicom32_io_port *io_port, u8_t c)
{
	u32_t data = 0x0000fe00 | (c << 1);

	if ( io_port ) {
		/*
		 * Fixed data format:
		 * [LSB]1 start bit - 8 data bits - no parity - 1 stop bit[MSB]
		 */
		io_port->int_clr = IO_PORTX_INT_SERDES_TXBE;
		io_port->ctl2 = data;
		io_port->int_set = IO_PORTX_INT_SERDES_TXBUF_VALID;
	}
}

static void ubi32_serdes_hw_init(struct uart_port *port, int baud)
{
	struct ubicom32_io_port *io_port = IO_PORT(port);

	if ( io_port ) {
		/*
		 * Put port functions 1-4 into reset state.
		 * Function 0 (GPIO) does not need or have a reset bit.
		 *
		 * Select SERDES function for restart below.
		 */
		io_port->function =
			IO_FUNC_FUNCTION_RESET(1) | IO_FUNC_FUNCTION_RESET(2) |
			IO_FUNC_FUNCTION_RESET(3) | IO_FUNC_FUNCTION_RESET(4) |
			IO_PORTX_FUNC_SERDES;

		/*
		 * Configure SERDES baudrate
		 */
		if ( baud == 0 ) {
			baud = ubi32_serdes_default_baud_rate;
		}

		io_port->ctl0 =
			SERIAL_UBICOM_CTL0 |
			((port->uartclk / (16 * baud)) - 1);

		io_port->ctl1 =
			SERIAL_UBICOM_CTL1;

		/*
		 * don't interrupt until startup and start_tx
		 */
		io_port->int_mask = 0;

		/*
		 * Set TXD pin output, RXD input and prevent GPIO
		 * override on the TXD & RXD pins
		 */
		io_port->gpio_ctl &= ~SERIAL_UBICOM_PIN_RXD;
		io_port->gpio_ctl |= SERIAL_UBICOM_PIN_TXD;
		io_port->gpio_mask &= ~(SERIAL_UBICOM_PIN_RXD | SERIAL_UBICOM_PIN_TXD);

		/*
		 * Restart (un-reset) the port's SERDES function.
		 */
		io_port->function &= ~(IO_FUNC_FUNCTION_RESET(IO_PORTX_FUNC_SERDES));
	}
}

#define ULITE_STATUS_RXVALID IO_PORTX_INT_SERDES_RXBF
#define ULITE_STATUS_OVERRUN 0
#define ULITE_STATUS_FRAME 0
#define ULITE_STATUS_PARITY 0
#define ULITE_STATUS_TXEMPTY IO_PORTX_INT_SERDES_TXBE
#define ULITE_STATUS_TXFULL 0

static int ubi32_serdes_receive(struct uart_port *port, int stat)
{
	struct tty_struct *tty = port->info->port.tty;
	unsigned char ch = 0;
	char flag = TTY_NORMAL;

	if ((stat & (ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN
		     | ULITE_STATUS_FRAME)) == 0)
		return 0;

	/* stats */
	if (stat & ULITE_STATUS_RXVALID) {
		port->icount.rx++;
		ch = ubi32_serdes_get_char((struct ubicom32_io_port *)port->membase);

		if (stat & ULITE_STATUS_PARITY)
			port->icount.parity++;
	}

	if (stat & ULITE_STATUS_OVERRUN)
		port->icount.overrun++;

	if (stat & ULITE_STATUS_FRAME)
		port->icount.frame++;


	/* drop byte with parity error if IGNPAR specificed */
	if (stat & port->ignore_status_mask & ULITE_STATUS_PARITY)
		stat &= ~ULITE_STATUS_RXVALID;

	stat &= port->read_status_mask;

	if (stat & ULITE_STATUS_PARITY)
		flag = TTY_PARITY;

	stat &= ~port->ignore_status_mask;

	if (stat & ULITE_STATUS_RXVALID)
		tty_insert_flip_char(tty, ch, flag);

	if (stat & ULITE_STATUS_FRAME)
		tty_insert_flip_char(tty, 0, TTY_FRAME);

	if (stat & ULITE_STATUS_OVERRUN)
		tty_insert_flip_char(tty, 0, TTY_OVERRUN);

	return 1;
}

/*
 * interrupts are disabled on entry
 */
static void ubi32_serdes_stop_tx(struct uart_port *port)
{
	IO_PORT_INT_MASK(port) = IO_PORT_INT_MASK(port) & ~IO_PORTX_INT_SERDES_TXBE;
}

static int ubi32_serdes_transmit(struct uart_port *port, int stat)
{
	struct circ_buf *xmit  = &port->info->xmit;

	if (!(stat & IO_PORTX_INT_SERDES_TXBE))
		return 0;

	if (port->x_char) {
		ubi32_serdes_put_char(IO_PORT(port), port->x_char);
		port->x_char = 0;
		port->icount.tx++;
		return 1;
	}

	if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
		ubi32_serdes_stop_tx(port);
		return 0;
	}

	ubi32_serdes_put_char(IO_PORT(port), xmit->buf[xmit->tail]);
	xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
	port->icount.tx++;

	/* wake up */
	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
		uart_write_wakeup(port);

	if (uart_circ_empty(xmit))
		ubi32_serdes_stop_tx(port);

	return 1;
}

/*
 * port is locked and interrupts are disabled
 */
static void ubi32_serdes_start_tx(struct uart_port *port)
{
	IO_PORT_INT_MASK(port) = IO_PORT_INT_MASK(port) | IO_PORTX_INT_SERDES_TXBE;
	ubi32_serdes_transmit(port, IO_PORT_INT_STATUS(port));
}

/*
 * Interrupts are enabled
 */
static void ubi32_serdes_stop_rx(struct uart_port *port)
{
	/* don't forward any more data (like !CREAD) */
	port->ignore_status_mask = IO_PORTX_INT_SERDES_RXBF;
}

/*
 * Set the modem control timer to fire immediately.
 */
static void ubi32_serdes_enable_ms(struct uart_port *port)
{
	/* N/A */
}

static irqreturn_t ubi32_serdes_isr(int irq, void *dev_id)
{
	struct uart_port *port = dev_id;
	int busy;

	spin_lock(&port->lock);

	do {
		int stat = IO_PORT_INT_STATUS(port);
		busy  = ubi32_serdes_receive(port, stat);
		busy |= ubi32_serdes_transmit(port, stat);
	} while (busy);

	tty_flip_buffer_push(port->info->port.tty);

	spin_unlock(&port->lock);

	return IRQ_HANDLED;
}

/*
 * Return TIOCSER_TEMT when transmitter is not busy.
 */
static unsigned int ubi32_serdes_tx_empty(struct uart_port *port)
{
	unsigned long flags;
	unsigned int ret;

	spin_lock_irqsave(&port->lock, flags);
	ret = IO_PORT_INT_STATUS(port);
	spin_unlock_irqrestore(&port->lock, flags);

	return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0;
}

static unsigned int ubi32_serdes_get_mctrl(struct uart_port *port)
{
	return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
}

static void ubi32_serdes_set_mctrl(struct uart_port *port, unsigned int mctrl)
{
	/* N/A */
}

/*
 * Interrupts are always disabled.
 */
static void ubi32_serdes_break_ctl(struct uart_port *port, int break_state)
{
	/* N/A */
}

static int ubi32_serdes_startup(struct uart_port *port)
{
	if (request_irq(port->irq, ubi32_serdes_isr, IRQF_DISABLED,
	     "UBI32_SERDES", port)) {
		printk(KERN_NOTICE "Unable to attach port interrupt\n");
		return -EBUSY;
	}

	IO_PORT_INT_CLR(port) = IO_PORTX_INT_SERDES_RXBF;
	IO_PORT_INT_MASK(port) = IO_PORTX_INT_SERDES_RXBF;
	return 0;
}

static void ubi32_serdes_shutdown(struct uart_port *port)
{
	struct ubi32_serdes_port *uart = (struct ubi32_serdes_port *)port;

	IO_PORT_INT_MASK(port) = 0;
	free_irq(port->irq, uart);
}

static void
ubi32_serdes_set_termios(struct uart_port *port, struct ktermios *termios,
		   struct ktermios *old)
{
	unsigned long flags;
	unsigned int baud;

	spin_lock_irqsave(&port->lock, flags);

	port->read_status_mask = ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN
		| ULITE_STATUS_TXFULL;

	if (termios->c_iflag & INPCK)
		port->read_status_mask |=
			ULITE_STATUS_PARITY | ULITE_STATUS_FRAME;

	port->ignore_status_mask = 0;
	if (termios->c_iflag & IGNPAR)
		port->ignore_status_mask |= ULITE_STATUS_PARITY
			| ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN;

	/* ignore all characters if CREAD is not set */
	if ((termios->c_cflag & CREAD) == 0)
		port->ignore_status_mask |=
			ULITE_STATUS_RXVALID | ULITE_STATUS_PARITY
			| ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN;

	/* update timeout */
	baud = uart_get_baud_rate(port, termios, old, 0, 460800);
	uart_update_timeout(port, termios->c_cflag, baud);

	IO_PORT(port)->ctl0 = SERIAL_UBICOM_CTL0 |
			((port->uartclk / (16 * baud)) - 1);

	spin_unlock_irqrestore(&port->lock, flags);
}

static const char *ubi32_serdes_type(struct uart_port *port)
{
	return port->type == PORT_UBI32_SERDES ? "UBI32_SERDES" : NULL;
}

/*
 * Release the memory region(s) being used by 'port'.
 */
static void ubi32_serdes_release_port(struct uart_port *port)
{
}

/*
 * Request the memory region(s) being used by 'port'.
 */
static int ubi32_serdes_request_port(struct uart_port *port)
{
	return 0;
}

/*
 * Configure/autoconfigure the port.
 */
static void ubi32_serdes_config_port(struct uart_port *port, int flags)
{
	if (flags & UART_CONFIG_TYPE &&
	    ubi32_serdes_request_port(port) == 0)
		port->type = PORT_UBI32_SERDES;
}

/*
 * Verify the new serial_struct (for TIOCSSERIAL).
 * The only change we allow are to the flags and type, and
 * even then only between PORT_UBI32_SERDES and PORT_UNKNOWN
 */
static int
ubi32_serdes_verify_port(struct uart_port *port, struct serial_struct *ser)
{
	return 0;
}

static struct uart_ops ubi32_serdes_pops = {
	.tx_empty	= ubi32_serdes_tx_empty,
	.set_mctrl	= ubi32_serdes_set_mctrl,
	.get_mctrl	= ubi32_serdes_get_mctrl,
	.stop_tx	= ubi32_serdes_stop_tx,
	.start_tx	= ubi32_serdes_start_tx,
	.stop_rx	= ubi32_serdes_stop_rx,
	.enable_ms	= ubi32_serdes_enable_ms,
	.break_ctl	= ubi32_serdes_break_ctl,
	.startup	= ubi32_serdes_startup,
	.shutdown	= ubi32_serdes_shutdown,
	.set_termios	= ubi32_serdes_set_termios,
	.type		= ubi32_serdes_type,
	.release_port	= ubi32_serdes_release_port,
	.request_port	= ubi32_serdes_request_port,
	.config_port	= ubi32_serdes_config_port,
	.verify_port	= ubi32_serdes_verify_port,
};

static void __init ubi32_serdes_init_ports(void)
{
	int i;

	for (i = 0; i < NR_PORTS; i++) {
		ubi32_serdes_ports[i].uartclk   = ubi32_serdes_resource[i].uart_clock;
		ubi32_serdes_ports[i].ops       = &ubi32_serdes_pops;
		ubi32_serdes_ports[i].line      = i;
		ubi32_serdes_ports[i].iotype    = UPIO_MEM;
		ubi32_serdes_ports[i].membase   =
			(void __iomem *)ubi32_serdes_resource[i].uart_base_addr;
		ubi32_serdes_ports[i].mapbase   =
			(resource_size_t)ubi32_serdes_resource[i].uart_base_addr;
		ubi32_serdes_ports[i].irq       =
			ubi32_serdes_resource[i].uart_irq;
		ubi32_serdes_ports[i].flags     = UPF_BOOT_AUTOCONF;

		ubi32_serdes_hw_init(&ubi32_serdes_ports[i], 0);
	}

}

#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
/*
 * If the port was already initialised (eg, by a boot loader),
 * try to determine the current setup.
 */
static void __init
ubi32_serdes_console_get_options(struct uart_port *port, int *baud)
{
	u32 round_to = 1200;
	u32 real_baud;

	/*
	 * We might get called before platform init and with no
	 * kernel command line options, so port might be NULL.
	 */
	*baud = ubi32_serdes_default_baud_rate;;
	if ( IO_PORT(port) == 0 )
		return;

	real_baud = port->uartclk
		/ (16 * ((IO_PORT(port)->ctl0 & ~SERIAL_UBICOM_CTL0) + 1));

	*baud = ((real_baud + round_to - 1) / round_to) * round_to;

	pr_debug("%s:baud = %d, real_baud = %d\n", __FUNCTION__, *baud, real_baud);
}
#endif

#if defined(CONFIG_SERIAL_UBI32_SERDES_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
static struct uart_driver ubi32_serdes_reg;

static int __init
ubi32_serdes_console_setup(struct console *co, char *options)
{
	struct uart_port *port;
#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
	int baud = ubi32_serdes_default_baud_rate;
	int bits = 8;
	int parity = 'n';
	int flow = 'n';
#endif

	/*
	 * Check whether an invalid uart number has been specified, and
	 * if so, search for the first available port that does have
	 * console support.
	 */
	if (co->index == -1 || co->index >= NR_PORTS)
		co->index = 0;
	port = &ubi32_serdes_ports[co->index];

#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
	if (options) {
		uart_parse_options(options, &baud, &parity, &bits, &flow);
		ubi32_serdes_hw_init(port, baud);
	}
	else
		ubi32_serdes_console_get_options(port, &baud);

	return uart_set_options(port, co, baud, parity, bits, flow);
#else
	return 0;
#endif
}
#endif /* defined (CONFIG_SERIAL_UBI32_SERDES_CONSOLE) ||
				 defined (CONFIG_EARLY_PRINTK) */

#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
static void
ubi32_serdes_console_putchar(struct uart_port *port, int ch)
{
	if ( IO_PORT(port) ) {
		while (!(IO_PORT_INT_STATUS(port) & IO_PORTX_INT_SERDES_TXBE))
			barrier();
		ubi32_serdes_put_char(IO_PORT(port), ch);
	}
}

/*
 * Interrupts are disabled on entering
 */
static void
ubi32_serdes_console_write(struct console *co, const char *s, unsigned int count)
{
	struct uart_port *port = &ubi32_serdes_ports[co->index];
	unsigned long flags = 0;

	spin_lock_irqsave(&port->lock, flags);
	uart_console_write(port, s, count, ubi32_serdes_console_putchar);
	spin_unlock_irqrestore(&port->lock, flags);

}

static struct console ubi32_serdes_console = {
	.name		= UBI32_SERDES_NAME,
	.write		= ubi32_serdes_console_write,
	.device		= uart_console_device,
	.setup		= ubi32_serdes_console_setup,
	.flags		= CON_PRINTBUFFER,
	.index		= -1,
	.data		= &ubi32_serdes_reg,
};

static int __init ubi32_serdes_console_init(void)
{
	ubi32_serdes_init_ports();
	register_console(&ubi32_serdes_console);
	return 0;
}
console_initcall(ubi32_serdes_console_init);

#define UBI32_SERDES_CONSOLE	&ubi32_serdes_console
#else
#define UBI32_SERDES_CONSOLE	NULL
#endif /* CONFIG_SERIAL_UBI32_SERDES_CONSOLE */


#ifdef CONFIG_EARLY_PRINTK
static __init void ubi32_serdes_early_putc(struct uart_port *port, int ch)
{
	unsigned timeout = 0xffff;

	while ((!(IO_PORT_INT_STATUS(port) & IO_PORTX_INT_SERDES_TXBE)) && --timeout)
		cpu_relax();
	ubi32_serdes_put_char(IO_PORT(port), ch);
}

static __init void ubi32_serdes_early_write(struct console *con, const char *s,
					unsigned int n)
{
	struct uart_port *port = &ubi32_serdes_ports[con->index];
	unsigned int i;

	for (i = 0; i < n; i++, s++) {
		if (*s == '\n')
			ubi32_serdes_early_putc(port, '\r');
		ubi32_serdes_early_putc(port, *s);
	}
}

static struct __init console ubi32_serdes_early_console = {
	.name = "early_US",
	.write = ubi32_serdes_early_write,
	.device = uart_console_device,
	.flags = CON_PRINTBUFFER,
	.setup = ubi32_serdes_console_setup,
	.index = -1,
	.data  = &ubi32_serdes_reg,
};

/*
 * XXX Unused in our driver. Need to find out what the termios initialization is good/needed for.
 */
struct console __init *ubi32_serdes_early_init(unsigned int port_index,
						unsigned int cflag)
{
	struct uart_port *uart;
	struct ktermios t;

	if (port_index == -1 || port_index >= NR_PORTS)
		port_index = 0;
	ubi32_serdes_init_ports();
	ubi32_serdes_early_console.index = port_index;
	uart = &ubi32_serdes_ports[port_index];
	t.c_cflag = cflag;
	t.c_iflag = 0;
	t.c_oflag = 0;
	t.c_lflag = ICANON;
	t.c_line = port_index;
	ubi32_serdes_set_termios(uart, &t, &t);
	return &ubi32_serdes_early_console;
}

#endif /* CONFIG_SERIAL_UBI32_SERDES_CONSOLE */

static struct uart_driver ubi32_serdes_reg = {
	.owner			= THIS_MODULE,
	.driver_name		= "ubi32_serdes",
	.dev_name		= UBI32_SERDES_NAME,
	.major			= UBI32_SERDES_MAJOR,
	.minor			= UBI32_SERDES_MINOR,
	.nr			= NR_PORTS,
	.cons			= UBI32_SERDES_CONSOLE,
};

static int ubi32_serdes_suspend(struct platform_device *dev, pm_message_t state)
{
	struct uart_port *port = platform_get_drvdata(dev);

	if (port)
		uart_suspend_port(&ubi32_serdes_reg, port);

	return 0;
}

static int ubi32_serdes_resume(struct platform_device *dev)
{
	struct uart_port *port = platform_get_drvdata(dev);

	if (port)
		uart_resume_port(&ubi32_serdes_reg, port);

	return 0;
}

static int ubi32_serdes_probe(struct platform_device *dev)
{
	struct resource *res = dev->resource;
	int i;

	for (i = 0; i < dev->num_resources; i++, res++) {
		if (res->flags & IORESOURCE_MEM) {
			ubi32_serdes_resource[0].uart_base_addr = (void *) res->start;
		}
		else if (res->flags & IORESOURCE_IRQ) {
			ubi32_serdes_resource[0].uart_irq = res->start;
		}
		else if (res->flags & UBICOM32_SUART_IORESOURCE_CLOCK) {
			ubi32_serdes_resource[0].uart_clock = res->start;
		}
	}

	ubi32_serdes_init_ports();

	return 0;
}

static int ubi32_serdes_remove(struct platform_device *pdev)
{
	struct uart_port *port = platform_get_drvdata(pdev);

	platform_set_drvdata(pdev, NULL);

	if (port)
		uart_remove_one_port(&ubi32_serdes_reg, port);

	return 0;
}

static struct platform_driver ubi32_serdes_driver = {
	.remove		= ubi32_serdes_remove,
	.suspend	= ubi32_serdes_suspend,
	.resume		= ubi32_serdes_resume,
	.driver		= {
		.name	= "ubicom32suart",
		.owner	= THIS_MODULE,
	},
};


#ifndef MODULE
/*
 * Called at boot time.
 *
 * You can specify IO base, IRQ, and clock for the serdes serial port
 * using kernel command line "serdes=0xiobase,irq,clock".  Values
 * specified will be overwritten by platform device data, if present.
 */
static int __init ubi32_serdes_setup(char *str)
{
#define N_PARMS   (4+1)
	int ints[N_PARMS];
	int i;

	str = get_options(str, ARRAY_SIZE(ints), ints);

	for (i = 0; i < N_PARMS; i++) {
		if (i < ints[0]) {
			if (i == 0) {
				ubi32_serdes_resource[0].uart_base_addr = (void *) ints[i+1];
			}
			else if (i == 1) {
				ubi32_serdes_resource[0].uart_irq = ints[i+1];
			}
			else if (i == 2) {
				ubi32_serdes_resource[0].uart_clock = ints[i+1];
			}
			else if (i == 3) {
				ubi32_serdes_default_baud_rate = ints[i+1];
			}
		}
	}
	return 1;
}

__setup("serdes=", ubi32_serdes_setup);
#endif

static int __init ubi32_serdes_init(void)
{
	int ret;

	pr_info("Serial: Ubicom32 serdes uart serial driver\n");

	ret = platform_driver_probe(&ubi32_serdes_driver, ubi32_serdes_probe);
	if (ret != 0) {
		printk(KERN_INFO "serdes platform_driver_probe() failed: %d\n", ret);
		return ret;
	}

	ubi32_serdes_init_ports();

	ret = uart_register_driver(&ubi32_serdes_reg);
	if ( ret == 0 ) {
		ret = uart_add_one_port(&ubi32_serdes_reg, &ubi32_serdes_ports[0]);
		if ( ret != 0 ) {
			uart_unregister_driver(&ubi32_serdes_reg);
		}
	}

	return ret;
}

static void __exit ubi32_serdes_exit(void)
{
	platform_driver_unregister(&ubi32_serdes_driver);
	uart_unregister_driver(&ubi32_serdes_reg);
}

module_init(ubi32_serdes_init);
module_exit(ubi32_serdes_exit);

MODULE_AUTHOR("Rainer Keller <rkeller@ubicom.com>");
MODULE_DESCRIPTION("Ubicom generic serial port driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS_CHARDEV_MAJOR(UBI32_SERDES_MAJOR);
MODULE_ALIAS("platform:ubi32_serdes");