2011-08-26 18:04:50 +00:00
|
|
|
/*
|
|
|
|
|
* Synopsys DesignWare 8250 driver.
|
|
|
|
|
*
|
|
|
|
|
* Copyright 2011 Picochip, Jamie Iles.
|
2013-01-10 09:25:10 +00:00
|
|
|
* Copyright 2013 Intel Corporation
|
2011-08-26 18:04:50 +00:00
|
|
|
*
|
|
|
|
|
* This program 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 Synopsys DesignWare 8250 has an extra feature whereby it detects if the
|
|
|
|
|
* LCR is written whilst busy. If it is, then a busy detect interrupt is
|
|
|
|
|
* raised, the LCR needs to be rewritten and the uart status register read.
|
|
|
|
|
*/
|
|
|
|
|
#include <linux/device.h>
|
|
|
|
|
#include <linux/io.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/serial_8250.h>
|
|
|
|
|
#include <linux/serial_core.h>
|
|
|
|
|
#include <linux/serial_reg.h>
|
|
|
|
|
#include <linux/of.h>
|
|
|
|
|
#include <linux/of_irq.h>
|
|
|
|
|
#include <linux/of_platform.h>
|
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
|
#include <linux/slab.h>
|
2013-01-10 09:25:10 +00:00
|
|
|
#include <linux/acpi.h>
|
2013-03-28 23:15:49 +00:00
|
|
|
#include <linux/clk.h>
|
2013-04-10 13:58:28 +00:00
|
|
|
#include <linux/pm_runtime.h>
|
2011-08-26 18:04:50 +00:00
|
|
|
|
2013-06-19 20:37:27 +00:00
|
|
|
#include <asm/byteorder.h>
|
|
|
|
|
|
2013-01-10 09:25:12 +00:00
|
|
|
#include "8250.h"
|
|
|
|
|
|
2013-01-10 09:25:09 +00:00
|
|
|
/* Offsets for the DesignWare specific registers */
|
|
|
|
|
#define DW_UART_USR 0x1f /* UART Status Register */
|
|
|
|
|
#define DW_UART_CPR 0xf4 /* Component Parameter Register */
|
|
|
|
|
#define DW_UART_UCV 0xf8 /* UART Component Version */
|
|
|
|
|
|
|
|
|
|
/* Component Parameter Register bits */
|
|
|
|
|
#define DW_UART_CPR_ABP_DATA_WIDTH (3 << 0)
|
|
|
|
|
#define DW_UART_CPR_AFCE_MODE (1 << 4)
|
|
|
|
|
#define DW_UART_CPR_THRE_MODE (1 << 5)
|
|
|
|
|
#define DW_UART_CPR_SIR_MODE (1 << 6)
|
|
|
|
|
#define DW_UART_CPR_SIR_LP_MODE (1 << 7)
|
|
|
|
|
#define DW_UART_CPR_ADDITIONAL_FEATURES (1 << 8)
|
|
|
|
|
#define DW_UART_CPR_FIFO_ACCESS (1 << 9)
|
|
|
|
|
#define DW_UART_CPR_FIFO_STAT (1 << 10)
|
|
|
|
|
#define DW_UART_CPR_SHADOW (1 << 11)
|
|
|
|
|
#define DW_UART_CPR_ENCODED_PARMS (1 << 12)
|
|
|
|
|
#define DW_UART_CPR_DMA_EXTRA (1 << 13)
|
|
|
|
|
#define DW_UART_CPR_FIFO_MODE (0xff << 16)
|
|
|
|
|
/* Helper for fifo size calculation */
|
|
|
|
|
#define DW_UART_CPR_FIFO_SIZE(a) (((a >> 16) & 0xff) * 16)
|
|
|
|
|
|
|
|
|
|
|
2011-08-26 18:04:50 +00:00
|
|
|
struct dw8250_data {
|
2013-09-05 14:34:53 +00:00
|
|
|
u8 usr_reg;
|
|
|
|
|
int last_mcr;
|
|
|
|
|
int line;
|
|
|
|
|
struct clk *clk;
|
|
|
|
|
struct uart_8250_dma dma;
|
2011-08-26 18:04:50 +00:00
|
|
|
};
|
|
|
|
|
|
2014-04-24 09:46:14 +00:00
|
|
|
struct dw8250_acpi_desc {
|
|
|
|
|
void (*set_termios)(struct uart_port *p, struct ktermios *termios,
|
|
|
|
|
struct ktermios *old);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define BYT_PRV_CLK 0x800
|
|
|
|
|
#define BYT_PRV_CLK_EN (1 << 0)
|
|
|
|
|
#define BYT_PRV_CLK_M_VAL_SHIFT 1
|
|
|
|
|
#define BYT_PRV_CLK_N_VAL_SHIFT 16
|
|
|
|
|
#define BYT_PRV_CLK_UPDATE (1 << 31)
|
|
|
|
|
|
|
|
|
|
static void byt_set_termios(struct uart_port *p, struct ktermios *termios,
|
|
|
|
|
struct ktermios *old)
|
|
|
|
|
{
|
|
|
|
|
unsigned int baud = tty_termios_baud_rate(termios);
|
|
|
|
|
unsigned int m, n;
|
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* For baud rates 0.5M, 1M, 1.5M, 2M, 2.5M, 3M, 3.5M and 4M the
|
|
|
|
|
* dividers must be adjusted.
|
|
|
|
|
*
|
|
|
|
|
* uartclk = (m / n) * 100 MHz, where m <= n
|
|
|
|
|
*/
|
|
|
|
|
switch (baud) {
|
|
|
|
|
case 500000:
|
|
|
|
|
case 1000000:
|
|
|
|
|
case 2000000:
|
|
|
|
|
case 4000000:
|
|
|
|
|
m = 64;
|
|
|
|
|
n = 100;
|
|
|
|
|
p->uartclk = 64000000;
|
|
|
|
|
break;
|
|
|
|
|
case 3500000:
|
|
|
|
|
m = 56;
|
|
|
|
|
n = 100;
|
|
|
|
|
p->uartclk = 56000000;
|
|
|
|
|
break;
|
|
|
|
|
case 1500000:
|
|
|
|
|
case 3000000:
|
|
|
|
|
m = 48;
|
|
|
|
|
n = 100;
|
|
|
|
|
p->uartclk = 48000000;
|
|
|
|
|
break;
|
|
|
|
|
case 2500000:
|
|
|
|
|
m = 40;
|
|
|
|
|
n = 100;
|
|
|
|
|
p->uartclk = 40000000;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
m = 2304;
|
|
|
|
|
n = 3125;
|
|
|
|
|
p->uartclk = 73728000;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Reset the clock */
|
|
|
|
|
reg = (m << BYT_PRV_CLK_M_VAL_SHIFT) | (n << BYT_PRV_CLK_N_VAL_SHIFT);
|
|
|
|
|
writel(reg, p->membase + BYT_PRV_CLK);
|
|
|
|
|
reg |= BYT_PRV_CLK_EN | BYT_PRV_CLK_UPDATE;
|
|
|
|
|
writel(reg, p->membase + BYT_PRV_CLK);
|
|
|
|
|
|
|
|
|
|
serial8250_do_set_termios(p, termios, old);
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-16 20:50:15 +00:00
|
|
|
static inline int dw8250_modify_msr(struct uart_port *p, int offset, int value)
|
|
|
|
|
{
|
|
|
|
|
struct dw8250_data *d = p->private_data;
|
|
|
|
|
|
|
|
|
|
/* If reading MSR, report CTS asserted when auto-CTS/RTS enabled */
|
|
|
|
|
if (offset == UART_MSR && d->last_mcr & UART_MCR_AFE) {
|
|
|
|
|
value |= UART_MSR_CTS;
|
|
|
|
|
value &= ~UART_MSR_DCTS;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
|
serial: 8250_dw: Improve unwritable LCR workaround
When configured with UART_16550_COMPATIBLE=NO or in versions prior to
the introduction of this option, the Designware UART will ignore writes
to the LCR if the UART is busy. The current workaround saves a copy of
the last written LCR and re-writes it in the ISR for a special interrupt
that is raised when a write was ignored.
Unfortunately, interrupts are typically disabled prior to performing a
sequence of register writes that include the LCR so the point at which
the retry occurs is too late. An example is serial8250_do_set_termios()
where an ignored LCR write results in the baud divisor not being set and
instead a garbage character is sent out the transmitter.
Furthermore, since serial_port_out() offers no way to indicate failure,
a serious effort must be made to ensure that the LCR is actually updated
before returning back to the caller. This is difficult, however, as a
UART that was busy during the first attempt is likely to still be busy
when a subsequent attempt is made unless some extra action is taken.
This updated workaround reads back the LCR after each write to confirm
that the new value was accepted by the hardware. Should the hardware
ignore a write, the TX/RX FIFOs are cleared and the receive buffer read
before attempting to rewrite the LCR out of the hope that doing so will
force the UART into an idle state. While this may seem unnecessarily
aggressive, writes to the LCR are used to change the baud rate, parity,
stop bit, or data length so the data that may be lost is likely not
important. Admittedly, this is far from ideal but it seems to be the
best that can be done given the hardware limitations.
Lastly, the revised workaround doesn't touch the LCR in the ISR, so it
avoids the possibility of a "serial8250: too much work for irq" lock up.
This problem is rare in real situations but can be reproduced easily by
wiring up two UARTs and running the following commands.
# stty -F /dev/ttyS1 echo
# stty -F /dev/ttyS2 echo
# cat /dev/ttyS1 &
[1] 375
# echo asdf > /dev/ttyS1
asdf
[ 27.700000] serial8250: too much work for irq96
[ 27.700000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.740000] serial8250: too much work for irq96
Signed-off-by: Tim Kryger <tim.kryger@linaro.org>
Reviewed-by: Matt Porter <matt.porter@linaro.org>
Reviewed-by: Markus Mayer <markus.mayer@linaro.org>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-10-01 17:18:08 +00:00
|
|
|
static void dw8250_force_idle(struct uart_port *p)
|
|
|
|
|
{
|
|
|
|
|
serial8250_clear_and_reinit_fifos(container_of
|
|
|
|
|
(p, struct uart_8250_port, port));
|
|
|
|
|
(void)p->serial_in(p, UART_RX);
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-26 18:04:50 +00:00
|
|
|
static void dw8250_serial_out(struct uart_port *p, int offset, int value)
|
|
|
|
|
{
|
|
|
|
|
struct dw8250_data *d = p->private_data;
|
|
|
|
|
|
2013-08-16 20:50:15 +00:00
|
|
|
if (offset == UART_MCR)
|
|
|
|
|
d->last_mcr = value;
|
|
|
|
|
|
|
|
|
|
writeb(value, p->membase + (offset << p->regshift));
|
serial: 8250_dw: Improve unwritable LCR workaround
When configured with UART_16550_COMPATIBLE=NO or in versions prior to
the introduction of this option, the Designware UART will ignore writes
to the LCR if the UART is busy. The current workaround saves a copy of
the last written LCR and re-writes it in the ISR for a special interrupt
that is raised when a write was ignored.
Unfortunately, interrupts are typically disabled prior to performing a
sequence of register writes that include the LCR so the point at which
the retry occurs is too late. An example is serial8250_do_set_termios()
where an ignored LCR write results in the baud divisor not being set and
instead a garbage character is sent out the transmitter.
Furthermore, since serial_port_out() offers no way to indicate failure,
a serious effort must be made to ensure that the LCR is actually updated
before returning back to the caller. This is difficult, however, as a
UART that was busy during the first attempt is likely to still be busy
when a subsequent attempt is made unless some extra action is taken.
This updated workaround reads back the LCR after each write to confirm
that the new value was accepted by the hardware. Should the hardware
ignore a write, the TX/RX FIFOs are cleared and the receive buffer read
before attempting to rewrite the LCR out of the hope that doing so will
force the UART into an idle state. While this may seem unnecessarily
aggressive, writes to the LCR are used to change the baud rate, parity,
stop bit, or data length so the data that may be lost is likely not
important. Admittedly, this is far from ideal but it seems to be the
best that can be done given the hardware limitations.
Lastly, the revised workaround doesn't touch the LCR in the ISR, so it
avoids the possibility of a "serial8250: too much work for irq" lock up.
This problem is rare in real situations but can be reproduced easily by
wiring up two UARTs and running the following commands.
# stty -F /dev/ttyS1 echo
# stty -F /dev/ttyS2 echo
# cat /dev/ttyS1 &
[1] 375
# echo asdf > /dev/ttyS1
asdf
[ 27.700000] serial8250: too much work for irq96
[ 27.700000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.740000] serial8250: too much work for irq96
Signed-off-by: Tim Kryger <tim.kryger@linaro.org>
Reviewed-by: Matt Porter <matt.porter@linaro.org>
Reviewed-by: Markus Mayer <markus.mayer@linaro.org>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-10-01 17:18:08 +00:00
|
|
|
|
|
|
|
|
/* Make sure LCR write wasn't ignored */
|
|
|
|
|
if (offset == UART_LCR) {
|
|
|
|
|
int tries = 1000;
|
|
|
|
|
while (tries--) {
|
2013-12-10 22:28:04 +00:00
|
|
|
unsigned int lcr = p->serial_in(p, UART_LCR);
|
|
|
|
|
if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
|
serial: 8250_dw: Improve unwritable LCR workaround
When configured with UART_16550_COMPATIBLE=NO or in versions prior to
the introduction of this option, the Designware UART will ignore writes
to the LCR if the UART is busy. The current workaround saves a copy of
the last written LCR and re-writes it in the ISR for a special interrupt
that is raised when a write was ignored.
Unfortunately, interrupts are typically disabled prior to performing a
sequence of register writes that include the LCR so the point at which
the retry occurs is too late. An example is serial8250_do_set_termios()
where an ignored LCR write results in the baud divisor not being set and
instead a garbage character is sent out the transmitter.
Furthermore, since serial_port_out() offers no way to indicate failure,
a serious effort must be made to ensure that the LCR is actually updated
before returning back to the caller. This is difficult, however, as a
UART that was busy during the first attempt is likely to still be busy
when a subsequent attempt is made unless some extra action is taken.
This updated workaround reads back the LCR after each write to confirm
that the new value was accepted by the hardware. Should the hardware
ignore a write, the TX/RX FIFOs are cleared and the receive buffer read
before attempting to rewrite the LCR out of the hope that doing so will
force the UART into an idle state. While this may seem unnecessarily
aggressive, writes to the LCR are used to change the baud rate, parity,
stop bit, or data length so the data that may be lost is likely not
important. Admittedly, this is far from ideal but it seems to be the
best that can be done given the hardware limitations.
Lastly, the revised workaround doesn't touch the LCR in the ISR, so it
avoids the possibility of a "serial8250: too much work for irq" lock up.
This problem is rare in real situations but can be reproduced easily by
wiring up two UARTs and running the following commands.
# stty -F /dev/ttyS1 echo
# stty -F /dev/ttyS2 echo
# cat /dev/ttyS1 &
[1] 375
# echo asdf > /dev/ttyS1
asdf
[ 27.700000] serial8250: too much work for irq96
[ 27.700000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.740000] serial8250: too much work for irq96
Signed-off-by: Tim Kryger <tim.kryger@linaro.org>
Reviewed-by: Matt Porter <matt.porter@linaro.org>
Reviewed-by: Markus Mayer <markus.mayer@linaro.org>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-10-01 17:18:08 +00:00
|
|
|
return;
|
|
|
|
|
dw8250_force_idle(p);
|
|
|
|
|
writeb(value, p->membase + (UART_LCR << p->regshift));
|
|
|
|
|
}
|
|
|
|
|
dev_err(p->dev, "Couldn't set LCR to %d\n", value);
|
|
|
|
|
}
|
2011-08-26 18:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned int dw8250_serial_in(struct uart_port *p, int offset)
|
|
|
|
|
{
|
2013-08-16 20:50:15 +00:00
|
|
|
unsigned int value = readb(p->membase + (offset << p->regshift));
|
2011-08-26 18:04:50 +00:00
|
|
|
|
2013-08-16 20:50:15 +00:00
|
|
|
return dw8250_modify_msr(p, offset, value);
|
2011-08-26 18:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
2013-06-19 20:37:27 +00:00
|
|
|
/* Read Back (rb) version to ensure register access ording. */
|
|
|
|
|
static void dw8250_serial_out_rb(struct uart_port *p, int offset, int value)
|
|
|
|
|
{
|
|
|
|
|
dw8250_serial_out(p, offset, value);
|
|
|
|
|
dw8250_serial_in(p, UART_LCR);
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-26 18:04:50 +00:00
|
|
|
static void dw8250_serial_out32(struct uart_port *p, int offset, int value)
|
|
|
|
|
{
|
|
|
|
|
struct dw8250_data *d = p->private_data;
|
|
|
|
|
|
2013-08-16 20:50:15 +00:00
|
|
|
if (offset == UART_MCR)
|
|
|
|
|
d->last_mcr = value;
|
|
|
|
|
|
|
|
|
|
writel(value, p->membase + (offset << p->regshift));
|
serial: 8250_dw: Improve unwritable LCR workaround
When configured with UART_16550_COMPATIBLE=NO or in versions prior to
the introduction of this option, the Designware UART will ignore writes
to the LCR if the UART is busy. The current workaround saves a copy of
the last written LCR and re-writes it in the ISR for a special interrupt
that is raised when a write was ignored.
Unfortunately, interrupts are typically disabled prior to performing a
sequence of register writes that include the LCR so the point at which
the retry occurs is too late. An example is serial8250_do_set_termios()
where an ignored LCR write results in the baud divisor not being set and
instead a garbage character is sent out the transmitter.
Furthermore, since serial_port_out() offers no way to indicate failure,
a serious effort must be made to ensure that the LCR is actually updated
before returning back to the caller. This is difficult, however, as a
UART that was busy during the first attempt is likely to still be busy
when a subsequent attempt is made unless some extra action is taken.
This updated workaround reads back the LCR after each write to confirm
that the new value was accepted by the hardware. Should the hardware
ignore a write, the TX/RX FIFOs are cleared and the receive buffer read
before attempting to rewrite the LCR out of the hope that doing so will
force the UART into an idle state. While this may seem unnecessarily
aggressive, writes to the LCR are used to change the baud rate, parity,
stop bit, or data length so the data that may be lost is likely not
important. Admittedly, this is far from ideal but it seems to be the
best that can be done given the hardware limitations.
Lastly, the revised workaround doesn't touch the LCR in the ISR, so it
avoids the possibility of a "serial8250: too much work for irq" lock up.
This problem is rare in real situations but can be reproduced easily by
wiring up two UARTs and running the following commands.
# stty -F /dev/ttyS1 echo
# stty -F /dev/ttyS2 echo
# cat /dev/ttyS1 &
[1] 375
# echo asdf > /dev/ttyS1
asdf
[ 27.700000] serial8250: too much work for irq96
[ 27.700000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.740000] serial8250: too much work for irq96
Signed-off-by: Tim Kryger <tim.kryger@linaro.org>
Reviewed-by: Matt Porter <matt.porter@linaro.org>
Reviewed-by: Markus Mayer <markus.mayer@linaro.org>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-10-01 17:18:08 +00:00
|
|
|
|
|
|
|
|
/* Make sure LCR write wasn't ignored */
|
|
|
|
|
if (offset == UART_LCR) {
|
|
|
|
|
int tries = 1000;
|
|
|
|
|
while (tries--) {
|
2013-12-10 22:28:04 +00:00
|
|
|
unsigned int lcr = p->serial_in(p, UART_LCR);
|
|
|
|
|
if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
|
serial: 8250_dw: Improve unwritable LCR workaround
When configured with UART_16550_COMPATIBLE=NO or in versions prior to
the introduction of this option, the Designware UART will ignore writes
to the LCR if the UART is busy. The current workaround saves a copy of
the last written LCR and re-writes it in the ISR for a special interrupt
that is raised when a write was ignored.
Unfortunately, interrupts are typically disabled prior to performing a
sequence of register writes that include the LCR so the point at which
the retry occurs is too late. An example is serial8250_do_set_termios()
where an ignored LCR write results in the baud divisor not being set and
instead a garbage character is sent out the transmitter.
Furthermore, since serial_port_out() offers no way to indicate failure,
a serious effort must be made to ensure that the LCR is actually updated
before returning back to the caller. This is difficult, however, as a
UART that was busy during the first attempt is likely to still be busy
when a subsequent attempt is made unless some extra action is taken.
This updated workaround reads back the LCR after each write to confirm
that the new value was accepted by the hardware. Should the hardware
ignore a write, the TX/RX FIFOs are cleared and the receive buffer read
before attempting to rewrite the LCR out of the hope that doing so will
force the UART into an idle state. While this may seem unnecessarily
aggressive, writes to the LCR are used to change the baud rate, parity,
stop bit, or data length so the data that may be lost is likely not
important. Admittedly, this is far from ideal but it seems to be the
best that can be done given the hardware limitations.
Lastly, the revised workaround doesn't touch the LCR in the ISR, so it
avoids the possibility of a "serial8250: too much work for irq" lock up.
This problem is rare in real situations but can be reproduced easily by
wiring up two UARTs and running the following commands.
# stty -F /dev/ttyS1 echo
# stty -F /dev/ttyS2 echo
# cat /dev/ttyS1 &
[1] 375
# echo asdf > /dev/ttyS1
asdf
[ 27.700000] serial8250: too much work for irq96
[ 27.700000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.740000] serial8250: too much work for irq96
Signed-off-by: Tim Kryger <tim.kryger@linaro.org>
Reviewed-by: Matt Porter <matt.porter@linaro.org>
Reviewed-by: Markus Mayer <markus.mayer@linaro.org>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-10-01 17:18:08 +00:00
|
|
|
return;
|
|
|
|
|
dw8250_force_idle(p);
|
|
|
|
|
writel(value, p->membase + (UART_LCR << p->regshift));
|
|
|
|
|
}
|
|
|
|
|
dev_err(p->dev, "Couldn't set LCR to %d\n", value);
|
|
|
|
|
}
|
2011-08-26 18:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static unsigned int dw8250_serial_in32(struct uart_port *p, int offset)
|
|
|
|
|
{
|
2013-08-16 20:50:15 +00:00
|
|
|
unsigned int value = readl(p->membase + (offset << p->regshift));
|
2011-08-26 18:04:50 +00:00
|
|
|
|
2013-08-16 20:50:15 +00:00
|
|
|
return dw8250_modify_msr(p, offset, value);
|
2011-08-26 18:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int dw8250_handle_irq(struct uart_port *p)
|
|
|
|
|
{
|
|
|
|
|
struct dw8250_data *d = p->private_data;
|
|
|
|
|
unsigned int iir = p->serial_in(p, UART_IIR);
|
|
|
|
|
|
|
|
|
|
if (serial8250_handle_irq(p, iir)) {
|
|
|
|
|
return 1;
|
|
|
|
|
} else if ((iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
|
serial: 8250_dw: Improve unwritable LCR workaround
When configured with UART_16550_COMPATIBLE=NO or in versions prior to
the introduction of this option, the Designware UART will ignore writes
to the LCR if the UART is busy. The current workaround saves a copy of
the last written LCR and re-writes it in the ISR for a special interrupt
that is raised when a write was ignored.
Unfortunately, interrupts are typically disabled prior to performing a
sequence of register writes that include the LCR so the point at which
the retry occurs is too late. An example is serial8250_do_set_termios()
where an ignored LCR write results in the baud divisor not being set and
instead a garbage character is sent out the transmitter.
Furthermore, since serial_port_out() offers no way to indicate failure,
a serious effort must be made to ensure that the LCR is actually updated
before returning back to the caller. This is difficult, however, as a
UART that was busy during the first attempt is likely to still be busy
when a subsequent attempt is made unless some extra action is taken.
This updated workaround reads back the LCR after each write to confirm
that the new value was accepted by the hardware. Should the hardware
ignore a write, the TX/RX FIFOs are cleared and the receive buffer read
before attempting to rewrite the LCR out of the hope that doing so will
force the UART into an idle state. While this may seem unnecessarily
aggressive, writes to the LCR are used to change the baud rate, parity,
stop bit, or data length so the data that may be lost is likely not
important. Admittedly, this is far from ideal but it seems to be the
best that can be done given the hardware limitations.
Lastly, the revised workaround doesn't touch the LCR in the ISR, so it
avoids the possibility of a "serial8250: too much work for irq" lock up.
This problem is rare in real situations but can be reproduced easily by
wiring up two UARTs and running the following commands.
# stty -F /dev/ttyS1 echo
# stty -F /dev/ttyS2 echo
# cat /dev/ttyS1 &
[1] 375
# echo asdf > /dev/ttyS1
asdf
[ 27.700000] serial8250: too much work for irq96
[ 27.700000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.710000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.720000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.730000] serial8250: too much work for irq96
[ 27.740000] serial8250: too much work for irq96
Signed-off-by: Tim Kryger <tim.kryger@linaro.org>
Reviewed-by: Matt Porter <matt.porter@linaro.org>
Reviewed-by: Markus Mayer <markus.mayer@linaro.org>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2013-10-01 17:18:08 +00:00
|
|
|
/* Clear the USR */
|
2013-06-19 20:37:27 +00:00
|
|
|
(void)p->serial_in(p, d->usr_reg);
|
2011-08-26 18:04:50 +00:00
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-10 13:58:28 +00:00
|
|
|
static void
|
|
|
|
|
dw8250_do_pm(struct uart_port *port, unsigned int state, unsigned int old)
|
|
|
|
|
{
|
|
|
|
|
if (!state)
|
|
|
|
|
pm_runtime_get_sync(port->dev);
|
|
|
|
|
|
|
|
|
|
serial8250_do_pm(port, state, old);
|
|
|
|
|
|
|
|
|
|
if (state)
|
|
|
|
|
pm_runtime_put_sync_suspend(port->dev);
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-05 14:34:54 +00:00
|
|
|
static bool dw8250_dma_filter(struct dma_chan *chan, void *param)
|
|
|
|
|
{
|
|
|
|
|
struct dw8250_data *data = param;
|
|
|
|
|
|
|
|
|
|
return chan->chan_id == data->dma.tx_chan_id ||
|
|
|
|
|
chan->chan_id == data->dma.rx_chan_id;
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-19 20:37:27 +00:00
|
|
|
static void dw8250_setup_port(struct uart_8250_port *up)
|
|
|
|
|
{
|
|
|
|
|
struct uart_port *p = &up->port;
|
|
|
|
|
u32 reg = readl(p->membase + DW_UART_UCV);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If the Component Version Register returns zero, we know that
|
|
|
|
|
* ADDITIONAL_FEATURES are not enabled. No need to go any further.
|
|
|
|
|
*/
|
|
|
|
|
if (!reg)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
dev_dbg_ratelimited(p->dev, "Designware UART version %c.%c%c\n",
|
|
|
|
|
(reg >> 24) & 0xff, (reg >> 16) & 0xff, (reg >> 8) & 0xff);
|
|
|
|
|
|
|
|
|
|
reg = readl(p->membase + DW_UART_CPR);
|
|
|
|
|
if (!reg)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Select the type based on fifo */
|
|
|
|
|
if (reg & DW_UART_CPR_FIFO_MODE) {
|
|
|
|
|
p->type = PORT_16550A;
|
|
|
|
|
p->flags |= UPF_FIXED_TYPE;
|
|
|
|
|
p->fifosize = DW_UART_CPR_FIFO_SIZE(reg);
|
|
|
|
|
up->tx_loadsz = p->fifosize;
|
|
|
|
|
up->capabilities = UART_CAP_FIFO;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (reg & DW_UART_CPR_AFCE_MODE)
|
|
|
|
|
up->capabilities |= UART_CAP_AFE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int dw8250_probe_of(struct uart_port *p,
|
|
|
|
|
struct dw8250_data *data)
|
2013-01-10 09:25:08 +00:00
|
|
|
{
|
|
|
|
|
struct device_node *np = p->dev->of_node;
|
|
|
|
|
u32 val;
|
2013-06-19 20:37:27 +00:00
|
|
|
bool has_ucv = true;
|
|
|
|
|
|
|
|
|
|
if (of_device_is_compatible(np, "cavium,octeon-3860-uart")) {
|
|
|
|
|
#ifdef __BIG_ENDIAN
|
|
|
|
|
/*
|
|
|
|
|
* Low order bits of these 64-bit registers, when
|
|
|
|
|
* accessed as a byte, are 7 bytes further down in the
|
|
|
|
|
* address space in big endian mode.
|
|
|
|
|
*/
|
|
|
|
|
p->membase += 7;
|
|
|
|
|
#endif
|
|
|
|
|
p->serial_out = dw8250_serial_out_rb;
|
|
|
|
|
p->flags = ASYNC_SKIP_TEST | UPF_SHARE_IRQ | UPF_FIXED_TYPE;
|
|
|
|
|
p->type = PORT_OCTEON;
|
|
|
|
|
data->usr_reg = 0x27;
|
|
|
|
|
has_ucv = false;
|
|
|
|
|
} else if (!of_property_read_u32(np, "reg-io-width", &val)) {
|
2013-01-10 09:25:08 +00:00
|
|
|
switch (val) {
|
|
|
|
|
case 1:
|
|
|
|
|
break;
|
|
|
|
|
case 4:
|
|
|
|
|
p->iotype = UPIO_MEM32;
|
|
|
|
|
p->serial_in = dw8250_serial_in32;
|
|
|
|
|
p->serial_out = dw8250_serial_out32;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
dev_err(p->dev, "unsupported reg-io-width (%u)\n", val);
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-06-19 20:37:27 +00:00
|
|
|
if (has_ucv)
|
|
|
|
|
dw8250_setup_port(container_of(p, struct uart_8250_port, port));
|
2013-01-10 09:25:08 +00:00
|
|
|
|
|
|
|
|
if (!of_property_read_u32(np, "reg-shift", &val))
|
|
|
|
|
p->regshift = val;
|
|
|
|
|
|
2013-03-28 23:15:49 +00:00
|
|
|
/* clock got configured through clk api, all done */
|
|
|
|
|
if (p->uartclk)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* try to find out clock frequency from DT as fallback */
|
2013-01-10 09:25:08 +00:00
|
|
|
if (of_property_read_u32(np, "clock-frequency", &val)) {
|
2013-03-28 23:15:49 +00:00
|
|
|
dev_err(p->dev, "clk or clock-frequency not defined\n");
|
2013-01-10 09:25:08 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
p->uartclk = val;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-05 14:34:53 +00:00
|
|
|
static int dw8250_probe_acpi(struct uart_8250_port *up,
|
|
|
|
|
struct dw8250_data *data)
|
2013-01-10 09:25:10 +00:00
|
|
|
{
|
|
|
|
|
const struct acpi_device_id *id;
|
2013-04-10 13:58:30 +00:00
|
|
|
struct uart_port *p = &up->port;
|
2014-04-24 09:46:14 +00:00
|
|
|
struct dw8250_acpi_desc *acpi_desc;
|
2013-01-10 09:25:10 +00:00
|
|
|
|
2013-06-19 20:37:27 +00:00
|
|
|
dw8250_setup_port(up);
|
|
|
|
|
|
2013-01-10 09:25:10 +00:00
|
|
|
id = acpi_match_device(p->dev->driver->acpi_match_table, p->dev);
|
|
|
|
|
if (!id)
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
|
|
p->iotype = UPIO_MEM32;
|
|
|
|
|
p->serial_in = dw8250_serial_in32;
|
|
|
|
|
p->serial_out = dw8250_serial_out32;
|
|
|
|
|
p->regshift = 2;
|
2013-04-10 13:58:29 +00:00
|
|
|
|
2013-09-05 14:34:53 +00:00
|
|
|
up->dma = &data->dma;
|
2013-04-10 13:58:30 +00:00
|
|
|
|
|
|
|
|
up->dma->rxconf.src_maxburst = p->fifosize / 4;
|
|
|
|
|
up->dma->txconf.dst_maxburst = p->fifosize / 4;
|
2013-01-10 09:25:12 +00:00
|
|
|
|
2014-04-24 09:46:14 +00:00
|
|
|
acpi_desc = (struct dw8250_acpi_desc *)id->driver_data;
|
|
|
|
|
if (!acpi_desc)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (acpi_desc->set_termios)
|
|
|
|
|
p->set_termios = acpi_desc->set_termios;
|
|
|
|
|
|
2013-01-10 09:25:10 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-19 18:21:50 +00:00
|
|
|
static int dw8250_probe(struct platform_device *pdev)
|
2011-08-26 18:04:50 +00:00
|
|
|
{
|
2012-07-12 11:59:50 +00:00
|
|
|
struct uart_8250_port uart = {};
|
2011-08-26 18:04:50 +00:00
|
|
|
struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
|
struct resource *irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
|
|
|
|
|
struct dw8250_data *data;
|
2013-01-10 09:25:08 +00:00
|
|
|
int err;
|
2011-08-26 18:04:50 +00:00
|
|
|
|
|
|
|
|
if (!regs || !irq) {
|
|
|
|
|
dev_err(&pdev->dev, "no registers/irq defined\n");
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-12 11:59:50 +00:00
|
|
|
spin_lock_init(&uart.port.lock);
|
|
|
|
|
uart.port.mapbase = regs->start;
|
|
|
|
|
uart.port.irq = irq->start;
|
|
|
|
|
uart.port.handle_irq = dw8250_handle_irq;
|
2013-04-10 13:58:28 +00:00
|
|
|
uart.port.pm = dw8250_do_pm;
|
2012-07-12 11:59:50 +00:00
|
|
|
uart.port.type = PORT_8250;
|
2013-01-10 09:25:07 +00:00
|
|
|
uart.port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_FIXED_PORT;
|
2012-07-12 11:59:50 +00:00
|
|
|
uart.port.dev = &pdev->dev;
|
2011-08-26 18:04:50 +00:00
|
|
|
|
2013-04-11 12:43:21 +00:00
|
|
|
uart.port.membase = devm_ioremap(&pdev->dev, regs->start,
|
|
|
|
|
resource_size(regs));
|
2013-01-10 09:25:07 +00:00
|
|
|
if (!uart.port.membase)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2013-03-28 23:15:49 +00:00
|
|
|
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
|
|
|
|
|
if (!data)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2013-06-19 20:37:27 +00:00
|
|
|
data->usr_reg = DW_UART_USR;
|
2013-03-28 23:15:49 +00:00
|
|
|
data->clk = devm_clk_get(&pdev->dev, NULL);
|
|
|
|
|
if (!IS_ERR(data->clk)) {
|
|
|
|
|
clk_prepare_enable(data->clk);
|
|
|
|
|
uart.port.uartclk = clk_get_rate(data->clk);
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-05 14:34:54 +00:00
|
|
|
data->dma.rx_chan_id = -1;
|
|
|
|
|
data->dma.tx_chan_id = -1;
|
|
|
|
|
data->dma.rx_param = data;
|
|
|
|
|
data->dma.tx_param = data;
|
|
|
|
|
data->dma.fn = dw8250_dma_filter;
|
|
|
|
|
|
2012-07-12 11:59:50 +00:00
|
|
|
uart.port.iotype = UPIO_MEM;
|
|
|
|
|
uart.port.serial_in = dw8250_serial_in;
|
|
|
|
|
uart.port.serial_out = dw8250_serial_out;
|
2013-03-28 23:15:49 +00:00
|
|
|
uart.port.private_data = data;
|
2013-01-10 09:25:08 +00:00
|
|
|
|
|
|
|
|
if (pdev->dev.of_node) {
|
2013-06-19 20:37:27 +00:00
|
|
|
err = dw8250_probe_of(&uart.port, data);
|
2013-01-10 09:25:08 +00:00
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-01-10 09:25:10 +00:00
|
|
|
} else if (ACPI_HANDLE(&pdev->dev)) {
|
2013-09-05 14:34:53 +00:00
|
|
|
err = dw8250_probe_acpi(&uart, data);
|
2013-01-10 09:25:10 +00:00
|
|
|
if (err)
|
|
|
|
|
return err;
|
2013-01-10 09:25:08 +00:00
|
|
|
} else {
|
|
|
|
|
return -ENODEV;
|
2011-08-26 18:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
2012-07-12 11:59:50 +00:00
|
|
|
data->line = serial8250_register_8250_port(&uart);
|
2011-08-26 18:04:50 +00:00
|
|
|
if (data->line < 0)
|
|
|
|
|
return data->line;
|
|
|
|
|
|
|
|
|
|
platform_set_drvdata(pdev, data);
|
|
|
|
|
|
2013-04-10 13:58:28 +00:00
|
|
|
pm_runtime_set_active(&pdev->dev);
|
|
|
|
|
pm_runtime_enable(&pdev->dev);
|
|
|
|
|
|
2011-08-26 18:04:50 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-19 18:26:18 +00:00
|
|
|
static int dw8250_remove(struct platform_device *pdev)
|
2011-08-26 18:04:50 +00:00
|
|
|
{
|
|
|
|
|
struct dw8250_data *data = platform_get_drvdata(pdev);
|
|
|
|
|
|
2013-04-10 13:58:28 +00:00
|
|
|
pm_runtime_get_sync(&pdev->dev);
|
|
|
|
|
|
2011-08-26 18:04:50 +00:00
|
|
|
serial8250_unregister_port(data->line);
|
|
|
|
|
|
2013-03-28 23:15:49 +00:00
|
|
|
if (!IS_ERR(data->clk))
|
|
|
|
|
clk_disable_unprepare(data->clk);
|
|
|
|
|
|
2013-04-10 13:58:28 +00:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
|
|
|
|
pm_runtime_put_noidle(&pdev->dev);
|
|
|
|
|
|
2011-08-26 18:04:50 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-16 12:55:57 +00:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2013-04-10 13:58:28 +00:00
|
|
|
static int dw8250_suspend(struct device *dev)
|
2012-10-15 09:25:58 +00:00
|
|
|
{
|
2013-04-10 13:58:28 +00:00
|
|
|
struct dw8250_data *data = dev_get_drvdata(dev);
|
2012-10-15 09:25:58 +00:00
|
|
|
|
|
|
|
|
serial8250_suspend_port(data->line);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-10 13:58:28 +00:00
|
|
|
static int dw8250_resume(struct device *dev)
|
2012-10-15 09:25:58 +00:00
|
|
|
{
|
2013-04-10 13:58:28 +00:00
|
|
|
struct dw8250_data *data = dev_get_drvdata(dev);
|
2012-10-15 09:25:58 +00:00
|
|
|
|
|
|
|
|
serial8250_resume_port(data->line);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2014-01-16 12:55:57 +00:00
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
2012-10-15 09:25:58 +00:00
|
|
|
|
2013-04-10 13:58:28 +00:00
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
|
|
|
static int dw8250_runtime_suspend(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct dw8250_data *data = dev_get_drvdata(dev);
|
|
|
|
|
|
2013-05-07 11:27:16 +00:00
|
|
|
if (!IS_ERR(data->clk))
|
|
|
|
|
clk_disable_unprepare(data->clk);
|
2013-04-10 13:58:28 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int dw8250_runtime_resume(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct dw8250_data *data = dev_get_drvdata(dev);
|
|
|
|
|
|
2013-05-07 11:27:16 +00:00
|
|
|
if (!IS_ERR(data->clk))
|
|
|
|
|
clk_prepare_enable(data->clk);
|
2013-04-10 13:58:28 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static const struct dev_pm_ops dw8250_pm_ops = {
|
|
|
|
|
SET_SYSTEM_SLEEP_PM_OPS(dw8250_suspend, dw8250_resume)
|
|
|
|
|
SET_RUNTIME_PM_OPS(dw8250_runtime_suspend, dw8250_runtime_resume, NULL)
|
|
|
|
|
};
|
|
|
|
|
|
2013-01-10 09:25:08 +00:00
|
|
|
static const struct of_device_id dw8250_of_match[] = {
|
2011-08-26 18:04:50 +00:00
|
|
|
{ .compatible = "snps,dw-apb-uart" },
|
2013-06-19 20:37:27 +00:00
|
|
|
{ .compatible = "cavium,octeon-3860-uart" },
|
2011-08-26 18:04:50 +00:00
|
|
|
{ /* Sentinel */ }
|
|
|
|
|
};
|
2013-01-10 09:25:08 +00:00
|
|
|
MODULE_DEVICE_TABLE(of, dw8250_of_match);
|
2011-08-26 18:04:50 +00:00
|
|
|
|
2014-04-24 09:46:14 +00:00
|
|
|
static struct dw8250_acpi_desc byt_8250_desc = {
|
|
|
|
|
.set_termios = byt_set_termios,
|
|
|
|
|
};
|
|
|
|
|
|
2013-01-10 09:25:10 +00:00
|
|
|
static const struct acpi_device_id dw8250_acpi_match[] = {
|
2013-04-10 13:58:29 +00:00
|
|
|
{ "INT33C4", 0 },
|
|
|
|
|
{ "INT33C5", 0 },
|
2013-12-10 10:56:59 +00:00
|
|
|
{ "INT3434", 0 },
|
|
|
|
|
{ "INT3435", 0 },
|
2014-04-24 09:46:14 +00:00
|
|
|
{ "80860F0A", (kernel_ulong_t)&byt_8250_desc},
|
2013-01-10 09:25:10 +00:00
|
|
|
{ },
|
|
|
|
|
};
|
|
|
|
|
MODULE_DEVICE_TABLE(acpi, dw8250_acpi_match);
|
|
|
|
|
|
2011-08-26 18:04:50 +00:00
|
|
|
static struct platform_driver dw8250_platform_driver = {
|
|
|
|
|
.driver = {
|
|
|
|
|
.name = "dw-apb-uart",
|
|
|
|
|
.owner = THIS_MODULE,
|
2013-04-10 13:58:28 +00:00
|
|
|
.pm = &dw8250_pm_ops,
|
2013-01-10 09:25:08 +00:00
|
|
|
.of_match_table = dw8250_of_match,
|
2013-01-10 09:25:10 +00:00
|
|
|
.acpi_match_table = ACPI_PTR(dw8250_acpi_match),
|
2011-08-26 18:04:50 +00:00
|
|
|
},
|
|
|
|
|
.probe = dw8250_probe,
|
2012-11-19 18:21:34 +00:00
|
|
|
.remove = dw8250_remove,
|
2011-08-26 18:04:50 +00:00
|
|
|
};
|
|
|
|
|
|
2011-11-28 11:22:15 +00:00
|
|
|
module_platform_driver(dw8250_platform_driver);
|
2011-08-26 18:04:50 +00:00
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Jamie Iles");
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
MODULE_DESCRIPTION("Synopsys DesignWare 8250 serial port driver");
|