mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 16:29:59 +00:00
![Greg Kroah-Hartman](/assets/img/avatar_default.png)
Now that the SPDX tag is in all tty files, that identifies the license in a specific and legally-defined manner. So the extra GPL text wording can be removed as it is no longer needed at all. This is done on a quest to remove the 700+ different ways that files in the kernel describe the GPL license text. And there's unneeded stuff like the address (sometimes incorrect) for the FSF which is never needed. No copyright headers or other non-license-description text was removed. Cc: Jiri Slaby <jslaby@suse.com> Cc: James Hogan <jhogan@kernel.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
1271 lines
35 KiB
C
1271 lines
35 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* TTY driver for MIPS EJTAG Fast Debug Channels.
|
|
*
|
|
* Copyright (C) 2007-2015 Imagination Technologies Ltd
|
|
*/
|
|
|
|
#include <linux/atomic.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/completion.h>
|
|
#include <linux/console.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/export.h>
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/kgdb.h>
|
|
#include <linux/kthread.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/serial.h>
|
|
#include <linux/serial_core.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/string.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/tty.h>
|
|
#include <linux/tty_driver.h>
|
|
#include <linux/tty_flip.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <asm/cdmm.h>
|
|
#include <asm/irq.h>
|
|
|
|
/* Register offsets */
|
|
#define REG_FDACSR 0x00 /* FDC Access Control and Status Register */
|
|
#define REG_FDCFG 0x08 /* FDC Configuration Register */
|
|
#define REG_FDSTAT 0x10 /* FDC Status Register */
|
|
#define REG_FDRX 0x18 /* FDC Receive Register */
|
|
#define REG_FDTX(N) (0x20+0x8*(N)) /* FDC Transmit Register n (0..15) */
|
|
|
|
/* Register fields */
|
|
|
|
#define REG_FDCFG_TXINTTHRES_SHIFT 18
|
|
#define REG_FDCFG_TXINTTHRES (0x3 << REG_FDCFG_TXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_TXINTTHRES_DISABLED (0x0 << REG_FDCFG_TXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_TXINTTHRES_EMPTY (0x1 << REG_FDCFG_TXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_TXINTTHRES_NOTFULL (0x2 << REG_FDCFG_TXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_TXINTTHRES_NEAREMPTY (0x3 << REG_FDCFG_TXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_RXINTTHRES_SHIFT 16
|
|
#define REG_FDCFG_RXINTTHRES (0x3 << REG_FDCFG_RXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_RXINTTHRES_DISABLED (0x0 << REG_FDCFG_RXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_RXINTTHRES_FULL (0x1 << REG_FDCFG_RXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_RXINTTHRES_NOTEMPTY (0x2 << REG_FDCFG_RXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_RXINTTHRES_NEARFULL (0x3 << REG_FDCFG_RXINTTHRES_SHIFT)
|
|
#define REG_FDCFG_TXFIFOSIZE_SHIFT 8
|
|
#define REG_FDCFG_TXFIFOSIZE (0xff << REG_FDCFG_TXFIFOSIZE_SHIFT)
|
|
#define REG_FDCFG_RXFIFOSIZE_SHIFT 0
|
|
#define REG_FDCFG_RXFIFOSIZE (0xff << REG_FDCFG_RXFIFOSIZE_SHIFT)
|
|
|
|
#define REG_FDSTAT_TXCOUNT_SHIFT 24
|
|
#define REG_FDSTAT_TXCOUNT (0xff << REG_FDSTAT_TXCOUNT_SHIFT)
|
|
#define REG_FDSTAT_RXCOUNT_SHIFT 16
|
|
#define REG_FDSTAT_RXCOUNT (0xff << REG_FDSTAT_RXCOUNT_SHIFT)
|
|
#define REG_FDSTAT_RXCHAN_SHIFT 4
|
|
#define REG_FDSTAT_RXCHAN (0xf << REG_FDSTAT_RXCHAN_SHIFT)
|
|
#define REG_FDSTAT_RXE BIT(3) /* Rx Empty */
|
|
#define REG_FDSTAT_RXF BIT(2) /* Rx Full */
|
|
#define REG_FDSTAT_TXE BIT(1) /* Tx Empty */
|
|
#define REG_FDSTAT_TXF BIT(0) /* Tx Full */
|
|
|
|
/* Default channel for the early console */
|
|
#define CONSOLE_CHANNEL 1
|
|
|
|
#define NUM_TTY_CHANNELS 16
|
|
|
|
#define RX_BUF_SIZE 1024
|
|
|
|
/*
|
|
* When the IRQ is unavailable, the FDC state must be polled for incoming data
|
|
* and space becoming available in TX FIFO.
|
|
*/
|
|
#define FDC_TTY_POLL (HZ / 50)
|
|
|
|
struct mips_ejtag_fdc_tty;
|
|
|
|
/**
|
|
* struct mips_ejtag_fdc_tty_port - Wrapper struct for FDC tty_port.
|
|
* @port: TTY port data
|
|
* @driver: TTY driver.
|
|
* @rx_lock: Lock for rx_buf.
|
|
* This protects between the hard interrupt and user
|
|
* context. It's also held during read SWITCH operations.
|
|
* @rx_buf: Read buffer.
|
|
* @xmit_lock: Lock for xmit_*, and port.xmit_buf.
|
|
* This protects between user context and kernel thread.
|
|
* It is used from chars_in_buffer()/write_room() TTY
|
|
* callbacks which are used during wait operations, so a
|
|
* mutex is unsuitable.
|
|
* @xmit_cnt: Size of xmit buffer contents.
|
|
* @xmit_head: Head of xmit buffer where data is written.
|
|
* @xmit_tail: Tail of xmit buffer where data is read.
|
|
* @xmit_empty: Completion for xmit buffer being empty.
|
|
*/
|
|
struct mips_ejtag_fdc_tty_port {
|
|
struct tty_port port;
|
|
struct mips_ejtag_fdc_tty *driver;
|
|
raw_spinlock_t rx_lock;
|
|
void *rx_buf;
|
|
spinlock_t xmit_lock;
|
|
unsigned int xmit_cnt;
|
|
unsigned int xmit_head;
|
|
unsigned int xmit_tail;
|
|
struct completion xmit_empty;
|
|
};
|
|
|
|
/**
|
|
* struct mips_ejtag_fdc_tty - Driver data for FDC as a whole.
|
|
* @dev: FDC device (for dev_*() logging).
|
|
* @driver: TTY driver.
|
|
* @cpu: CPU number for this FDC.
|
|
* @fdc_name: FDC name (not for base of channel names).
|
|
* @driver_name: Base of driver name.
|
|
* @ports: Per-channel data.
|
|
* @waitqueue: Wait queue for waiting for TX data, or for space in TX
|
|
* FIFO.
|
|
* @lock: Lock to protect FDCFG (interrupt enable).
|
|
* @thread: KThread for writing out data to FDC.
|
|
* @reg: FDC registers.
|
|
* @tx_fifo: TX FIFO size.
|
|
* @xmit_size: Size of each port's xmit buffer.
|
|
* @xmit_total: Total number of bytes (from all ports) to transmit.
|
|
* @xmit_next: Next port number to transmit from (round robin).
|
|
* @xmit_full: Indicates TX FIFO is full, we're waiting for space.
|
|
* @irq: IRQ number (negative if no IRQ).
|
|
* @removing: Indicates the device is being removed and @poll_timer
|
|
* should not be restarted.
|
|
* @poll_timer: Timer for polling for interrupt events when @irq < 0.
|
|
* @sysrq_pressed: Whether the magic sysrq key combination has been
|
|
* detected. See mips_ejtag_fdc_handle().
|
|
*/
|
|
struct mips_ejtag_fdc_tty {
|
|
struct device *dev;
|
|
struct tty_driver *driver;
|
|
unsigned int cpu;
|
|
char fdc_name[16];
|
|
char driver_name[16];
|
|
struct mips_ejtag_fdc_tty_port ports[NUM_TTY_CHANNELS];
|
|
wait_queue_head_t waitqueue;
|
|
raw_spinlock_t lock;
|
|
struct task_struct *thread;
|
|
|
|
void __iomem *reg;
|
|
u8 tx_fifo;
|
|
|
|
unsigned int xmit_size;
|
|
atomic_t xmit_total;
|
|
unsigned int xmit_next;
|
|
bool xmit_full;
|
|
|
|
int irq;
|
|
bool removing;
|
|
struct timer_list poll_timer;
|
|
|
|
#ifdef CONFIG_MAGIC_SYSRQ
|
|
bool sysrq_pressed;
|
|
#endif
|
|
};
|
|
|
|
/* Hardware access */
|
|
|
|
static inline void mips_ejtag_fdc_write(struct mips_ejtag_fdc_tty *priv,
|
|
unsigned int offs, unsigned int data)
|
|
{
|
|
__raw_writel(data, priv->reg + offs);
|
|
}
|
|
|
|
static inline unsigned int mips_ejtag_fdc_read(struct mips_ejtag_fdc_tty *priv,
|
|
unsigned int offs)
|
|
{
|
|
return __raw_readl(priv->reg + offs);
|
|
}
|
|
|
|
/* Encoding of byte stream in FDC words */
|
|
|
|
/**
|
|
* struct fdc_word - FDC word encoding some number of bytes of data.
|
|
* @word: Raw FDC word.
|
|
* @bytes: Number of bytes encoded by @word.
|
|
*/
|
|
struct fdc_word {
|
|
u32 word;
|
|
unsigned int bytes;
|
|
};
|
|
|
|
/*
|
|
* This is a compact encoding which allows every 1 byte, 2 byte, and 3 byte
|
|
* sequence to be encoded in a single word, while allowing the majority of 4
|
|
* byte sequences (including all ASCII and common binary data) to be encoded in
|
|
* a single word too.
|
|
* _______________________ _____________
|
|
* | FDC Word | |
|
|
* |31-24|23-16|15-8 | 7-0 | Bytes |
|
|
* |_____|_____|_____|_____|_____________|
|
|
* | | | | | |
|
|
* |0x80 |0x80 |0x80 | WW | WW |
|
|
* |0x81 |0x81 | XX | WW | WW XX |
|
|
* |0x82 | YY | XX | WW | WW XX YY |
|
|
* | ZZ | YY | XX | WW | WW XX YY ZZ |
|
|
* |_____|_____|_____|_____|_____________|
|
|
*
|
|
* Note that the 4-byte encoding can only be used where none of the other 3
|
|
* encodings match, otherwise it must fall back to the 3 byte encoding.
|
|
*/
|
|
|
|
/* ranges >= 1 && sizes[0] >= 1 */
|
|
static struct fdc_word mips_ejtag_fdc_encode(const char **ptrs,
|
|
unsigned int *sizes,
|
|
unsigned int ranges)
|
|
{
|
|
struct fdc_word word = { 0, 0 };
|
|
const char **ptrs_end = ptrs + ranges;
|
|
|
|
for (; ptrs < ptrs_end; ++ptrs) {
|
|
const char *ptr = *(ptrs++);
|
|
const char *end = ptr + *(sizes++);
|
|
|
|
for (; ptr < end; ++ptr) {
|
|
word.word |= (u8)*ptr << (8*word.bytes);
|
|
++word.bytes;
|
|
if (word.bytes == 4)
|
|
goto done;
|
|
}
|
|
}
|
|
done:
|
|
/* Choose the appropriate encoding */
|
|
switch (word.bytes) {
|
|
case 4:
|
|
/* 4 byte encoding, but don't match the 1-3 byte encodings */
|
|
if ((word.word >> 8) != 0x808080 &&
|
|
(word.word >> 16) != 0x8181 &&
|
|
(word.word >> 24) != 0x82)
|
|
break;
|
|
/* Fall back to a 3 byte encoding */
|
|
word.bytes = 3;
|
|
word.word &= 0x00ffffff;
|
|
case 3:
|
|
/* 3 byte encoding */
|
|
word.word |= 0x82000000;
|
|
break;
|
|
case 2:
|
|
/* 2 byte encoding */
|
|
word.word |= 0x81810000;
|
|
break;
|
|
case 1:
|
|
/* 1 byte encoding */
|
|
word.word |= 0x80808000;
|
|
break;
|
|
}
|
|
return word;
|
|
}
|
|
|
|
static unsigned int mips_ejtag_fdc_decode(u32 word, char *buf)
|
|
{
|
|
buf[0] = (u8)word;
|
|
word >>= 8;
|
|
if (word == 0x808080)
|
|
return 1;
|
|
buf[1] = (u8)word;
|
|
word >>= 8;
|
|
if (word == 0x8181)
|
|
return 2;
|
|
buf[2] = (u8)word;
|
|
word >>= 8;
|
|
if (word == 0x82)
|
|
return 3;
|
|
buf[3] = (u8)word;
|
|
return 4;
|
|
}
|
|
|
|
/* Console operations */
|
|
|
|
/**
|
|
* struct mips_ejtag_fdc_console - Wrapper struct for FDC consoles.
|
|
* @cons: Console object.
|
|
* @tty_drv: TTY driver associated with this console.
|
|
* @lock: Lock to protect concurrent access to other fields.
|
|
* This is raw because it may be used very early.
|
|
* @initialised: Whether the console is initialised.
|
|
* @regs: Registers base address for each CPU.
|
|
*/
|
|
struct mips_ejtag_fdc_console {
|
|
struct console cons;
|
|
struct tty_driver *tty_drv;
|
|
raw_spinlock_t lock;
|
|
bool initialised;
|
|
void __iomem *regs[NR_CPUS];
|
|
};
|
|
|
|
/* Low level console write shared by early console and normal console */
|
|
static void mips_ejtag_fdc_console_write(struct console *c, const char *s,
|
|
unsigned int count)
|
|
{
|
|
struct mips_ejtag_fdc_console *cons =
|
|
container_of(c, struct mips_ejtag_fdc_console, cons);
|
|
void __iomem *regs;
|
|
struct fdc_word word;
|
|
unsigned long flags;
|
|
unsigned int i, buf_len, cpu;
|
|
bool done_cr = false;
|
|
char buf[4];
|
|
const char *buf_ptr = buf;
|
|
/* Number of bytes of input data encoded up to each byte in buf */
|
|
u8 inc[4];
|
|
|
|
local_irq_save(flags);
|
|
cpu = smp_processor_id();
|
|
regs = cons->regs[cpu];
|
|
/* First console output on this CPU? */
|
|
if (!regs) {
|
|
regs = mips_cdmm_early_probe(0xfd);
|
|
cons->regs[cpu] = regs;
|
|
}
|
|
/* Already tried and failed to find FDC on this CPU? */
|
|
if (IS_ERR(regs))
|
|
goto out;
|
|
while (count) {
|
|
/*
|
|
* Copy the next few characters to a buffer so we can inject
|
|
* carriage returns before newlines.
|
|
*/
|
|
for (buf_len = 0, i = 0; buf_len < 4 && i < count; ++buf_len) {
|
|
if (s[i] == '\n' && !done_cr) {
|
|
buf[buf_len] = '\r';
|
|
done_cr = true;
|
|
} else {
|
|
buf[buf_len] = s[i];
|
|
done_cr = false;
|
|
++i;
|
|
}
|
|
inc[buf_len] = i;
|
|
}
|
|
word = mips_ejtag_fdc_encode(&buf_ptr, &buf_len, 1);
|
|
count -= inc[word.bytes - 1];
|
|
s += inc[word.bytes - 1];
|
|
|
|
/* Busy wait until there's space in fifo */
|
|
while (__raw_readl(regs + REG_FDSTAT) & REG_FDSTAT_TXF)
|
|
;
|
|
__raw_writel(word.word, regs + REG_FDTX(c->index));
|
|
}
|
|
out:
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
static struct tty_driver *mips_ejtag_fdc_console_device(struct console *c,
|
|
int *index)
|
|
{
|
|
struct mips_ejtag_fdc_console *cons =
|
|
container_of(c, struct mips_ejtag_fdc_console, cons);
|
|
|
|
*index = c->index;
|
|
return cons->tty_drv;
|
|
}
|
|
|
|
/* Initialise an FDC console (early or normal */
|
|
static int __init mips_ejtag_fdc_console_init(struct mips_ejtag_fdc_console *c)
|
|
{
|
|
void __iomem *regs;
|
|
unsigned long flags;
|
|
int ret = 0;
|
|
|
|
raw_spin_lock_irqsave(&c->lock, flags);
|
|
/* Don't init twice */
|
|
if (c->initialised)
|
|
goto out;
|
|
/* Look for the FDC device */
|
|
regs = mips_cdmm_early_probe(0xfd);
|
|
if (IS_ERR(regs)) {
|
|
ret = PTR_ERR(regs);
|
|
goto out;
|
|
}
|
|
|
|
c->initialised = true;
|
|
c->regs[smp_processor_id()] = regs;
|
|
register_console(&c->cons);
|
|
out:
|
|
raw_spin_unlock_irqrestore(&c->lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
static struct mips_ejtag_fdc_console mips_ejtag_fdc_con = {
|
|
.cons = {
|
|
.name = "fdc",
|
|
.write = mips_ejtag_fdc_console_write,
|
|
.device = mips_ejtag_fdc_console_device,
|
|
.flags = CON_PRINTBUFFER,
|
|
.index = -1,
|
|
},
|
|
.lock = __RAW_SPIN_LOCK_UNLOCKED(mips_ejtag_fdc_con.lock),
|
|
};
|
|
|
|
/* TTY RX/TX operations */
|
|
|
|
/**
|
|
* mips_ejtag_fdc_put_chan() - Write out a block of channel data.
|
|
* @priv: Pointer to driver private data.
|
|
* @chan: Channel number.
|
|
*
|
|
* Write a single block of data out to the debug adapter. If the circular buffer
|
|
* is wrapped then only the first block is written.
|
|
*
|
|
* Returns: The number of bytes that were written.
|
|
*/
|
|
static unsigned int mips_ejtag_fdc_put_chan(struct mips_ejtag_fdc_tty *priv,
|
|
unsigned int chan)
|
|
{
|
|
struct mips_ejtag_fdc_tty_port *dport;
|
|
struct tty_struct *tty;
|
|
const char *ptrs[2];
|
|
unsigned int sizes[2] = { 0 };
|
|
struct fdc_word word = { .bytes = 0 };
|
|
unsigned long flags;
|
|
|
|
dport = &priv->ports[chan];
|
|
spin_lock(&dport->xmit_lock);
|
|
if (dport->xmit_cnt) {
|
|
ptrs[0] = dport->port.xmit_buf + dport->xmit_tail;
|
|
sizes[0] = min_t(unsigned int,
|
|
priv->xmit_size - dport->xmit_tail,
|
|
dport->xmit_cnt);
|
|
ptrs[1] = dport->port.xmit_buf;
|
|
sizes[1] = dport->xmit_cnt - sizes[0];
|
|
word = mips_ejtag_fdc_encode(ptrs, sizes, 1 + !!sizes[1]);
|
|
|
|
dev_dbg(priv->dev, "%s%u: out %08x: \"%*pE%*pE\"\n",
|
|
priv->driver_name, chan, word.word,
|
|
min_t(int, word.bytes, sizes[0]), ptrs[0],
|
|
max_t(int, 0, word.bytes - sizes[0]), ptrs[1]);
|
|
|
|
local_irq_save(flags);
|
|
/* Maybe we raced with the console and TX FIFO is full */
|
|
if (mips_ejtag_fdc_read(priv, REG_FDSTAT) & REG_FDSTAT_TXF)
|
|
word.bytes = 0;
|
|
else
|
|
mips_ejtag_fdc_write(priv, REG_FDTX(chan), word.word);
|
|
local_irq_restore(flags);
|
|
|
|
dport->xmit_cnt -= word.bytes;
|
|
if (!dport->xmit_cnt) {
|
|
/* Reset pointers to avoid wraps */
|
|
dport->xmit_head = 0;
|
|
dport->xmit_tail = 0;
|
|
complete(&dport->xmit_empty);
|
|
} else {
|
|
dport->xmit_tail += word.bytes;
|
|
if (dport->xmit_tail >= priv->xmit_size)
|
|
dport->xmit_tail -= priv->xmit_size;
|
|
}
|
|
atomic_sub(word.bytes, &priv->xmit_total);
|
|
}
|
|
spin_unlock(&dport->xmit_lock);
|
|
|
|
/* If we've made more data available, wake up tty */
|
|
if (sizes[0] && word.bytes) {
|
|
tty = tty_port_tty_get(&dport->port);
|
|
if (tty) {
|
|
tty_wakeup(tty);
|
|
tty_kref_put(tty);
|
|
}
|
|
}
|
|
|
|
return word.bytes;
|
|
}
|
|
|
|
/**
|
|
* mips_ejtag_fdc_put() - Kernel thread to write out channel data to FDC.
|
|
* @arg: Driver pointer.
|
|
*
|
|
* This kernel thread runs while @priv->xmit_total != 0, and round robins the
|
|
* channels writing out blocks of buffered data to the FDC TX FIFO.
|
|
*/
|
|
static int mips_ejtag_fdc_put(void *arg)
|
|
{
|
|
struct mips_ejtag_fdc_tty *priv = arg;
|
|
struct mips_ejtag_fdc_tty_port *dport;
|
|
unsigned int ret;
|
|
u32 cfg;
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
while (!kthread_should_stop()) {
|
|
/* Wait for data to actually write */
|
|
wait_event_interruptible(priv->waitqueue,
|
|
atomic_read(&priv->xmit_total) ||
|
|
kthread_should_stop());
|
|
if (kthread_should_stop())
|
|
break;
|
|
|
|
/* Wait for TX FIFO space to write data */
|
|
raw_spin_lock_irq(&priv->lock);
|
|
if (mips_ejtag_fdc_read(priv, REG_FDSTAT) & REG_FDSTAT_TXF) {
|
|
priv->xmit_full = true;
|
|
if (priv->irq >= 0) {
|
|
/* Enable TX interrupt */
|
|
cfg = mips_ejtag_fdc_read(priv, REG_FDCFG);
|
|
cfg &= ~REG_FDCFG_TXINTTHRES;
|
|
cfg |= REG_FDCFG_TXINTTHRES_NOTFULL;
|
|
mips_ejtag_fdc_write(priv, REG_FDCFG, cfg);
|
|
}
|
|
}
|
|
raw_spin_unlock_irq(&priv->lock);
|
|
wait_event_interruptible(priv->waitqueue,
|
|
!(mips_ejtag_fdc_read(priv, REG_FDSTAT)
|
|
& REG_FDSTAT_TXF) ||
|
|
kthread_should_stop());
|
|
if (kthread_should_stop())
|
|
break;
|
|
|
|
/* Find next channel with data to output */
|
|
for (;;) {
|
|
dport = &priv->ports[priv->xmit_next];
|
|
spin_lock(&dport->xmit_lock);
|
|
ret = dport->xmit_cnt;
|
|
spin_unlock(&dport->xmit_lock);
|
|
if (ret)
|
|
break;
|
|
/* Round robin */
|
|
++priv->xmit_next;
|
|
if (priv->xmit_next >= NUM_TTY_CHANNELS)
|
|
priv->xmit_next = 0;
|
|
}
|
|
|
|
/* Try writing data to the chosen channel */
|
|
ret = mips_ejtag_fdc_put_chan(priv, priv->xmit_next);
|
|
|
|
/*
|
|
* If anything was output, move on to the next channel so as not
|
|
* to starve other channels.
|
|
*/
|
|
if (ret) {
|
|
++priv->xmit_next;
|
|
if (priv->xmit_next >= NUM_TTY_CHANNELS)
|
|
priv->xmit_next = 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* mips_ejtag_fdc_handle() - Handle FDC events.
|
|
* @priv: Pointer to driver private data.
|
|
*
|
|
* Handle FDC events, such as new incoming data which needs draining out of the
|
|
* RX FIFO and feeding into the appropriate TTY ports, and space becoming
|
|
* available in the TX FIFO which would allow more data to be written out.
|
|
*/
|
|
static void mips_ejtag_fdc_handle(struct mips_ejtag_fdc_tty *priv)
|
|
{
|
|
struct mips_ejtag_fdc_tty_port *dport;
|
|
unsigned int stat, channel, data, cfg, i, flipped;
|
|
int len;
|
|
char buf[4];
|
|
|
|
for (;;) {
|
|
/* Find which channel the next FDC word is destined for */
|
|
stat = mips_ejtag_fdc_read(priv, REG_FDSTAT);
|
|
if (stat & REG_FDSTAT_RXE)
|
|
break;
|
|
channel = (stat & REG_FDSTAT_RXCHAN) >> REG_FDSTAT_RXCHAN_SHIFT;
|
|
dport = &priv->ports[channel];
|
|
|
|
/* Read out the FDC word, decode it, and pass to tty layer */
|
|
raw_spin_lock(&dport->rx_lock);
|
|
data = mips_ejtag_fdc_read(priv, REG_FDRX);
|
|
|
|
len = mips_ejtag_fdc_decode(data, buf);
|
|
dev_dbg(priv->dev, "%s%u: in %08x: \"%*pE\"\n",
|
|
priv->driver_name, channel, data, len, buf);
|
|
|
|
flipped = 0;
|
|
for (i = 0; i < len; ++i) {
|
|
#ifdef CONFIG_MAGIC_SYSRQ
|
|
#ifdef CONFIG_MIPS_EJTAG_FDC_KGDB
|
|
/* Support just Ctrl+C with KGDB channel */
|
|
if (channel == CONFIG_MIPS_EJTAG_FDC_KGDB_CHAN) {
|
|
if (buf[i] == '\x03') { /* ^C */
|
|
handle_sysrq('g');
|
|
continue;
|
|
}
|
|
}
|
|
#endif
|
|
/* Support Ctrl+O for console channel */
|
|
if (channel == mips_ejtag_fdc_con.cons.index) {
|
|
if (buf[i] == '\x0f') { /* ^O */
|
|
priv->sysrq_pressed =
|
|
!priv->sysrq_pressed;
|
|
if (priv->sysrq_pressed)
|
|
continue;
|
|
} else if (priv->sysrq_pressed) {
|
|
handle_sysrq(buf[i]);
|
|
priv->sysrq_pressed = false;
|
|
continue;
|
|
}
|
|
}
|
|
#endif /* CONFIG_MAGIC_SYSRQ */
|
|
|
|
/* Check the port isn't being shut down */
|
|
if (!dport->rx_buf)
|
|
continue;
|
|
|
|
flipped += tty_insert_flip_char(&dport->port, buf[i],
|
|
TTY_NORMAL);
|
|
}
|
|
if (flipped)
|
|
tty_flip_buffer_push(&dport->port);
|
|
|
|
raw_spin_unlock(&dport->rx_lock);
|
|
}
|
|
|
|
/* If TX FIFO no longer full we may be able to write more data */
|
|
raw_spin_lock(&priv->lock);
|
|
if (priv->xmit_full && !(stat & REG_FDSTAT_TXF)) {
|
|
priv->xmit_full = false;
|
|
|
|
/* Disable TX interrupt */
|
|
cfg = mips_ejtag_fdc_read(priv, REG_FDCFG);
|
|
cfg &= ~REG_FDCFG_TXINTTHRES;
|
|
cfg |= REG_FDCFG_TXINTTHRES_DISABLED;
|
|
mips_ejtag_fdc_write(priv, REG_FDCFG, cfg);
|
|
|
|
/* Wait the kthread so it can try writing more data */
|
|
wake_up_interruptible(&priv->waitqueue);
|
|
}
|
|
raw_spin_unlock(&priv->lock);
|
|
}
|
|
|
|
/**
|
|
* mips_ejtag_fdc_isr() - Interrupt handler.
|
|
* @irq: IRQ number.
|
|
* @dev_id: Pointer to driver private data.
|
|
*
|
|
* This is the interrupt handler, used when interrupts are enabled.
|
|
*
|
|
* It simply triggers the common FDC handler code.
|
|
*
|
|
* Returns: IRQ_HANDLED if an FDC interrupt was pending.
|
|
* IRQ_NONE otherwise.
|
|
*/
|
|
static irqreturn_t mips_ejtag_fdc_isr(int irq, void *dev_id)
|
|
{
|
|
struct mips_ejtag_fdc_tty *priv = dev_id;
|
|
|
|
/*
|
|
* We're not using proper per-cpu IRQs, so we must be careful not to
|
|
* handle IRQs on CPUs we're not interested in.
|
|
*
|
|
* Ideally proper per-cpu IRQ handlers could be used, but that doesn't
|
|
* fit well with the whole sharing of the main CPU IRQ lines. When we
|
|
* have something with a GIC that routes the FDC IRQs (i.e. no sharing
|
|
* between handlers) then support could be added more easily.
|
|
*/
|
|
if (smp_processor_id() != priv->cpu)
|
|
return IRQ_NONE;
|
|
|
|
/* If no FDC interrupt pending, it wasn't for us */
|
|
if (!(read_c0_cause() & CAUSEF_FDCI))
|
|
return IRQ_NONE;
|
|
|
|
mips_ejtag_fdc_handle(priv);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/**
|
|
* mips_ejtag_fdc_tty_timer() - Poll FDC for incoming data.
|
|
* @opaque: Pointer to driver private data.
|
|
*
|
|
* This is the timer handler for when interrupts are disabled and polling the
|
|
* FDC state is required.
|
|
*
|
|
* It simply triggers the common FDC handler code and arranges for further
|
|
* polling.
|
|
*/
|
|
static void mips_ejtag_fdc_tty_timer(struct timer_list *t)
|
|
{
|
|
struct mips_ejtag_fdc_tty *priv = from_timer(priv, t, poll_timer);
|
|
|
|
mips_ejtag_fdc_handle(priv);
|
|
if (!priv->removing)
|
|
mod_timer(&priv->poll_timer, jiffies + FDC_TTY_POLL);
|
|
}
|
|
|
|
/* TTY Port operations */
|
|
|
|
static int mips_ejtag_fdc_tty_port_activate(struct tty_port *port,
|
|
struct tty_struct *tty)
|
|
{
|
|
struct mips_ejtag_fdc_tty_port *dport =
|
|
container_of(port, struct mips_ejtag_fdc_tty_port, port);
|
|
void *rx_buf;
|
|
|
|
/* Allocate the buffer we use for writing data */
|
|
if (tty_port_alloc_xmit_buf(port) < 0)
|
|
goto err;
|
|
|
|
/* Allocate the buffer we use for reading data */
|
|
rx_buf = kzalloc(RX_BUF_SIZE, GFP_KERNEL);
|
|
if (!rx_buf)
|
|
goto err_free_xmit;
|
|
|
|
raw_spin_lock_irq(&dport->rx_lock);
|
|
dport->rx_buf = rx_buf;
|
|
raw_spin_unlock_irq(&dport->rx_lock);
|
|
|
|
return 0;
|
|
err_free_xmit:
|
|
tty_port_free_xmit_buf(port);
|
|
err:
|
|
return -ENOMEM;
|
|
}
|
|
|
|
static void mips_ejtag_fdc_tty_port_shutdown(struct tty_port *port)
|
|
{
|
|
struct mips_ejtag_fdc_tty_port *dport =
|
|
container_of(port, struct mips_ejtag_fdc_tty_port, port);
|
|
struct mips_ejtag_fdc_tty *priv = dport->driver;
|
|
void *rx_buf;
|
|
unsigned int count;
|
|
|
|
spin_lock(&dport->xmit_lock);
|
|
count = dport->xmit_cnt;
|
|
spin_unlock(&dport->xmit_lock);
|
|
if (count) {
|
|
/*
|
|
* There's still data to write out, so wake and wait for the
|
|
* writer thread to drain the buffer.
|
|
*/
|
|
wake_up_interruptible(&priv->waitqueue);
|
|
wait_for_completion(&dport->xmit_empty);
|
|
}
|
|
|
|
/* Null the read buffer (timer could still be running!) */
|
|
raw_spin_lock_irq(&dport->rx_lock);
|
|
rx_buf = dport->rx_buf;
|
|
dport->rx_buf = NULL;
|
|
raw_spin_unlock_irq(&dport->rx_lock);
|
|
/* Free the read buffer */
|
|
kfree(rx_buf);
|
|
|
|
/* Free the write buffer */
|
|
tty_port_free_xmit_buf(port);
|
|
}
|
|
|
|
static const struct tty_port_operations mips_ejtag_fdc_tty_port_ops = {
|
|
.activate = mips_ejtag_fdc_tty_port_activate,
|
|
.shutdown = mips_ejtag_fdc_tty_port_shutdown,
|
|
};
|
|
|
|
/* TTY operations */
|
|
|
|
static int mips_ejtag_fdc_tty_install(struct tty_driver *driver,
|
|
struct tty_struct *tty)
|
|
{
|
|
struct mips_ejtag_fdc_tty *priv = driver->driver_state;
|
|
|
|
tty->driver_data = &priv->ports[tty->index];
|
|
return tty_port_install(&priv->ports[tty->index].port, driver, tty);
|
|
}
|
|
|
|
static int mips_ejtag_fdc_tty_open(struct tty_struct *tty, struct file *filp)
|
|
{
|
|
return tty_port_open(tty->port, tty, filp);
|
|
}
|
|
|
|
static void mips_ejtag_fdc_tty_close(struct tty_struct *tty, struct file *filp)
|
|
{
|
|
return tty_port_close(tty->port, tty, filp);
|
|
}
|
|
|
|
static void mips_ejtag_fdc_tty_hangup(struct tty_struct *tty)
|
|
{
|
|
struct mips_ejtag_fdc_tty_port *dport = tty->driver_data;
|
|
struct mips_ejtag_fdc_tty *priv = dport->driver;
|
|
|
|
/* Drop any data in the xmit buffer */
|
|
spin_lock(&dport->xmit_lock);
|
|
if (dport->xmit_cnt) {
|
|
atomic_sub(dport->xmit_cnt, &priv->xmit_total);
|
|
dport->xmit_cnt = 0;
|
|
dport->xmit_head = 0;
|
|
dport->xmit_tail = 0;
|
|
complete(&dport->xmit_empty);
|
|
}
|
|
spin_unlock(&dport->xmit_lock);
|
|
|
|
tty_port_hangup(tty->port);
|
|
}
|
|
|
|
static int mips_ejtag_fdc_tty_write(struct tty_struct *tty,
|
|
const unsigned char *buf, int total)
|
|
{
|
|
int count, block;
|
|
struct mips_ejtag_fdc_tty_port *dport = tty->driver_data;
|
|
struct mips_ejtag_fdc_tty *priv = dport->driver;
|
|
|
|
/*
|
|
* Write to output buffer.
|
|
*
|
|
* The reason that we asynchronously write the buffer is because if we
|
|
* were to write the buffer synchronously then because the channels are
|
|
* per-CPU the buffer would be written to the channel of whatever CPU
|
|
* we're running on.
|
|
*
|
|
* What we actually want to happen is have all input and output done on
|
|
* one CPU.
|
|
*/
|
|
spin_lock(&dport->xmit_lock);
|
|
/* Work out how many bytes we can write to the xmit buffer */
|
|
total = min(total, (int)(priv->xmit_size - dport->xmit_cnt));
|
|
atomic_add(total, &priv->xmit_total);
|
|
dport->xmit_cnt += total;
|
|
/* Write the actual bytes (may need splitting if it wraps) */
|
|
for (count = total; count; count -= block) {
|
|
block = min(count, (int)(priv->xmit_size - dport->xmit_head));
|
|
memcpy(dport->port.xmit_buf + dport->xmit_head, buf, block);
|
|
dport->xmit_head += block;
|
|
if (dport->xmit_head >= priv->xmit_size)
|
|
dport->xmit_head -= priv->xmit_size;
|
|
buf += block;
|
|
}
|
|
count = dport->xmit_cnt;
|
|
/* Xmit buffer no longer empty? */
|
|
if (count)
|
|
reinit_completion(&dport->xmit_empty);
|
|
spin_unlock(&dport->xmit_lock);
|
|
|
|
/* Wake up the kthread */
|
|
if (total)
|
|
wake_up_interruptible(&priv->waitqueue);
|
|
return total;
|
|
}
|
|
|
|
static int mips_ejtag_fdc_tty_write_room(struct tty_struct *tty)
|
|
{
|
|
struct mips_ejtag_fdc_tty_port *dport = tty->driver_data;
|
|
struct mips_ejtag_fdc_tty *priv = dport->driver;
|
|
int room;
|
|
|
|
/* Report the space in the xmit buffer */
|
|
spin_lock(&dport->xmit_lock);
|
|
room = priv->xmit_size - dport->xmit_cnt;
|
|
spin_unlock(&dport->xmit_lock);
|
|
|
|
return room;
|
|
}
|
|
|
|
static int mips_ejtag_fdc_tty_chars_in_buffer(struct tty_struct *tty)
|
|
{
|
|
struct mips_ejtag_fdc_tty_port *dport = tty->driver_data;
|
|
int chars;
|
|
|
|
/* Report the number of bytes in the xmit buffer */
|
|
spin_lock(&dport->xmit_lock);
|
|
chars = dport->xmit_cnt;
|
|
spin_unlock(&dport->xmit_lock);
|
|
|
|
return chars;
|
|
}
|
|
|
|
static const struct tty_operations mips_ejtag_fdc_tty_ops = {
|
|
.install = mips_ejtag_fdc_tty_install,
|
|
.open = mips_ejtag_fdc_tty_open,
|
|
.close = mips_ejtag_fdc_tty_close,
|
|
.hangup = mips_ejtag_fdc_tty_hangup,
|
|
.write = mips_ejtag_fdc_tty_write,
|
|
.write_room = mips_ejtag_fdc_tty_write_room,
|
|
.chars_in_buffer = mips_ejtag_fdc_tty_chars_in_buffer,
|
|
};
|
|
|
|
int __weak get_c0_fdc_int(void)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
static int mips_ejtag_fdc_tty_probe(struct mips_cdmm_device *dev)
|
|
{
|
|
int ret, nport;
|
|
struct mips_ejtag_fdc_tty_port *dport;
|
|
struct mips_ejtag_fdc_tty *priv;
|
|
struct tty_driver *driver;
|
|
unsigned int cfg, tx_fifo;
|
|
|
|
priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
|
|
if (!priv)
|
|
return -ENOMEM;
|
|
priv->cpu = dev->cpu;
|
|
priv->dev = &dev->dev;
|
|
mips_cdmm_set_drvdata(dev, priv);
|
|
atomic_set(&priv->xmit_total, 0);
|
|
raw_spin_lock_init(&priv->lock);
|
|
|
|
priv->reg = devm_ioremap_nocache(priv->dev, dev->res.start,
|
|
resource_size(&dev->res));
|
|
if (!priv->reg) {
|
|
dev_err(priv->dev, "ioremap failed for resource %pR\n",
|
|
&dev->res);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
cfg = mips_ejtag_fdc_read(priv, REG_FDCFG);
|
|
tx_fifo = (cfg & REG_FDCFG_TXFIFOSIZE) >> REG_FDCFG_TXFIFOSIZE_SHIFT;
|
|
/* Disable interrupts */
|
|
cfg &= ~(REG_FDCFG_TXINTTHRES | REG_FDCFG_RXINTTHRES);
|
|
cfg |= REG_FDCFG_TXINTTHRES_DISABLED;
|
|
cfg |= REG_FDCFG_RXINTTHRES_DISABLED;
|
|
mips_ejtag_fdc_write(priv, REG_FDCFG, cfg);
|
|
|
|
/* Make each port's xmit FIFO big enough to fill FDC TX FIFO */
|
|
priv->xmit_size = min(tx_fifo * 4, (unsigned int)SERIAL_XMIT_SIZE);
|
|
|
|
driver = tty_alloc_driver(NUM_TTY_CHANNELS, TTY_DRIVER_REAL_RAW);
|
|
if (IS_ERR(driver))
|
|
return PTR_ERR(driver);
|
|
priv->driver = driver;
|
|
|
|
driver->driver_name = "ejtag_fdc";
|
|
snprintf(priv->fdc_name, sizeof(priv->fdc_name), "ttyFDC%u", dev->cpu);
|
|
snprintf(priv->driver_name, sizeof(priv->driver_name), "%sc",
|
|
priv->fdc_name);
|
|
driver->name = priv->driver_name;
|
|
driver->major = 0; /* Auto-allocate */
|
|
driver->minor_start = 0;
|
|
driver->type = TTY_DRIVER_TYPE_SERIAL;
|
|
driver->subtype = SERIAL_TYPE_NORMAL;
|
|
driver->init_termios = tty_std_termios;
|
|
driver->init_termios.c_cflag |= CLOCAL;
|
|
driver->driver_state = priv;
|
|
|
|
tty_set_operations(driver, &mips_ejtag_fdc_tty_ops);
|
|
for (nport = 0; nport < NUM_TTY_CHANNELS; nport++) {
|
|
dport = &priv->ports[nport];
|
|
dport->driver = priv;
|
|
tty_port_init(&dport->port);
|
|
dport->port.ops = &mips_ejtag_fdc_tty_port_ops;
|
|
raw_spin_lock_init(&dport->rx_lock);
|
|
spin_lock_init(&dport->xmit_lock);
|
|
/* The xmit buffer starts empty, i.e. completely written */
|
|
init_completion(&dport->xmit_empty);
|
|
complete(&dport->xmit_empty);
|
|
}
|
|
|
|
/* Set up the console */
|
|
mips_ejtag_fdc_con.regs[dev->cpu] = priv->reg;
|
|
if (dev->cpu == 0)
|
|
mips_ejtag_fdc_con.tty_drv = driver;
|
|
|
|
init_waitqueue_head(&priv->waitqueue);
|
|
priv->thread = kthread_create(mips_ejtag_fdc_put, priv, priv->fdc_name);
|
|
if (IS_ERR(priv->thread)) {
|
|
ret = PTR_ERR(priv->thread);
|
|
dev_err(priv->dev, "Couldn't create kthread (%d)\n", ret);
|
|
goto err_destroy_ports;
|
|
}
|
|
/*
|
|
* Bind the writer thread to the right CPU so it can't migrate.
|
|
* The channels are per-CPU and we want all channel I/O to be on a
|
|
* single predictable CPU.
|
|
*/
|
|
kthread_bind(priv->thread, dev->cpu);
|
|
wake_up_process(priv->thread);
|
|
|
|
/* Look for an FDC IRQ */
|
|
priv->irq = get_c0_fdc_int();
|
|
|
|
/* Try requesting the IRQ */
|
|
if (priv->irq >= 0) {
|
|
/*
|
|
* IRQF_SHARED, IRQF_COND_SUSPEND: The FDC IRQ may be shared with
|
|
* other local interrupts such as the timer which sets
|
|
* IRQF_TIMER (including IRQF_NO_SUSPEND).
|
|
*
|
|
* IRQF_NO_THREAD: The FDC IRQ isn't individually maskable so it
|
|
* cannot be deferred and handled by a thread on RT kernels. For
|
|
* this reason any spinlocks used from the ISR are raw.
|
|
*/
|
|
ret = devm_request_irq(priv->dev, priv->irq, mips_ejtag_fdc_isr,
|
|
IRQF_PERCPU | IRQF_SHARED |
|
|
IRQF_NO_THREAD | IRQF_COND_SUSPEND,
|
|
priv->fdc_name, priv);
|
|
if (ret)
|
|
priv->irq = -1;
|
|
}
|
|
if (priv->irq >= 0) {
|
|
/* IRQ is usable, enable RX interrupt */
|
|
raw_spin_lock_irq(&priv->lock);
|
|
cfg = mips_ejtag_fdc_read(priv, REG_FDCFG);
|
|
cfg &= ~REG_FDCFG_RXINTTHRES;
|
|
cfg |= REG_FDCFG_RXINTTHRES_NOTEMPTY;
|
|
mips_ejtag_fdc_write(priv, REG_FDCFG, cfg);
|
|
raw_spin_unlock_irq(&priv->lock);
|
|
} else {
|
|
/* If we didn't get an usable IRQ, poll instead */
|
|
timer_setup(&priv->poll_timer, mips_ejtag_fdc_tty_timer,
|
|
TIMER_PINNED);
|
|
priv->poll_timer.expires = jiffies + FDC_TTY_POLL;
|
|
/*
|
|
* Always attach the timer to the right CPU. The channels are
|
|
* per-CPU so all polling should be from a single CPU.
|
|
*/
|
|
add_timer_on(&priv->poll_timer, dev->cpu);
|
|
|
|
dev_info(priv->dev, "No usable IRQ, polling enabled\n");
|
|
}
|
|
|
|
ret = tty_register_driver(driver);
|
|
if (ret < 0) {
|
|
dev_err(priv->dev, "Couldn't install tty driver (%d)\n", ret);
|
|
goto err_stop_irq;
|
|
}
|
|
|
|
return 0;
|
|
|
|
err_stop_irq:
|
|
if (priv->irq >= 0) {
|
|
raw_spin_lock_irq(&priv->lock);
|
|
cfg = mips_ejtag_fdc_read(priv, REG_FDCFG);
|
|
/* Disable interrupts */
|
|
cfg &= ~(REG_FDCFG_TXINTTHRES | REG_FDCFG_RXINTTHRES);
|
|
cfg |= REG_FDCFG_TXINTTHRES_DISABLED;
|
|
cfg |= REG_FDCFG_RXINTTHRES_DISABLED;
|
|
mips_ejtag_fdc_write(priv, REG_FDCFG, cfg);
|
|
raw_spin_unlock_irq(&priv->lock);
|
|
} else {
|
|
priv->removing = true;
|
|
del_timer_sync(&priv->poll_timer);
|
|
}
|
|
kthread_stop(priv->thread);
|
|
err_destroy_ports:
|
|
if (dev->cpu == 0)
|
|
mips_ejtag_fdc_con.tty_drv = NULL;
|
|
for (nport = 0; nport < NUM_TTY_CHANNELS; nport++) {
|
|
dport = &priv->ports[nport];
|
|
tty_port_destroy(&dport->port);
|
|
}
|
|
put_tty_driver(priv->driver);
|
|
return ret;
|
|
}
|
|
|
|
static int mips_ejtag_fdc_tty_cpu_down(struct mips_cdmm_device *dev)
|
|
{
|
|
struct mips_ejtag_fdc_tty *priv = mips_cdmm_get_drvdata(dev);
|
|
unsigned int cfg;
|
|
|
|
if (priv->irq >= 0) {
|
|
raw_spin_lock_irq(&priv->lock);
|
|
cfg = mips_ejtag_fdc_read(priv, REG_FDCFG);
|
|
/* Disable interrupts */
|
|
cfg &= ~(REG_FDCFG_TXINTTHRES | REG_FDCFG_RXINTTHRES);
|
|
cfg |= REG_FDCFG_TXINTTHRES_DISABLED;
|
|
cfg |= REG_FDCFG_RXINTTHRES_DISABLED;
|
|
mips_ejtag_fdc_write(priv, REG_FDCFG, cfg);
|
|
raw_spin_unlock_irq(&priv->lock);
|
|
} else {
|
|
priv->removing = true;
|
|
del_timer_sync(&priv->poll_timer);
|
|
}
|
|
kthread_stop(priv->thread);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mips_ejtag_fdc_tty_cpu_up(struct mips_cdmm_device *dev)
|
|
{
|
|
struct mips_ejtag_fdc_tty *priv = mips_cdmm_get_drvdata(dev);
|
|
unsigned int cfg;
|
|
int ret = 0;
|
|
|
|
if (priv->irq >= 0) {
|
|
/*
|
|
* IRQ is usable, enable RX interrupt
|
|
* This must be before kthread is restarted, as kthread may
|
|
* enable TX interrupt.
|
|
*/
|
|
raw_spin_lock_irq(&priv->lock);
|
|
cfg = mips_ejtag_fdc_read(priv, REG_FDCFG);
|
|
cfg &= ~(REG_FDCFG_TXINTTHRES | REG_FDCFG_RXINTTHRES);
|
|
cfg |= REG_FDCFG_TXINTTHRES_DISABLED;
|
|
cfg |= REG_FDCFG_RXINTTHRES_NOTEMPTY;
|
|
mips_ejtag_fdc_write(priv, REG_FDCFG, cfg);
|
|
raw_spin_unlock_irq(&priv->lock);
|
|
} else {
|
|
/* Restart poll timer */
|
|
priv->removing = false;
|
|
add_timer_on(&priv->poll_timer, dev->cpu);
|
|
}
|
|
|
|
/* Restart the kthread */
|
|
priv->thread = kthread_create(mips_ejtag_fdc_put, priv, priv->fdc_name);
|
|
if (IS_ERR(priv->thread)) {
|
|
ret = PTR_ERR(priv->thread);
|
|
dev_err(priv->dev, "Couldn't re-create kthread (%d)\n", ret);
|
|
goto out;
|
|
}
|
|
/* Bind it back to the right CPU and set it off */
|
|
kthread_bind(priv->thread, dev->cpu);
|
|
wake_up_process(priv->thread);
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
static const struct mips_cdmm_device_id mips_ejtag_fdc_tty_ids[] = {
|
|
{ .type = 0xfd },
|
|
{ }
|
|
};
|
|
|
|
static struct mips_cdmm_driver mips_ejtag_fdc_tty_driver = {
|
|
.drv = {
|
|
.name = "mips_ejtag_fdc",
|
|
},
|
|
.probe = mips_ejtag_fdc_tty_probe,
|
|
.cpu_down = mips_ejtag_fdc_tty_cpu_down,
|
|
.cpu_up = mips_ejtag_fdc_tty_cpu_up,
|
|
.id_table = mips_ejtag_fdc_tty_ids,
|
|
};
|
|
builtin_mips_cdmm_driver(mips_ejtag_fdc_tty_driver);
|
|
|
|
static int __init mips_ejtag_fdc_init_console(void)
|
|
{
|
|
return mips_ejtag_fdc_console_init(&mips_ejtag_fdc_con);
|
|
}
|
|
console_initcall(mips_ejtag_fdc_init_console);
|
|
|
|
#ifdef CONFIG_MIPS_EJTAG_FDC_EARLYCON
|
|
static struct mips_ejtag_fdc_console mips_ejtag_fdc_earlycon = {
|
|
.cons = {
|
|
.name = "early_fdc",
|
|
.write = mips_ejtag_fdc_console_write,
|
|
.flags = CON_PRINTBUFFER | CON_BOOT,
|
|
.index = CONSOLE_CHANNEL,
|
|
},
|
|
.lock = __RAW_SPIN_LOCK_UNLOCKED(mips_ejtag_fdc_earlycon.lock),
|
|
};
|
|
|
|
int __init setup_early_fdc_console(void)
|
|
{
|
|
return mips_ejtag_fdc_console_init(&mips_ejtag_fdc_earlycon);
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_MIPS_EJTAG_FDC_KGDB
|
|
|
|
/* read buffer to allow decompaction */
|
|
static unsigned int kgdbfdc_rbuflen;
|
|
static unsigned int kgdbfdc_rpos;
|
|
static char kgdbfdc_rbuf[4];
|
|
|
|
/* write buffer to allow compaction */
|
|
static unsigned int kgdbfdc_wbuflen;
|
|
static char kgdbfdc_wbuf[4];
|
|
|
|
static void __iomem *kgdbfdc_setup(void)
|
|
{
|
|
void __iomem *regs;
|
|
unsigned int cpu;
|
|
|
|
/* Find address, piggy backing off console percpu regs */
|
|
cpu = smp_processor_id();
|
|
regs = mips_ejtag_fdc_con.regs[cpu];
|
|
/* First console output on this CPU? */
|
|
if (!regs) {
|
|
regs = mips_cdmm_early_probe(0xfd);
|
|
mips_ejtag_fdc_con.regs[cpu] = regs;
|
|
}
|
|
/* Already tried and failed to find FDC on this CPU? */
|
|
if (IS_ERR(regs))
|
|
return regs;
|
|
|
|
return regs;
|
|
}
|
|
|
|
/* read a character from the read buffer, filling from FDC RX FIFO */
|
|
static int kgdbfdc_read_char(void)
|
|
{
|
|
unsigned int stat, channel, data;
|
|
void __iomem *regs;
|
|
|
|
/* No more data, try and read another FDC word from RX FIFO */
|
|
if (kgdbfdc_rpos >= kgdbfdc_rbuflen) {
|
|
kgdbfdc_rpos = 0;
|
|
kgdbfdc_rbuflen = 0;
|
|
|
|
regs = kgdbfdc_setup();
|
|
if (IS_ERR(regs))
|
|
return NO_POLL_CHAR;
|
|
|
|
/* Read next word from KGDB channel */
|
|
do {
|
|
stat = __raw_readl(regs + REG_FDSTAT);
|
|
|
|
/* No data waiting? */
|
|
if (stat & REG_FDSTAT_RXE)
|
|
return NO_POLL_CHAR;
|
|
|
|
/* Read next word */
|
|
channel = (stat & REG_FDSTAT_RXCHAN) >>
|
|
REG_FDSTAT_RXCHAN_SHIFT;
|
|
data = __raw_readl(regs + REG_FDRX);
|
|
} while (channel != CONFIG_MIPS_EJTAG_FDC_KGDB_CHAN);
|
|
|
|
/* Decode into rbuf */
|
|
kgdbfdc_rbuflen = mips_ejtag_fdc_decode(data, kgdbfdc_rbuf);
|
|
}
|
|
pr_devel("kgdbfdc r %c\n", kgdbfdc_rbuf[kgdbfdc_rpos]);
|
|
return kgdbfdc_rbuf[kgdbfdc_rpos++];
|
|
}
|
|
|
|
/* push an FDC word from write buffer to TX FIFO */
|
|
static void kgdbfdc_push_one(void)
|
|
{
|
|
const char *bufs[1] = { kgdbfdc_wbuf };
|
|
struct fdc_word word;
|
|
void __iomem *regs;
|
|
unsigned int i;
|
|
|
|
/* Construct a word from any data in buffer */
|
|
word = mips_ejtag_fdc_encode(bufs, &kgdbfdc_wbuflen, 1);
|
|
/* Relocate any remaining data to beginnning of buffer */
|
|
kgdbfdc_wbuflen -= word.bytes;
|
|
for (i = 0; i < kgdbfdc_wbuflen; ++i)
|
|
kgdbfdc_wbuf[i] = kgdbfdc_wbuf[i + word.bytes];
|
|
|
|
regs = kgdbfdc_setup();
|
|
if (IS_ERR(regs))
|
|
return;
|
|
|
|
/* Busy wait until there's space in fifo */
|
|
while (__raw_readl(regs + REG_FDSTAT) & REG_FDSTAT_TXF)
|
|
;
|
|
__raw_writel(word.word,
|
|
regs + REG_FDTX(CONFIG_MIPS_EJTAG_FDC_KGDB_CHAN));
|
|
}
|
|
|
|
/* flush the whole write buffer to the TX FIFO */
|
|
static void kgdbfdc_flush(void)
|
|
{
|
|
while (kgdbfdc_wbuflen)
|
|
kgdbfdc_push_one();
|
|
}
|
|
|
|
/* write a character into the write buffer, writing out if full */
|
|
static void kgdbfdc_write_char(u8 chr)
|
|
{
|
|
pr_devel("kgdbfdc w %c\n", chr);
|
|
kgdbfdc_wbuf[kgdbfdc_wbuflen++] = chr;
|
|
if (kgdbfdc_wbuflen >= sizeof(kgdbfdc_wbuf))
|
|
kgdbfdc_push_one();
|
|
}
|
|
|
|
static struct kgdb_io kgdbfdc_io_ops = {
|
|
.name = "kgdbfdc",
|
|
.read_char = kgdbfdc_read_char,
|
|
.write_char = kgdbfdc_write_char,
|
|
.flush = kgdbfdc_flush,
|
|
};
|
|
|
|
static int __init kgdbfdc_init(void)
|
|
{
|
|
kgdb_register_io_module(&kgdbfdc_io_ops);
|
|
return 0;
|
|
}
|
|
early_initcall(kgdbfdc_init);
|
|
#endif
|