mirror of
git://projects.qi-hardware.com/openwrt-xburst.git
synced 2024-12-22 17:38:58 +02:00
1a29ef8e97
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@19815 3c298f89-4303-0410-b956-a3cf2f4a3e73
818 lines
20 KiB
C
818 lines
20 KiB
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");
|