stuartl/adv950
1
0
Fork 0
mirror of https://github.com/sjlongland/adv950.git synced 2025-09-13 10:43:14 +10:00
Code Issues Releases Wiki Activity

Rename symbols

Browse Source 
Avoid possible clashes with the 8250 driver, now that we've effectively
forked it.
This commit is contained in:
Stuart Longland 2017-03-05 16:13:21 +10:00
parent ac28b5fe5b
commit 87e8c9d69b
Signed by: stuartl
GPG Key ID: 4DFA191410BDE3B7
4 changed files with 85 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
driver/adv950_base.c
View File

@ -194,7 +194,7 @@ static DEFINE_MUTEX(hash_mutex); /* Used to walk the hash */
/*
* Here we define the default xmit fifo size used for each type of UART.
*/
static const struct serial8250_config uart_config[] = {
static const struct adv950_uart_config uart_config[] = {
[PORT_UNKNOWN] = {
.name = "unknown",
.fifo_size = 1,
@ -1603,7 +1603,7 @@ static void transmit_chars(struct uart_adv950_port *up)
}
if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
adv_uart_write_wakeup(&up->port);
adv950_uart_write_wakeup(&up->port);
DEBUG_INTR("THRE...");
@ -2904,7 +2904,7 @@ static void __init adv950_register_ports(struct uart_driver *drv)
up->mcr_mask = ~ALPHA_KLUDGE_MCR;
up->mcr_force = ALPHA_KLUDGE_MCR;
adv_uart_add_one_port(drv, &up->port);
adv950_uart_add_one_port(drv, &up->port);
}
}
@ -2972,7 +2972,7 @@ int __init early_serial_setup(struct uart_port *port)
*/
void adv950_suspend_port(int line)
{
adv_uart_suspend_port(&adv950_reg, &adv950_ports[line].port);
adv950_uart_suspend_port(&adv950_reg, &adv950_ports[line].port);
}
/**
@ -2994,7 +2994,7 @@ void adv950_resume_port(int line)
serial_outp(up, UART_LCR, 0);
up->port.uartclk = 921600*16;
}
adv_uart_resume_port(&adv950_reg, &up->port);
adv950_uart_resume_port(&adv950_reg, &up->port);
}
@ -3020,7 +3020,7 @@ static struct uart_adv950_port *adv950_find_match_or_unused(struct uart_port *po
* First, find a port entry which matches.
*/
for (i = 0; i < nr_uarts; i++)
if (adv_uart_match_port(&adv950_ports[i].port, port))
if (adv950_uart_match_port(&adv950_ports[i].port, port))
return &adv950_ports[i];
/*
@ -3059,7 +3059,7 @@ static struct uart_adv950_port *adv950_find_match_or_unused(struct uart_port *po
*
* On success the port is ready to use and the line number is returned.
*/
extern void uart_configure_port(struct uart_driver *drv, struct uart_state *state,
extern void adv950_uart_configure_port(struct uart_driver *drv, struct uart_state *state,
struct uart_port *port);
int adv950_register_port(struct uart_port *port)
{
@ -3105,7 +3105,7 @@ int adv950_register_port(struct uart_port *port)
uart->port.set_termios = port->set_termios;
if (port->pm)
uart->port.pm = port->pm;
uart_configure_port(&adv950_reg, uart->port.state, &uart->port);
adv950_uart_configure_port(&adv950_reg, uart->port.state, &uart->port);
//if (ret == 0)
ret = uart->port.line;
}
@ -3127,13 +3127,13 @@ void adv950_unregister_port(int line)
struct uart_adv950_port *uart = &adv950_ports[line];
mutex_lock(&serial_mutex);
adv_uart_remove_one_port(&adv950_reg, &uart->port);
adv950_uart_remove_one_port(&adv950_reg, &uart->port);
if (adv950_isa_devs) {
uart->port.flags &= ~UPF_BOOT_AUTOCONF;
uart->port.type = PORT_UNKNOWN;
uart->port.dev = &adv950_isa_devs->dev;
uart->capabilities = uart_config[uart->port.type].flags;
adv_uart_add_one_port(&adv950_reg, &uart->port);
adv950_uart_add_one_port(&adv950_reg, &uart->port);
} else {
uart->port.dev = NULL;
}
@ -3153,7 +3153,7 @@ int adv950_init(void)
share_irqs ? "en" : "dis");
adv950_reg.nr = UART_NR;
ret = adv_uart_register_driver(&adv950_reg);
ret = adv950_uart_register_driver(&adv950_reg);
if (ret)
goto out;
@ -3174,10 +3174,10 @@ void __exit adv950_exit(void)
{
state = ((struct uart_driver*)(&adv950_reg))->state + ((struct uart_port *)(&adv950_ports[i].port))->line;
if (state->uart_port != NULL)
adv_uart_remove_one_port(&adv950_reg, &adv950_ports[i].port);
adv950_uart_remove_one_port(&adv950_reg, &adv950_ports[i].port);
}
adv_uart_unregister_driver(&adv950_reg);
adv950_uart_unregister_driver(&adv950_reg);
}
EXPORT_SYMBOL(adv950_unregister_port);

39
driver/adv950_base.h
View File

@ -12,26 +12,25 @@
*/
#include <linux/serial_8250.h>
void adv_uart_write_wakeup(struct uart_port *port);
int adv_uart_resume_port(struct uart_driver *drv, struct uart_port *uport);
void adv_serial8250_resume_port(int line);
int adv_uart_suspend_port(struct uart_driver *drv, struct uart_port *uport);
void adv_serial8250_suspend_port(int line);
void adv_uart_configure_port(struct uart_driver *drv, struct uart_state *state,
void adv950_uart_write_wakeup(struct uart_port *port);
int adv950_uart_resume_port(struct uart_driver *drv, struct uart_port *uport);
void adv950_resume_port(int line);
int adv950_uart_suspend_port(struct uart_driver *drv, struct uart_port *uport);
void adv950_suspend_port(int line);
void adv950_uart_configure_port(struct uart_driver *drv, struct uart_state *state,
struct uart_port *port);
int adv_uart_match_port(struct uart_port *port1, struct uart_port *port2);
int adv_serial8250_register_port(struct uart_port *port);
int __init adv_serial8250_init(void);
int adv_uart_register_driver(struct uart_driver *drv);
int adv_uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport);
int adv_uart_register_driver(struct uart_driver *drv);
int adv_uart_add_one_port(struct uart_driver *drv, struct uart_port *uport);
void __exit adv_serial8250_exit(void);
void adv_uart_unregister_driver(struct uart_driver *drv);
void adv_serial8250_unregister_port(int line);
unsigned int
adv_uart_get_divisor(struct uart_port *port, unsigned int baud);
void uart_configure_port(struct uart_driver *drv, struct uart_state *state,
int adv950_uart_match_port(struct uart_port *port1, struct uart_port *port2);
int adv950_uart_register_port(struct uart_port *port);
int __init adv950_uart_init(void);
int adv950_uart_register_driver(struct uart_driver *drv);
int adv950_uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport);
int adv950_uart_register_driver(struct uart_driver *drv);
int adv950_uart_add_one_port(struct uart_driver *drv, struct uart_port *uport);
void __exit adv950_uart_exit(void);
void adv950_uart_unregister_driver(struct uart_driver *drv);
void adv950_uart_unregister_port(int line);
unsigned int adv950_uart_get_divisor(struct uart_port *port, unsigned int baud);
void adv950_uart_configure_port(struct uart_driver *drv, struct uart_state *state,
struct uart_port *port);
struct old_serial_port {
@ -50,7 +49,7 @@ struct old_serial_port {
/*
* This replaces serial_uart_config in include/linux/serial.h
*/
struct serial8250_config {
struct adv950_uart_config {
const char *name;
unsigned short fifo_size;
unsigned short tx_loadsz;

64
driver/adv950_core.c
View File

@ -61,7 +61,7 @@ static void uart_change_pm(struct uart_state *state, int pm_state);
* This routine is used by the interrupt handler to schedule processing in
* the software interrupt portion of the driver.
*/
void adv_uart_write_wakeup(struct uart_port *port)
void adv950_uart_write_wakeup(struct uart_port *port)
{
struct uart_state *state = port->state;
/*
@ -259,7 +259,7 @@ static void uart_shutdown(struct tty_struct *tty, struct uart_state *state)
* reflect the actual hardware settings.
*/
void
adv_uart_update_timeout(struct uart_port *port, unsigned int cflag,
adv950_uart_update_timeout(struct uart_port *port, unsigned int cflag,
unsigned int baud)
{
unsigned int bits;
@ -297,7 +297,7 @@ adv_uart_update_timeout(struct uart_port *port, unsigned int cflag,
port->timeout = (HZ * bits) / baud + HZ/50;
}
EXPORT_SYMBOL(adv_uart_update_timeout);
EXPORT_SYMBOL(adv950_uart_update_timeout);
/**
* uart_get_baud_rate - return baud rate for a particular port
@ -319,7 +319,7 @@ EXPORT_SYMBOL(adv_uart_update_timeout);
* where B0 is requested ("hang up").
*/
unsigned int
adv_uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
adv950_uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
struct ktermios *old, unsigned int min, unsigned int max)
{
unsigned int try, baud, altbaud = 38400;
@ -388,7 +388,7 @@ adv_uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
return 0;
}
EXPORT_SYMBOL(adv_uart_get_baud_rate);
EXPORT_SYMBOL(adv950_uart_get_baud_rate);
/**
* uart_get_divisor - return uart clock divisor
@ -398,7 +398,7 @@ EXPORT_SYMBOL(adv_uart_get_baud_rate);
* Calculate the uart clock divisor for the port.
*/
unsigned int
adv_uart_get_divisor(struct uart_port *port, unsigned int baud)
adv950_uart_get_divisor(struct uart_port *port, unsigned int baud)
{
unsigned int quot;
@ -413,7 +413,7 @@ adv_uart_get_divisor(struct uart_port *port, unsigned int baud)
return quot;
}
EXPORT_SYMBOL(adv_uart_get_divisor);
EXPORT_SYMBOL(adv950_uart_get_divisor);
/* FIXME: Consistent locking policy */
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
@ -1696,7 +1696,7 @@ static const struct file_operations uart_proc_fops = {
* @count: number of characters in string to write
* @write: function to write character to port
*/
void adv_uart_console_write(struct uart_port *port, const char *s,
void adv950_uart_console_write(struct uart_port *port, const char *s,
unsigned int count,
void (*putchar)(struct uart_port *, int))
{
@ -1745,7 +1745,7 @@ uart_get_console(struct uart_port *ports, int nr, struct console *co)
* eg: 115200n8r
*/
void
adv_uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
adv950_uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
{
char *s = options;
@ -1791,7 +1791,7 @@ static const struct baud_rates baud_rates[] = {
* @flow: flow control character - 'r' (rts)
*/
int
adv_uart_set_options(struct uart_port *port, struct console *co,
adv950_uart_set_options(struct uart_port *port, struct console *co,
int baud, int parity, int bits, int flow)
{
struct ktermios termios;
@ -1880,7 +1880,7 @@ static int serial_match_port(struct device *dev, void *data)
return dev->devt == devt; /* Actually, only one tty per port */
}
int adv_uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
int adv950_uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
{
struct uart_state *state = drv->state + uport->line;
struct tty_port *port = &state->port;
@ -1946,7 +1946,7 @@ int adv_uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
return 0;
}
int adv_uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
int adv950_uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
{
struct uart_state *state = drv->state + uport->line;
struct tty_port *port = &state->port;
@ -2059,7 +2059,7 @@ uart_report_port(struct uart_driver *drv, struct uart_port *port)
void
uart_configure_port(struct uart_driver *drv, struct uart_state *state,
adv950_uart_configure_port(struct uart_driver *drv, struct uart_state *state,
struct uart_port *port)
{
unsigned int flags;
@ -2144,8 +2144,8 @@ static int uart_poll_init(struct tty_driver *driver, int line, char *options)
return -1;
if (options) {
adv_uart_parse_options(options, &baud, &parity, &bits, &flow);
return adv_uart_set_options(port, NULL, baud, parity, bits, flow);
adv950_uart_parse_options(options, &baud, &parity, &bits, &flow);
return adv950_uart_set_options(port, NULL, baud, parity, bits, flow);
}
return 0;
@ -2229,7 +2229,7 @@ static const struct tty_port_operations uart_port_ops = {
* drv->port should be NULL, and the per-port structures should be
* registered using uart_add_one_port after this call has succeeded.
*/
int adv_uart_register_driver(struct uart_driver *drv)
int adv950_uart_register_driver(struct uart_driver *drv)
{
struct tty_driver *normal;
int i, retval;
@ -2297,7 +2297,7 @@ out:
* uart_remove_one_port() if it registered them with uart_add_one_port().
* (ie, drv->port == NULL)
*/
void adv_uart_unregister_driver(struct uart_driver *drv)
void adv950_uart_unregister_driver(struct uart_driver *drv)
{
struct tty_driver *p = drv->tty_driver;
tty_unregister_driver(p);
@ -2323,7 +2323,7 @@ struct tty_driver *uart_console_device(struct console *co, int *index)
* level uart drivers to expand uart_port, rather than having yet
* more levels of structures.
*/
int adv_uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
int adv950_uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
{
struct uart_state *state;
struct tty_port *port;
@ -2360,7 +2360,7 @@ int adv_uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
lockdep_set_class(&uport->lock, &port_lock_key);
}
uart_configure_port(drv, state, uport);
adv950_uart_configure_port(drv, state, uport);
/*
* Register the port whether it's detected or not. This allows
@ -2395,7 +2395,7 @@ int adv_uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
* core driver. No further calls will be made to the low-level code
* for this port.
*/
int adv_uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
int adv950_uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
{
struct uart_state *state = drv->state + uport->line;
struct tty_port *port = &state->port;
@ -2444,7 +2444,7 @@ int adv_uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
/*
* Are the two ports equivalent?
*/
int adv_uart_match_port(struct uart_port *port1, struct uart_port *port2)
int adv950_uart_match_port(struct uart_port *port1, struct uart_port *port2)
{
if (port1->iotype != port2->iotype)
return 0;
@ -2463,17 +2463,17 @@ int adv_uart_match_port(struct uart_port *port1, struct uart_port *port2)
}
return 0;
}
EXPORT_SYMBOL_GPL(adv_uart_console_write);
EXPORT_SYMBOL_GPL(adv_uart_parse_options);
EXPORT_SYMBOL_GPL(adv_uart_set_options);
EXPORT_SYMBOL(adv_uart_match_port);
EXPORT_SYMBOL(adv_uart_write_wakeup);
EXPORT_SYMBOL(adv_uart_register_driver);
EXPORT_SYMBOL(adv_uart_unregister_driver);
EXPORT_SYMBOL(adv_uart_suspend_port);
EXPORT_SYMBOL(adv_uart_resume_port);
EXPORT_SYMBOL(adv_uart_add_one_port);
EXPORT_SYMBOL(adv_uart_remove_one_port);
EXPORT_SYMBOL_GPL(adv950_uart_console_write);
EXPORT_SYMBOL_GPL(adv950_uart_parse_options);
EXPORT_SYMBOL_GPL(adv950_uart_set_options);
EXPORT_SYMBOL(adv950_uart_match_port);
EXPORT_SYMBOL(adv950_uart_write_wakeup);
EXPORT_SYMBOL(adv950_uart_register_driver);
EXPORT_SYMBOL(adv950_uart_unregister_driver);
EXPORT_SYMBOL(adv950_uart_suspend_port);
EXPORT_SYMBOL(adv950_uart_resume_port);
EXPORT_SYMBOL(adv950_uart_add_one_port);
EXPORT_SYMBOL(adv950_uart_remove_one_port);
MODULE_DESCRIPTION("Advantech Serial driver core");
MODULE_LICENSE("GPL");

42
driver/adv950_pci.c
View File

@ -1438,7 +1438,7 @@ serial_pci_matches(const struct pciserial_board *board,
}
struct serial_private *
adv_pciserial_init_ports(struct pci_dev *dev, const struct pciserial_board *board)
adv950_uart_pci_init_ports(struct pci_dev *dev, const struct pciserial_board *board)
{
struct uart_port serial_port;
struct serial_private *priv;
@ -1494,7 +1494,7 @@ adv_pciserial_init_ports(struct pci_dev *dev, const struct pciserial_board *boar
serial_port.iobase, serial_port.irq, serial_port.iotype);
#endif
priv->line[i] = adv_serial8250_register_port(&serial_port);
priv->line[i] = adv950_uart_register_port(&serial_port);
//printk("port->unused[0] = %d\n",serial_port.unused[0]);
if (priv->line[i] < 0) {
printk(KERN_WARNING "Couldn't register serial port %s: %d\n", pci_name(dev), priv->line[i]);
@ -1512,12 +1512,12 @@ err_out:
}
void adv_pciserial_remove_ports(struct serial_private *priv)
void adv950_uart_pci_remove_ports(struct serial_private *priv)
{
struct pci_serial_quirk *quirk;
int i;
for (i = 0; i < priv->nr; i++)
adv_serial8250_unregister_port(priv->line[i]);
adv950_uart_unregister_port(priv->line[i]);
for (i = 0; i < PCI_NUM_BAR_RESOURCES; i++) {
if (priv->remapped_bar[i])
@ -1536,17 +1536,17 @@ void adv_pciserial_remove_ports(struct serial_private *priv)
}
void adv_pciserial_suspend_ports(struct serial_private *priv)
void adv950_uart_pci_suspend_ports(struct serial_private *priv)
{
int i;
for (i = 0; i < priv->nr; i++)
if (priv->line[i] >= 0)
adv_serial8250_suspend_port(priv->line[i]);
adv950_suspend_port(priv->line[i]);
}
void adv_pciserial_resume_ports(struct serial_private *priv)
void adv950_uart_pci_resume_ports(struct serial_private *priv)
{
int i;
@ -1558,7 +1558,7 @@ void adv_pciserial_resume_ports(struct serial_private *priv)
for (i = 0; i < priv->nr; i++)
if (priv->line[i] >= 0)
adv_serial8250_resume_port(priv->line[i]);
adv950_resume_port(priv->line[i]);
}
@ -1615,7 +1615,7 @@ pciserial_init_one(struct pci_dev *dev, const struct pci_device_id *ent)
dev);
}
priv = adv_pciserial_init_ports(dev, board);
priv = adv950_uart_pci_init_ports(dev, board);
if (!IS_ERR(priv)) {
pci_set_drvdata(dev, priv);
return 0;
@ -1634,7 +1634,7 @@ static void pciserial_remove_one(struct pci_dev *dev)
pci_set_drvdata(dev, NULL);
adv_pciserial_remove_ports(priv);
adv950_uart_pci_remove_ports(priv);
pci_disable_device(dev);
}
@ -1668,7 +1668,7 @@ static int pciserial_resume_one(struct pci_dev *dev)
/* FIXME: We cannot simply error out here */
if (err)
printk(KERN_ERR "pciserial: Unable to re-enable ports, trying to continue.\n");
adv_pciserial_resume_ports(priv);
adv950_uart_pci_resume_ports(priv);
}
return 0;
}
@ -1818,7 +1818,7 @@ static struct pci_driver serial_pci_driver = {
.id_table = serial_pci_tbl,
};
static int __init adv_serial8250_pci_init(void)
static int __init adv950_uart_pci_init(void)
{
printk("\n");
printk("==========================================================="
@ -1849,23 +1849,23 @@ static int __init adv_serial8250_pci_init(void)
printk("Advantech Industrial Automation Group.\n");
printk("==========================================================="
"====\n");
if(adv_serial8250_init() >= 0)
if(adv950_uart_init() >= 0)
return pci_register_driver(&serial_pci_driver);
return -ENODEV;
}
static void __exit adv_serial8250_pci_exit(void)
static void __exit adv950_uart_pci_exit(void)
{
pci_unregister_driver(&serial_pci_driver);
adv_serial8250_exit();
adv950_uart_exit();
}
EXPORT_SYMBOL_GPL(adv_pciserial_remove_ports);
EXPORT_SYMBOL_GPL(adv_pciserial_suspend_ports);
EXPORT_SYMBOL_GPL(adv_pciserial_resume_ports);
EXPORT_SYMBOL_GPL(adv_pciserial_init_ports);
EXPORT_SYMBOL_GPL(adv950_uart_pci_remove_ports);
EXPORT_SYMBOL_GPL(adv950_uart_pci_suspend_ports);
EXPORT_SYMBOL_GPL(adv950_uart_pci_resume_ports);
EXPORT_SYMBOL_GPL(adv950_uart_pci_init_ports);
module_init(adv_serial8250_pci_init);
module_exit(adv_serial8250_pci_exit);
module_init(adv950_uart_pci_init);
module_exit(adv950_uart_pci_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Generic 8250/16x50 PCI serial probe module");