2017-11-06 17:11:51 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2009-06-11 13:05:39 +00:00
|
|
|
/*
|
|
|
|
* timbuart.c timberdale FPGA UART driver
|
|
|
|
* Copyright (c) 2009 Intel Corporation
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Supports:
|
|
|
|
* Timberdale FPGA UART
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/serial_core.h>
|
2011-09-01 14:20:57 +00:00
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/tty_flip.h>
|
2009-06-11 13:05:39 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/ioport.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-05-27 20:14:23 +00:00
|
|
|
#include <linux/module.h>
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
#include "timbuart.h"
|
|
|
|
|
|
|
|
struct timbuart_port {
|
|
|
|
struct uart_port port;
|
|
|
|
struct tasklet_struct tasklet;
|
|
|
|
int usedma;
|
2009-06-22 17:43:03 +00:00
|
|
|
u32 last_ier;
|
2009-06-11 13:05:39 +00:00
|
|
|
struct platform_device *dev;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int baudrates[] = {9600, 19200, 38400, 57600, 115200, 230400, 460800,
|
|
|
|
921600, 1843200, 3250000};
|
|
|
|
|
2009-06-22 17:43:03 +00:00
|
|
|
static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier);
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
static irqreturn_t timbuart_handleinterrupt(int irq, void *devid);
|
|
|
|
|
|
|
|
static void timbuart_stop_rx(struct uart_port *port)
|
|
|
|
{
|
|
|
|
/* spin lock held by upper layer, disable all RX interrupts */
|
2009-06-22 17:43:03 +00:00
|
|
|
u32 ier = ioread32(port->membase + TIMBUART_IER) & ~RXFLAGS;
|
|
|
|
iowrite32(ier, port->membase + TIMBUART_IER);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_stop_tx(struct uart_port *port)
|
|
|
|
{
|
|
|
|
/* spinlock held by upper layer, disable TX interrupt */
|
2009-06-22 17:43:03 +00:00
|
|
|
u32 ier = ioread32(port->membase + TIMBUART_IER) & ~TXBAE;
|
|
|
|
iowrite32(ier, port->membase + TIMBUART_IER);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_start_tx(struct uart_port *port)
|
|
|
|
{
|
|
|
|
struct timbuart_port *uart =
|
|
|
|
container_of(port, struct timbuart_port, port);
|
|
|
|
|
|
|
|
/* do not transfer anything here -> fire off the tasklet */
|
|
|
|
tasklet_schedule(&uart->tasklet);
|
|
|
|
}
|
|
|
|
|
2010-04-27 21:16:34 +00:00
|
|
|
static unsigned int timbuart_tx_empty(struct uart_port *port)
|
|
|
|
{
|
|
|
|
u32 isr = ioread32(port->membase + TIMBUART_ISR);
|
|
|
|
|
|
|
|
return (isr & TXBE) ? TIOCSER_TEMT : 0;
|
|
|
|
}
|
|
|
|
|
2009-06-11 13:05:39 +00:00
|
|
|
static void timbuart_flush_buffer(struct uart_port *port)
|
|
|
|
{
|
2010-04-27 21:16:34 +00:00
|
|
|
if (!timbuart_tx_empty(port)) {
|
|
|
|
u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |
|
|
|
|
TIMBUART_CTRL_FLSHTX;
|
2009-06-11 13:05:39 +00:00
|
|
|
|
2010-04-27 21:16:34 +00:00
|
|
|
iowrite8(ctl, port->membase + TIMBUART_CTRL);
|
|
|
|
iowrite32(TXBF, port->membase + TIMBUART_ISR);
|
|
|
|
}
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_rx_chars(struct uart_port *port)
|
|
|
|
{
|
2013-01-03 14:53:03 +00:00
|
|
|
struct tty_port *tport = &port->state->port;
|
2009-06-11 13:05:39 +00:00
|
|
|
|
2009-06-22 17:43:03 +00:00
|
|
|
while (ioread32(port->membase + TIMBUART_ISR) & RXDP) {
|
2009-06-11 13:05:39 +00:00
|
|
|
u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);
|
|
|
|
port->icount.rx++;
|
2013-01-03 14:53:03 +00:00
|
|
|
tty_insert_flip_char(tport, ch, TTY_NORMAL);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&port->lock);
|
2013-01-03 14:53:06 +00:00
|
|
|
tty_flip_buffer_push(tport);
|
2009-06-11 13:05:39 +00:00
|
|
|
spin_lock(&port->lock);
|
|
|
|
|
|
|
|
dev_dbg(port->dev, "%s - total read %d bytes\n",
|
|
|
|
__func__, port->icount.rx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_tx_chars(struct uart_port *port)
|
|
|
|
{
|
2009-09-19 20:13:28 +00:00
|
|
|
struct circ_buf *xmit = &port->state->xmit;
|
2009-06-11 13:05:39 +00:00
|
|
|
|
2009-06-22 17:43:03 +00:00
|
|
|
while (!(ioread32(port->membase + TIMBUART_ISR) & TXBF) &&
|
2009-06-11 13:05:39 +00:00
|
|
|
!uart_circ_empty(xmit)) {
|
|
|
|
iowrite8(xmit->buf[xmit->tail],
|
|
|
|
port->membase + TIMBUART_TXFIFO);
|
|
|
|
xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
|
|
|
|
port->icount.tx++;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(port->dev,
|
|
|
|
"%s - total written %d bytes, CTL: %x, RTS: %x, baud: %x\n",
|
|
|
|
__func__,
|
|
|
|
port->icount.tx,
|
|
|
|
ioread8(port->membase + TIMBUART_CTRL),
|
|
|
|
port->mctrl & TIOCM_RTS,
|
|
|
|
ioread8(port->membase + TIMBUART_BAUDRATE));
|
|
|
|
}
|
|
|
|
|
2009-06-22 17:43:03 +00:00
|
|
|
static void timbuart_handle_tx_port(struct uart_port *port, u32 isr, u32 *ier)
|
2009-06-11 13:05:39 +00:00
|
|
|
{
|
|
|
|
struct timbuart_port *uart =
|
|
|
|
container_of(port, struct timbuart_port, port);
|
2009-09-19 20:13:28 +00:00
|
|
|
struct circ_buf *xmit = &port->state->xmit;
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
if (uart_circ_empty(xmit) || uart_tx_stopped(port))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (port->x_char)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (isr & TXFLAGS) {
|
|
|
|
timbuart_tx_chars(port);
|
|
|
|
/* clear all TX interrupts */
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(TXFLAGS, port->membase + TIMBUART_ISR);
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
|
|
|
|
uart_write_wakeup(port);
|
|
|
|
} else
|
|
|
|
/* Re-enable any tx interrupt */
|
|
|
|
*ier |= uart->last_ier & TXFLAGS;
|
|
|
|
|
|
|
|
/* enable interrupts if there are chars in the transmit buffer,
|
|
|
|
* Or if we delivered some bytes and want the almost empty interrupt
|
|
|
|
* we wake up the upper layer later when we got the interrupt
|
|
|
|
* to give it some time to go out...
|
|
|
|
*/
|
|
|
|
if (!uart_circ_empty(xmit))
|
|
|
|
*ier |= TXBAE;
|
|
|
|
|
|
|
|
dev_dbg(port->dev, "%s - leaving\n", __func__);
|
|
|
|
}
|
|
|
|
|
2013-08-08 08:33:27 +00:00
|
|
|
static void timbuart_handle_rx_port(struct uart_port *port, u32 isr, u32 *ier)
|
2009-06-11 13:05:39 +00:00
|
|
|
{
|
|
|
|
if (isr & RXFLAGS) {
|
|
|
|
/* Some RX status is set */
|
|
|
|
if (isr & RXBF) {
|
|
|
|
u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |
|
|
|
|
TIMBUART_CTRL_FLSHRX;
|
|
|
|
iowrite8(ctl, port->membase + TIMBUART_CTRL);
|
|
|
|
port->icount.overrun++;
|
|
|
|
} else if (isr & (RXDP))
|
|
|
|
timbuart_rx_chars(port);
|
|
|
|
|
|
|
|
/* ack all RX interrupts */
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(RXFLAGS, port->membase + TIMBUART_ISR);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* always have the RX interrupts enabled */
|
|
|
|
*ier |= RXBAF | RXBF | RXTT;
|
|
|
|
|
|
|
|
dev_dbg(port->dev, "%s - leaving\n", __func__);
|
|
|
|
}
|
|
|
|
|
2013-08-08 08:33:27 +00:00
|
|
|
static void timbuart_tasklet(unsigned long arg)
|
2009-06-11 13:05:39 +00:00
|
|
|
{
|
|
|
|
struct timbuart_port *uart = (struct timbuart_port *)arg;
|
2009-06-22 17:43:03 +00:00
|
|
|
u32 isr, ier = 0;
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
spin_lock(&uart->port.lock);
|
|
|
|
|
2009-06-22 17:43:03 +00:00
|
|
|
isr = ioread32(uart->port.membase + TIMBUART_ISR);
|
2009-06-11 13:05:39 +00:00
|
|
|
dev_dbg(uart->port.dev, "%s ISR: %x\n", __func__, isr);
|
|
|
|
|
|
|
|
if (!uart->usedma)
|
|
|
|
timbuart_handle_tx_port(&uart->port, isr, &ier);
|
|
|
|
|
|
|
|
timbuart_mctrl_check(&uart->port, isr, &ier);
|
|
|
|
|
|
|
|
if (!uart->usedma)
|
|
|
|
timbuart_handle_rx_port(&uart->port, isr, &ier);
|
|
|
|
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(ier, uart->port.membase + TIMBUART_IER);
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
spin_unlock(&uart->port.lock);
|
|
|
|
dev_dbg(uart->port.dev, "%s leaving\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int timbuart_get_mctrl(struct uart_port *port)
|
|
|
|
{
|
|
|
|
u8 cts = ioread8(port->membase + TIMBUART_CTRL);
|
|
|
|
dev_dbg(port->dev, "%s - cts %x\n", __func__, cts);
|
|
|
|
|
|
|
|
if (cts & TIMBUART_CTRL_CTS)
|
|
|
|
return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
|
|
|
|
else
|
|
|
|
return TIOCM_DSR | TIOCM_CAR;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
|
|
|
|
{
|
|
|
|
dev_dbg(port->dev, "%s - %x\n", __func__, mctrl);
|
|
|
|
|
|
|
|
if (mctrl & TIOCM_RTS)
|
|
|
|
iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
|
|
|
|
else
|
2010-04-27 21:16:33 +00:00
|
|
|
iowrite8(0, port->membase + TIMBUART_CTRL);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
2009-06-22 17:43:03 +00:00
|
|
|
static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier)
|
2009-06-11 13:05:39 +00:00
|
|
|
{
|
|
|
|
unsigned int cts;
|
|
|
|
|
|
|
|
if (isr & CTS_DELTA) {
|
|
|
|
/* ack */
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(CTS_DELTA, port->membase + TIMBUART_ISR);
|
2009-06-11 13:05:39 +00:00
|
|
|
cts = timbuart_get_mctrl(port);
|
|
|
|
uart_handle_cts_change(port, cts & TIOCM_CTS);
|
2009-09-19 20:13:31 +00:00
|
|
|
wake_up_interruptible(&port->state->port.delta_msr_wait);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
*ier |= CTS_DELTA;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_break_ctl(struct uart_port *port, int ctl)
|
|
|
|
{
|
|
|
|
/* N/A */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int timbuart_startup(struct uart_port *port)
|
|
|
|
{
|
|
|
|
struct timbuart_port *uart =
|
|
|
|
container_of(port, struct timbuart_port, port);
|
|
|
|
|
|
|
|
dev_dbg(port->dev, "%s\n", __func__);
|
|
|
|
|
|
|
|
iowrite8(TIMBUART_CTRL_FLSHRX, port->membase + TIMBUART_CTRL);
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(0x1ff, port->membase + TIMBUART_ISR);
|
2009-06-11 13:05:39 +00:00
|
|
|
/* Enable all but TX interrupts */
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(RXBAF | RXBF | RXTT | CTS_DELTA,
|
2009-06-11 13:05:39 +00:00
|
|
|
port->membase + TIMBUART_IER);
|
|
|
|
|
|
|
|
return request_irq(port->irq, timbuart_handleinterrupt, IRQF_SHARED,
|
|
|
|
"timb-uart", uart);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_shutdown(struct uart_port *port)
|
|
|
|
{
|
|
|
|
struct timbuart_port *uart =
|
|
|
|
container_of(port, struct timbuart_port, port);
|
|
|
|
dev_dbg(port->dev, "%s\n", __func__);
|
|
|
|
free_irq(port->irq, uart);
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(0, port->membase + TIMBUART_IER);
|
2014-10-16 20:54:18 +00:00
|
|
|
|
|
|
|
timbuart_flush_buffer(port);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int get_bindex(int baud)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(baudrates); i++)
|
2009-06-11 13:27:13 +00:00
|
|
|
if (baud <= baudrates[i])
|
2009-06-11 13:05:39 +00:00
|
|
|
return i;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void timbuart_set_termios(struct uart_port *port,
|
|
|
|
struct ktermios *termios,
|
|
|
|
struct ktermios *old)
|
|
|
|
{
|
|
|
|
unsigned int baud;
|
|
|
|
short bindex;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
|
|
|
|
bindex = get_bindex(baud);
|
|
|
|
dev_dbg(port->dev, "%s - bindex %d\n", __func__, bindex);
|
|
|
|
|
2009-06-11 13:27:13 +00:00
|
|
|
if (bindex < 0)
|
|
|
|
bindex = 0;
|
|
|
|
baud = baudrates[bindex];
|
|
|
|
|
|
|
|
/* The serial layer calls into this once with old = NULL when setting
|
|
|
|
up initially */
|
|
|
|
if (old)
|
|
|
|
tty_termios_copy_hw(termios, old);
|
|
|
|
tty_termios_encode_baud_rate(termios, baud, baud);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
iowrite8((u8)bindex, port->membase + TIMBUART_BAUDRATE);
|
|
|
|
uart_update_timeout(port, termios->c_cflag, baud);
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
2009-06-11 13:05:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char *timbuart_type(struct uart_port *port)
|
|
|
|
{
|
|
|
|
return port->type == PORT_UNKNOWN ? "timbuart" : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We do not request/release mappings of the registers here,
|
|
|
|
* currently it's done in the proble function.
|
|
|
|
*/
|
|
|
|
static void timbuart_release_port(struct uart_port *port)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = to_platform_device(port->dev);
|
|
|
|
int size =
|
|
|
|
resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0));
|
|
|
|
|
|
|
|
if (port->flags & UPF_IOREMAP) {
|
|
|
|
iounmap(port->membase);
|
|
|
|
port->membase = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
release_mem_region(port->mapbase, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int timbuart_request_port(struct uart_port *port)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = to_platform_device(port->dev);
|
|
|
|
int size =
|
|
|
|
resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0));
|
|
|
|
|
|
|
|
if (!request_mem_region(port->mapbase, size, "timb-uart"))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
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 irqreturn_t timbuart_handleinterrupt(int irq, void *devid)
|
|
|
|
{
|
|
|
|
struct timbuart_port *uart = (struct timbuart_port *)devid;
|
|
|
|
|
|
|
|
if (ioread8(uart->port.membase + TIMBUART_IPR)) {
|
2009-06-22 17:43:03 +00:00
|
|
|
uart->last_ier = ioread32(uart->port.membase + TIMBUART_IER);
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
/* disable interrupts, the tasklet enables them again */
|
2009-06-22 17:43:03 +00:00
|
|
|
iowrite32(0, uart->port.membase + TIMBUART_IER);
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
/* fire off bottom half */
|
|
|
|
tasklet_schedule(&uart->tasklet);
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
} else
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure/autoconfigure the port.
|
|
|
|
*/
|
|
|
|
static void timbuart_config_port(struct uart_port *port, int flags)
|
|
|
|
{
|
|
|
|
if (flags & UART_CONFIG_TYPE) {
|
|
|
|
port->type = PORT_TIMBUART;
|
|
|
|
timbuart_request_port(port);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int timbuart_verify_port(struct uart_port *port,
|
|
|
|
struct serial_struct *ser)
|
|
|
|
{
|
|
|
|
/* we don't want the core code to modify any port params */
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-09-01 17:51:35 +00:00
|
|
|
static const struct uart_ops timbuart_ops = {
|
2009-06-11 13:05:39 +00:00
|
|
|
.tx_empty = timbuart_tx_empty,
|
|
|
|
.set_mctrl = timbuart_set_mctrl,
|
|
|
|
.get_mctrl = timbuart_get_mctrl,
|
|
|
|
.stop_tx = timbuart_stop_tx,
|
|
|
|
.start_tx = timbuart_start_tx,
|
|
|
|
.flush_buffer = timbuart_flush_buffer,
|
|
|
|
.stop_rx = timbuart_stop_rx,
|
|
|
|
.break_ctl = timbuart_break_ctl,
|
|
|
|
.startup = timbuart_startup,
|
|
|
|
.shutdown = timbuart_shutdown,
|
|
|
|
.set_termios = timbuart_set_termios,
|
|
|
|
.type = timbuart_type,
|
|
|
|
.release_port = timbuart_release_port,
|
|
|
|
.request_port = timbuart_request_port,
|
|
|
|
.config_port = timbuart_config_port,
|
|
|
|
.verify_port = timbuart_verify_port
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct uart_driver timbuart_driver = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.driver_name = "timberdale_uart",
|
|
|
|
.dev_name = "ttyTU",
|
|
|
|
.major = TIMBUART_MAJOR,
|
|
|
|
.minor = TIMBUART_MINOR,
|
|
|
|
.nr = 1
|
|
|
|
};
|
|
|
|
|
2012-11-19 18:21:50 +00:00
|
|
|
static int timbuart_probe(struct platform_device *dev)
|
2009-06-11 13:05:39 +00:00
|
|
|
{
|
2009-12-22 00:26:49 +00:00
|
|
|
int err, irq;
|
2009-06-11 13:05:39 +00:00
|
|
|
struct timbuart_port *uart;
|
|
|
|
struct resource *iomem;
|
|
|
|
|
|
|
|
dev_dbg(&dev->dev, "%s\n", __func__);
|
|
|
|
|
|
|
|
uart = kzalloc(sizeof(*uart), GFP_KERNEL);
|
|
|
|
if (!uart) {
|
|
|
|
err = -EINVAL;
|
|
|
|
goto err_mem;
|
|
|
|
}
|
|
|
|
|
|
|
|
uart->usedma = 0;
|
|
|
|
|
|
|
|
uart->port.uartclk = 3250000 * 16;
|
|
|
|
uart->port.fifosize = TIMBUART_FIFO_SIZE;
|
|
|
|
uart->port.regshift = 2;
|
|
|
|
uart->port.iotype = UPIO_MEM;
|
|
|
|
uart->port.ops = &timbuart_ops;
|
|
|
|
uart->port.irq = 0;
|
|
|
|
uart->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP;
|
|
|
|
uart->port.line = 0;
|
|
|
|
uart->port.dev = &dev->dev;
|
|
|
|
|
|
|
|
iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
|
|
|
|
if (!iomem) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_register;
|
|
|
|
}
|
|
|
|
uart->port.mapbase = iomem->start;
|
|
|
|
uart->port.membase = NULL;
|
|
|
|
|
2009-12-22 00:26:49 +00:00
|
|
|
irq = platform_get_irq(dev, 0);
|
|
|
|
if (irq < 0) {
|
2009-06-11 13:05:39 +00:00
|
|
|
err = -EINVAL;
|
|
|
|
goto err_register;
|
|
|
|
}
|
2009-12-22 00:26:49 +00:00
|
|
|
uart->port.irq = irq;
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart);
|
|
|
|
|
|
|
|
err = uart_register_driver(&timbuart_driver);
|
|
|
|
if (err)
|
|
|
|
goto err_register;
|
|
|
|
|
|
|
|
err = uart_add_one_port(&timbuart_driver, &uart->port);
|
|
|
|
if (err)
|
|
|
|
goto err_add_port;
|
|
|
|
|
|
|
|
platform_set_drvdata(dev, uart);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_add_port:
|
|
|
|
uart_unregister_driver(&timbuart_driver);
|
|
|
|
err_register:
|
|
|
|
kfree(uart);
|
|
|
|
err_mem:
|
|
|
|
printk(KERN_ERR "timberdale: Failed to register Timberdale UART: %d\n",
|
|
|
|
err);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-11-19 18:26:18 +00:00
|
|
|
static int timbuart_remove(struct platform_device *dev)
|
2009-06-11 13:05:39 +00:00
|
|
|
{
|
|
|
|
struct timbuart_port *uart = platform_get_drvdata(dev);
|
|
|
|
|
|
|
|
tasklet_kill(&uart->tasklet);
|
|
|
|
uart_remove_one_port(&timbuart_driver, &uart->port);
|
|
|
|
uart_unregister_driver(&timbuart_driver);
|
|
|
|
kfree(uart);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct platform_driver timbuart_platform_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "timb-uart",
|
|
|
|
},
|
|
|
|
.probe = timbuart_probe,
|
2012-11-19 18:21:34 +00:00
|
|
|
.remove = timbuart_remove,
|
2009-06-11 13:05:39 +00:00
|
|
|
};
|
|
|
|
|
2011-11-28 11:22:15 +00:00
|
|
|
module_platform_driver(timbuart_platform_driver);
|
2009-06-11 13:05:39 +00:00
|
|
|
|
|
|
|
MODULE_DESCRIPTION("Timberdale UART driver");
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
|
|
MODULE_ALIAS("platform:timb-uart");
|
|
|
|
|