satip-axe/kernel/drivers/serial/stm-asc.c
2015-03-26 17:24:57 +01:00

1059 lines
25 KiB
C

/*
* drivers/serial/stasc.c
* Asynchronous serial controller (ASC) driver
*/
#if defined(CONFIG_SERIAL_STM_ASC_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
#define SUPPORT_SYSRQ
#endif
#include <linux/module.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/uaccess.h>
#include <linux/bitops.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/sysrq.h>
#include <linux/serial.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/console.h>
#include <linux/gpio.h>
#include <linux/generic_serial.h>
#include <linux/spinlock.h>
#include <linux/pm_runtime.h>
#include <linux/platform_device.h>
#include <linux/stm/platform.h>
#include <linux/clk.h>
#ifdef CONFIG_SH_STANDARD_BIOS
#include <asm/sh_bios.h>
#endif
#include "stm-asc.h"
#define DRIVER_NAME "stm-asc"
#ifdef CONFIG_SERIAL_STM_ASC_CONSOLE
static struct console asc_console;
#endif
struct asc_port asc_ports[ASC_MAX_PORTS];
/*---- Forward function declarations---------------------------*/
static int asc_request_irq(struct uart_port *);
static void asc_free_irq(struct uart_port *);
static void asc_transmit_chars(struct uart_port *);
static int asc_remap_port(struct asc_port *ascport, int req);
static int asc_set_baud(struct uart_port *port, int baud,
unsigned long clkrate);
void asc_set_termios_cflag(struct asc_port *, int, int);
static inline void asc_receive_chars(struct uart_port *);
#ifdef CONFIG_SERIAL_STM_ASC_CONSOLE
static void asc_console_write(struct console *, const char *, unsigned);
static int __init asc_console_setup(struct console *, char *);
#endif
/*---- Inline function definitions ---------------------------*/
/* Some simple utility functions to enable and disable interrupts.
* Note that these need to be called with interrupts disabled.
*/
static inline void asc_disable_tx_interrupts(struct uart_port *port)
{
unsigned long intenable;
/* Clear TE (Transmitter empty) interrupt enable in INTEN */
intenable = asc_in(port, INTEN);
intenable &= ~ASC_INTEN_THE;
asc_out(port, INTEN, intenable);
}
static inline void asc_enable_tx_interrupts(struct uart_port *port)
{
unsigned long intenable;
/* Set TE (Transmitter empty) interrupt enable in INTEN */
intenable = asc_in(port, INTEN);
intenable |= ASC_INTEN_THE;
asc_out(port, INTEN, intenable);
}
static inline void asc_disable_rx_interrupts(struct uart_port *port)
{
unsigned long intenable;
/* Clear RBE (Receive Buffer Full Interrupt Enable) bit in INTEN */
intenable = asc_in(port, INTEN);
intenable &= ~ASC_INTEN_RBE;
asc_out(port, INTEN, intenable);
}
static inline void asc_enable_rx_interrupts(struct uart_port *port)
{
unsigned long intenable;
/* Set RBE (Receive Buffer Full Interrupt Enable) bit in INTEN */
intenable = asc_in(port, INTEN);
intenable |= ASC_INTEN_RBE;
asc_out(port, INTEN, intenable);
}
/*----------------------------------------------------------------------*/
/*
* UART Functions
*/
static unsigned int asc_tx_empty(struct uart_port *port)
{
unsigned long status;
status = asc_in(port, STA);
if (status & ASC_STA_TE)
return TIOCSER_TEMT;
return 0;
}
static void asc_set_mctrl(struct uart_port *port, unsigned int mctrl)
{
/* This routine is used for seting signals of: DTR, DCD, CTS/RTS
* We use ASC's hardware for CTS/RTS, so don't need any for that.
* Some boards have DTR and DCD implemented using PIO pins,
* code to do this should be hooked in here.
*/
}
static unsigned int asc_get_mctrl(struct uart_port *port)
{
/* This routine is used for geting signals of: DTR, DCD, DSR, RI,
and CTS/RTS */
return TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
}
/*
* There are probably characters waiting to be transmitted.
* Start doing so.
* The port lock is held and interrupts are disabled.
*/
static void asc_start_tx(struct uart_port *port)
{
if (asc_fdma_enabled(port))
asc_fdma_tx_start(port);
else {
struct circ_buf *xmit = &port->state->xmit;
asc_transmit_chars(port);
if (!uart_circ_empty(xmit))
asc_enable_tx_interrupts(port);
}
}
/*
* Transmit stop - interrupts disabled on entry
*/
static void asc_stop_tx(struct uart_port *port)
{
if (asc_fdma_enabled(port))
asc_fdma_tx_stop(port);
else
asc_disable_tx_interrupts(port);
}
/*
* Receive stop - interrupts still enabled on entry
*/
static void asc_stop_rx(struct uart_port *port)
{
if (asc_fdma_enabled(port))
asc_fdma_rx_stop(port);
else
asc_disable_rx_interrupts(port);
}
/*
* Force modem status interrupts on - no-op for us
*/
static void asc_enable_ms(struct uart_port *port)
{
/* Nothing here yet .. */
}
/*
* Handle breaks - ignored by us
*/
static void asc_break_ctl(struct uart_port *port, int break_state)
{
/* Nothing here yet .. */
}
/*
* Enable port for reception.
* port_sem held and interrupts disabled
*/
static int asc_startup(struct uart_port *port)
{
asc_request_irq(port);
asc_fdma_startup(port);
asc_transmit_chars(port);
asc_enable_rx_interrupts(port);
return 0;
}
static void asc_shutdown(struct uart_port *port)
{
asc_disable_tx_interrupts(port);
asc_disable_rx_interrupts(port);
asc_fdma_shutdown(port);
asc_free_irq(port);
}
static void asc_set_termios(struct uart_port *port, struct ktermios *termios,
struct ktermios *old)
{
struct asc_port *ascport = container_of(port, struct asc_port, port);
unsigned int baud;
baud = uart_get_baud_rate(port, termios, old, 0,
port->uartclk/16);
asc_set_termios_cflag(ascport, termios->c_cflag, baud);
}
static const char *asc_type(struct uart_port *port)
{
struct platform_device *pdev = to_platform_device(port->dev);
return pdev->name;
}
static void asc_release_port(struct uart_port *port)
{
struct asc_port *ascport = container_of(port, struct asc_port, port);
struct platform_device *pdev = to_platform_device(port->dev);
int size = pdev->resource[0].end - pdev->resource[0].start + 1;
release_mem_region(port->mapbase, size);
if (port->flags & UPF_IOREMAP) {
iounmap(port->membase);
port->membase = NULL;
}
if (ascport->pad_state) {
stm_pad_release(ascport->pad_state);
ascport->pad_state = NULL;
}
}
static int asc_request_port(struct uart_port *port)
{
struct asc_port *ascport = container_of(port, struct asc_port, port);
return asc_remap_port(ascport, 1);
}
/* Called when the port is opened, and UPF_BOOT_AUTOCONF flag is set */
/* Set type field if successful */
static void asc_config_port(struct uart_port *port, int flags)
{
if ((flags & UART_CONFIG_TYPE) &&
(asc_request_port(port) == 0))
port->type = PORT_ASC;
}
static int
asc_verify_port(struct uart_port *port, struct serial_struct *ser)
{
/* No user changeable parameters */
return -EINVAL;
}
/*---------------------------------------------------------------------*/
static struct uart_ops asc_uart_ops = {
.tx_empty = asc_tx_empty,
.set_mctrl = asc_set_mctrl,
.get_mctrl = asc_get_mctrl,
.start_tx = asc_start_tx,
.stop_tx = asc_stop_tx,
.stop_rx = asc_stop_rx,
.enable_ms = asc_enable_ms,
.break_ctl = asc_break_ctl,
.startup = asc_startup,
.shutdown = asc_shutdown,
.set_termios = asc_set_termios,
.type = asc_type,
.release_port = asc_release_port,
.request_port = asc_request_port,
.config_port = asc_config_port,
.verify_port = asc_verify_port,
};
static void __devinit asc_init_port(struct asc_port *ascport,
struct platform_device *pdev)
{
struct uart_port *port = &ascport->port;
struct stm_plat_asc_data *plat_data = pdev->dev.platform_data;
port->iotype = UPIO_MEM;
port->flags = UPF_BOOT_AUTOCONF;
port->ops = &asc_uart_ops;
port->fifosize = FIFO_SIZE;
port->line = pdev->id;
port->dev = &pdev->dev;
port->mapbase = pdev->resource[0].start;
port->irq = pdev->resource[1].start;
spin_lock_init(&port->lock);
#ifdef CONFIG_SERIAL_STM_ASC_FDMA
ascport->fdma.rx_req_id = pdev->resource[2].start;
ascport->fdma.tx_req_id = pdev->resource[3].start;
#endif
/* Assume that we can always use ioremap */
port->flags |= UPF_IOREMAP;
port->membase = NULL;
ascport->clk = clk_get(&pdev->dev, "comms_clk");
if (IS_ERR(ascport->clk))
return;
clk_enable(ascport->clk);
WARN_ON(clk_get_rate(ascport->clk) == 0); /* It won't work at all */
ascport->port.uartclk = clk_get_rate(ascport->clk);
ascport->pad_config = plat_data->pad_config;
ascport->hw_flow_control = plat_data->hw_flow_control;
ascport->txfifo_bug = plat_data->txfifo_bug;
}
static struct uart_driver asc_uart_driver = {
.owner = THIS_MODULE,
.driver_name = DRIVER_NAME,
.dev_name = "ttyAS",
.major = ASC_MAJOR,
.minor = ASC_MINOR_START,
.nr = ASC_MAX_PORTS,
#ifdef CONFIG_SERIAL_STM_ASC_CONSOLE
.cons = &asc_console,
#endif
};
#ifdef CONFIG_SERIAL_STM_ASC_CONSOLE
static struct console asc_console = {
.name = "ttyAS",
.device = uart_console_device,
.write = asc_console_write,
.setup = asc_console_setup,
.flags = CON_PRINTBUFFER,
.index = -1,
.data = &asc_uart_driver,
};
static void __init asc_init_ports(void)
{
int i;
for (i = 0; i < stm_asc_configured_devices_num; i++)
asc_init_port(&asc_ports[i], stm_asc_configured_devices[i]);
}
/*
* Early console initialization.
*/
static int __init asc_console_init(void)
{
if (!stm_asc_configured_devices_num)
return 0;
asc_init_ports();
register_console(&asc_console);
if (stm_asc_console_device != -1)
add_preferred_console("ttyAS", stm_asc_console_device, NULL);
return 0;
}
console_initcall(asc_console_init);
/*
* Late console initialization.
*/
static int __init asc_late_console_init(void)
{
if (!(asc_console.flags & CON_ENABLED))
register_console(&asc_console);
return 0;
}
core_initcall(asc_late_console_init);
#endif
static int __devinit asc_serial_probe(struct platform_device *pdev)
{
int ret;
struct asc_port *ascport = &asc_ports[pdev->id];
asc_init_port(ascport, pdev);
ret = uart_add_one_port(&asc_uart_driver, &ascport->port);
if (ret == 0) {
platform_set_drvdata(pdev, &ascport->port);
/* set can_wakeup*/
device_set_wakeup_capable(&pdev->dev, 1);
/* enable the wakeup on console */
device_set_wakeup_enable(&pdev->dev, 1);
enable_irq_wake(pdev->resource[1].start);
pm_runtime_set_active(&pdev->dev);
pm_suspend_ignore_children(&pdev->dev, 1);
pm_runtime_enable(&pdev->dev);
}
return ret;
}
static int __devexit asc_serial_remove(struct platform_device *pdev)
{
struct uart_port *port = platform_get_drvdata(pdev);
platform_set_drvdata(pdev, NULL);
return uart_remove_one_port(&asc_uart_driver, port);
}
#ifdef CONFIG_PM
static int asc_serial_suspend(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct asc_port *ascport = &asc_ports[pdev->id];
struct uart_port *port = &(ascport->port);
unsigned long flags;
local_irq_save(flags);
mdelay(10);
ascport->pm_ctrl = asc_in(port, CTL);
ascport->pm_irq = asc_in(port, INTEN);
/* disable the FIFO to resume on a first button */
asc_out(port, CTL, ascport->pm_ctrl & ~ASC_CTL_FIFOENABLE);
if (device_can_wakeup(dev)) {
if (!console_suspend_enabled)
goto ret_asc_suspend;
ascport->suspended = 1;
asc_disable_tx_interrupts(port);
goto ret_asc_suspend;
}
ascport->suspended = 1;
asc_disable_tx_interrupts(port);
asc_disable_rx_interrupts(port);
clk_disable(ascport->clk);
ret_asc_suspend:
local_irq_restore(flags);
return 0;
}
static int asc_serial_resume(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct asc_port *ascport = &asc_ports[pdev->id];
struct uart_port *port = &(ascport->port);
unsigned long flags;
if (!device_can_wakeup(dev))
clk_enable(ascport->clk);
local_irq_save(flags);
asc_out(port, CTL, ascport->pm_ctrl);
asc_out(port, TIMEOUT, 20); /* hardcoded */
asc_out(port, INTEN, ascport->pm_irq);
asc_set_baud(port, ascport->pm_baud, clk_get_rate(ascport->clk));
ascport->suspended = 0;
local_irq_restore(flags);
return 0;
}
static int asc_serial_freeze(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct asc_port *ascport = &asc_ports[pdev->id];
struct uart_port *port = &(ascport->port);
ascport->pm_ctrl = asc_in(port, CTL);
ascport->pm_irq = asc_in(port, INTEN);
clk_disable(ascport->clk);
return 0;
}
static int asc_serial_restore(struct device *dev)
{
struct platform_device *pdev = to_platform_device(dev);
struct asc_port *ascport = &asc_ports[pdev->id];
struct uart_port *port = &(ascport->port);
clk_enable(ascport->clk);
/* program the port but do not enable it */
asc_out(port, CTL, ascport->pm_ctrl & ~ASC_CTL_RUN);
asc_out(port, TIMEOUT, 20); /* hardcoded */
asc_out(port, INTEN, ascport->pm_irq);
asc_set_baud(port, ascport->pm_baud, clk_get_rate(ascport->clk));
/* reset fifo rx & tx */
asc_out(port, TXRESET, 1);
asc_out(port, RXRESET, 1);
/* write final value and enable port */
asc_out(port, CTL, ascport->pm_ctrl);
return 0;
}
static struct dev_pm_ops asc_serial_pm_ops = {
.suspend = asc_serial_suspend, /* on standby/memstandby */
.resume = asc_serial_resume, /* resume from standby/memstandby */
.freeze = asc_serial_freeze, /* hibernation */
.restore = asc_serial_restore, /* resume from hibernation */
.runtime_suspend = asc_serial_suspend,
.runtime_resume = asc_serial_resume,
};
#else
static struct dev_pm_ops asc_serial_pm_ops;
#endif
static struct platform_driver asc_serial_driver = {
.probe = asc_serial_probe,
.remove = __devexit_p(asc_serial_remove),
.driver = {
.name = DRIVER_NAME,
.pm = &asc_serial_pm_ops,
.owner = THIS_MODULE,
},
};
static int __init asc_init(void)
{
int ret;
static char banner[] __initdata =
KERN_INFO "STMicroelectronics ASC driver initialized\n";
printk(banner);
ret = uart_register_driver(&asc_uart_driver);
if (ret)
return ret;
ret = platform_driver_register(&asc_serial_driver);
if (ret)
uart_unregister_driver(&asc_uart_driver);
return ret;
}
static void __exit asc_exit(void)
{
platform_driver_unregister(&asc_serial_driver);
uart_unregister_driver(&asc_uart_driver);
}
module_init(asc_init);
module_exit(asc_exit);
MODULE_AUTHOR("Stuart Menefy <stuart.menefy@st.com>");
MODULE_DESCRIPTION("STMicroelectronics ASC serial port driver");
MODULE_LICENSE("GPL");
/*----------------------------------------------------------------------*/
/* This sections contains code to support the use of the ASC as a
* generic serial port.
*/
static int asc_remap_port(struct asc_port *ascport, int req)
{
struct uart_port *port = &ascport->port;
struct platform_device *pdev = to_platform_device(port->dev);
int size = pdev->resource[0].end - pdev->resource[0].start + 1;
if (!ascport->pad_state) {
/* Can't use dev_name() here as we can be called early */
ascport->pad_state = stm_pad_claim(ascport->pad_config,
"stasc");
if (!ascport->pad_state)
return -EBUSY;
}
if (req && !request_mem_region(port->mapbase, size, pdev->name))
return -EBUSY;
/* We have already been remapped for the console */
if (port->membase)
return 0;
if (port->flags & UPF_IOREMAP) {
port->membase = ioremap(port->mapbase, size);
if (port->membase == NULL) {
release_mem_region(port->mapbase, size);
return -ENOMEM;
}
}
return 0;
}
static int asc_set_baud(struct uart_port *port, int baud, unsigned long rate)
{
unsigned int t;
if (baud < 19200) {
t = BAUDRATE_VAL_M0(baud, rate);
asc_out(port, BAUDRATE, t);
return 0;
} else {
t = BAUDRATE_VAL_M1(baud, rate);
asc_out(port, BAUDRATE, t);
return ASC_CTL_BAUDMODE;
}
}
void asc_set_termios_cflag(struct asc_port *ascport, int cflag, int baud)
{
struct uart_port *port = &ascport->port;
unsigned int ctrl_val;
unsigned long flags;
spin_lock_irqsave(&port->lock, flags);
/* read control register */
ctrl_val = asc_in(port, CTL);
/* stop serial port and reset value */
asc_out(port, CTL, (ctrl_val & ~ASC_CTL_RUN));
ctrl_val = ASC_CTL_RXENABLE | ASC_CTL_FIFOENABLE;
/* reset fifo rx & tx */
asc_out(port, TXRESET, 1);
asc_out(port, RXRESET, 1);
/* set character length */
if ((cflag & CSIZE) == CS7)
ctrl_val |= ASC_CTL_MODE_7BIT_PAR;
else {
if (cflag & PARENB)
ctrl_val |= ASC_CTL_MODE_8BIT_PAR;
else
ctrl_val |= ASC_CTL_MODE_8BIT;
}
ascport->check_parity = (cflag & PARENB) ? 1 : 0;
/* set stop bit */
if (cflag & CSTOPB)
ctrl_val |= ASC_CTL_STOP_2BIT;
else
ctrl_val |= ASC_CTL_STOP_1BIT;
/* odd parity */
if (cflag & PARODD)
ctrl_val |= ASC_CTL_PARITYODD;
/* hardware flow control */
if ((cflag & CRTSCTS) && ascport->hw_flow_control)
ctrl_val |= ASC_CTL_CTSENABLE;
/* set speed and baud generator mode */
#ifdef CONFIG_PM
ascport->pm_baud = baud; /* save the latest baudrate request */
#endif
ctrl_val |= asc_set_baud(port, baud, clk_get_rate(ascport->clk));
uart_update_timeout(port, cflag, baud);
/* Undocumented feature: use max possible baud */
if (cflag & 0020000)
asc_out(port, BAUDRATE, 0x0000ffff);
/* Undocumented feature: FDMA "acceleration" */
if ((cflag & 0040000) && !asc_fdma_enabled(port)) {
/* TODO: check parameters if suitable for FDMA transmission */
asc_disable_tx_interrupts(port);
asc_disable_rx_interrupts(port);
if (asc_fdma_enable(port) != 0) {
asc_enable_rx_interrupts(port);
asc_enable_tx_interrupts(port);
}
} else if (!(cflag & 0040000) && asc_fdma_enabled(port)) {
asc_fdma_disable(port);
asc_enable_rx_interrupts(port);
asc_enable_tx_interrupts(port);
}
/* Undocumented feature: use local loopback */
if (cflag & 0100000)
ctrl_val |= ASC_CTL_LOOPBACK;
else
ctrl_val &= ~ASC_CTL_LOOPBACK;
/* Set the timeout */
asc_out(port, TIMEOUT, 20);
/* write final value and enable port */
asc_out(port, CTL, (ctrl_val | ASC_CTL_RUN));
spin_unlock_irqrestore(&port->lock, flags);
}
static inline unsigned asc_hw_txroom(struct uart_port *port)
{
unsigned long status;
struct asc_port *ascport = container_of(port, struct asc_port, port);
status = asc_in(port, STA);
if (ascport->txfifo_bug) {
if (status & ASC_STA_THE)
return (FIFO_SIZE / 2) - 1;
} else {
if (status & ASC_STA_THE)
return FIFO_SIZE / 2;
else if (!(status & ASC_STA_TF))
return 1;
}
return 0;
}
/*
* Start transmitting chars.
* This is called from both interrupt and task level.
* Either way interrupts are disabled.
*/
static void asc_transmit_chars(struct uart_port *port)
{
struct circ_buf *xmit = &port->state->xmit;
int txroom;
unsigned char c;
txroom = asc_hw_txroom(port);
if ((txroom != 0) && port->x_char) {
c = port->x_char;
port->x_char = 0;
asc_out(port, TXBUF, c);
port->icount.tx++;
txroom = asc_hw_txroom(port);
}
if (uart_tx_stopped(port)) {
/*
* We should try and stop the hardware here, but I
* don't think the ASC has any way to do that.
*/
asc_disable_tx_interrupts(port);
return;
}
if (uart_circ_empty(xmit)) {
asc_disable_tx_interrupts(port);
return;
}
if (txroom == 0)
return;
do {
c = xmit->buf[xmit->tail];
xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
asc_out(port, TXBUF, c);
port->icount.tx++;
txroom--;
} while ((txroom > 0) && (!uart_circ_empty(xmit)));
if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
uart_write_wakeup(port);
if (uart_circ_empty(xmit))
asc_disable_tx_interrupts(port);
}
static inline void asc_receive_chars(struct uart_port *port)
{
int count;
struct asc_port *ascport = container_of(port, struct asc_port, port);
struct tty_struct *tty = port->state->port.tty;
int copied = 0;
unsigned long status;
unsigned long c = 0;
char flag;
int overrun;
while (1) {
status = asc_in(port, STA);
if (status & ASC_STA_RHF) {
count = FIFO_SIZE / 2;
} else if (status & ASC_STA_RBF) {
count = 1;
} else {
break;
}
/* Check for overrun before reading any data from the
* RX FIFO, as this clears the overflow error condition. */
overrun = status & ASC_STA_OE;
for (; count != 0; count--) {
c = asc_in(port, RXBUF);
flag = TTY_NORMAL;
port->icount.rx++;
if (unlikely(c & ASC_RXBUF_FE)) {
if (c == ASC_RXBUF_FE) {
port->icount.brk++;
if (uart_handle_break(port))
continue;
flag = TTY_BREAK;
} else {
port->icount.frame++;
flag = TTY_FRAME;
}
} else if (ascport->check_parity &&
unlikely(c & ASC_RXBUF_PE)) {
port->icount.parity++;
flag = TTY_PARITY;
}
if (uart_handle_sysrq_char(port, c))
continue;
tty_insert_flip_char(tty, c & 0xff, flag);
}
if (overrun) {
port->icount.overrun++;
tty_insert_flip_char(tty, 0, TTY_OVERRUN);
}
copied = 1;
}
if (copied) {
/* Tell the rest of the system the news. New characters! */
tty_flip_buffer_push(tty);
}
}
static irqreturn_t asc_interrupt(int irq, void *ptr)
{
struct uart_port *port = ptr;
unsigned long status;
spin_lock(&port->lock);
status = asc_in(port, STA);
if (asc_fdma_enabled(port)) {
/* FDMA transmission, only timeout-not-empty
* interrupt shall be enabled */
if (likely(status & ASC_STA_TNE))
asc_fdma_rx_timeout(port);
else
printk(KERN_ERR"Unknown ASC interrupt for port %p!"
"(ASC_STA = %08x)\n", port, asc_in(port, STA));
} else {
if (status & ASC_STA_RBF) {
/* Receive FIFO not empty */
asc_receive_chars(port);
}
if ((status & ASC_STA_THE) &&
(asc_in(port, INTEN) & ASC_INTEN_THE)) {
/* Transmitter FIFO at least half empty */
asc_transmit_chars(port);
}
}
spin_unlock(&port->lock);
return IRQ_HANDLED;
}
static int asc_request_irq(struct uart_port *port)
{
struct platform_device *pdev = to_platform_device(port->dev);
if (request_irq(port->irq, asc_interrupt, 0,
pdev->name, port)) {
printk(KERN_ERR "stasc: cannot allocate irq.\n");
return -ENODEV;
}
return 0;
}
static void asc_free_irq(struct uart_port *port)
{
free_irq(port->irq, port);
}
/*----------------------------------------------------------------------*/
#if defined(CONFIG_SH_STANDARD_BIOS)
static int get_char(struct uart_port *port)
{
int c;
unsigned long status;
do {
status = asc_in(port, STA);
} while (!(status & ASC_STA_RBF));
c = asc_in(port, RXBUF);
return c;
}
/* Taken from sh-stub.c of GDB 4.18 */
static const char hexchars[] = "0123456789abcdef";
static __inline__ char highhex(int x)
{
return hexchars[(x >> 4) & 0xf];
}
static __inline__ char lowhex(int x)
{
return hexchars[x & 0xf];
}
#endif
#ifdef CONFIG_SERIAL_STM_ASC_CONSOLE
static int asc_txfifo_is_full(struct asc_port *ascport, unsigned long status)
{
if (ascport->txfifo_bug)
return !(status & ASC_STA_THE);
return status & ASC_STA_TF;
}
static void put_char(struct uart_port *port, char c)
{
unsigned long flags;
unsigned long status;
struct asc_port *ascport = container_of(port, struct asc_port, port);
if (ascport->suspended)
return;
try_again:
do {
status = asc_in(port, STA);
} while (asc_txfifo_is_full(ascport, status));
spin_lock_irqsave(&port->lock, flags);
status = asc_in(port, STA);
if (asc_txfifo_is_full(ascport, status)) {
spin_unlock_irqrestore(&port->lock, flags);
goto try_again;
}
asc_out(port, TXBUF, c);
spin_unlock_irqrestore(&port->lock, flags);
}
/*
* Send the packet in buffer. The host gets one chance to read it.
* This routine does not wait for a positive acknowledge.
*/
static void put_string(struct uart_port *port, const char *buffer, int count)
{
int i;
const unsigned char *p = buffer;
#if defined(CONFIG_SH_STANDARD_BIOS)
int checksum;
int usegdb = 0;
/* This call only does a trap the first time it is
* called, and so is safe to do here unconditionally */
usegdb |= sh_bios_in_gdb_mode();
if (usegdb) {
/* $<packet info>#<checksum>. */
do {
unsigned char c;
put_char(port, '$');
put_char(port, 'O'); /* 'O'utput to console */
checksum = 'O';
/* Don't use run length encoding */
for (i = 0; i < count; i++) {
int h, l;
c = *p++;
h = highhex(c);
l = lowhex(c);
put_char(port, h);
put_char(port, l);
checksum += h + l;
}
put_char(port, '#');
put_char(port, highhex(checksum));
put_char(port, lowhex(checksum));
} while (get_char(port) != '+');
} else
#endif /* CONFIG_SH_STANDARD_BIOS */
for (i = 0; i < count; i++) {
if (*p == 10)
put_char(port, '\r');
put_char(port, *p++);
}
}
/*----------------------------------------------------------------------*/
/*
* Setup initial baud/bits/parity. We do two things here:
* - construct a cflag setting for the first rs_open()
* - initialize the serial port
* Return non-zero if we didn't find a serial port.
*/
static int __init asc_console_setup(struct console *co, char *options)
{
struct asc_port *ascport;
int baud = 9600;
int bits = 8;
int parity = 'n';
int flow = 'n';
int ret;
if (co->index >= ASC_MAX_PORTS)
co->index = 0;
ascport = &asc_ports[co->index];
if ((ascport->port.mapbase == 0))
return -ENODEV;
ret = asc_remap_port(ascport, 0);
if (ret != 0)
return ret;
if (options)
uart_parse_options(options, &baud, &parity, &bits, &flow);
return uart_set_options(&ascport->port, co, baud, parity, bits, flow);
}
/*
* Print a string to the serial port trying not to disturb
* any possible real use of the port...
*/
static void asc_console_write(struct console *co, const char *s, unsigned count)
{
struct uart_port *port = &asc_ports[co->index].port;
put_string(port, s, count);
}
#endif /* CONFIG_SERIAL_STM_ASC_CONSOLE */