stuartl/adv950
1
0
Fork 0
mirror of https://github.com/sjlongland/adv950.git synced 2025-09-14 03:03:15 +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. * 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] = { [PORT_UNKNOWN] = {
.name = "unknown", .name = "unknown",
.fifo_size = 1, .fifo_size = 1,
@ -1603,7 +1603,7 @@ static void transmit_chars(struct uart_adv950_port *up)
} }
if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
adv_uart_write_wakeup(&up->port); adv950_uart_write_wakeup(&up->port);
DEBUG_INTR("THRE..."); 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_mask = ~ALPHA_KLUDGE_MCR;
up->mcr_force = 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) 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); serial_outp(up, UART_LCR, 0);
up->port.uartclk = 921600*16; 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. * First, find a port entry which matches.
*/ */
for (i = 0; i < nr_uarts; i++) 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]; 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. * 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); struct uart_port *port);
int adv950_register_port(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; uart->port.set_termios = port->set_termios;
if (port->pm) if (port->pm)
uart->port.pm = 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) //if (ret == 0)
ret = uart->port.line; ret = uart->port.line;
} }
@ -3127,13 +3127,13 @@ void adv950_unregister_port(int line)
struct uart_adv950_port *uart = &adv950_ports[line]; struct uart_adv950_port *uart = &adv950_ports[line];
mutex_lock(&serial_mutex); 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) { if (adv950_isa_devs) {
uart->port.flags &= ~UPF_BOOT_AUTOCONF; uart->port.flags &= ~UPF_BOOT_AUTOCONF;
uart->port.type = PORT_UNKNOWN; uart->port.type = PORT_UNKNOWN;
uart->port.dev = &adv950_isa_devs->dev; uart->port.dev = &adv950_isa_devs->dev;
uart->capabilities = uart_config[uart->port.type].flags; 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 { } else {
uart->port.dev = NULL; uart->port.dev = NULL;
} }
@ -3153,7 +3153,7 @@ int adv950_init(void)
share_irqs ? "en" : "dis"); share_irqs ? "en" : "dis");
adv950_reg.nr = UART_NR; adv950_reg.nr = UART_NR;
ret = adv_uart_register_driver(&adv950_reg); ret = adv950_uart_register_driver(&adv950_reg);
if (ret) if (ret)
goto out; 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; state = ((struct uart_driver*)(&adv950_reg))->state + ((struct uart_port *)(&adv950_ports[i].port))->line;
if (state->uart_port != NULL) 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); EXPORT_SYMBOL(adv950_unregister_port);

39
driver/adv950_base.h
View File

@ -12,26 +12,25 @@
*/ */
#include <linux/serial_8250.h> #include <linux/serial_8250.h>
void adv_uart_write_wakeup(struct uart_port *port); void adv950_uart_write_wakeup(struct uart_port *port);
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);
void adv_serial8250_resume_port(int line); void adv950_resume_port(int line);
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);
void adv_serial8250_suspend_port(int line); void adv950_suspend_port(int line);
void adv_uart_configure_port(struct uart_driver *drv, struct uart_state *state, void adv950_uart_configure_port(struct uart_driver *drv, struct uart_state *state,
struct uart_port *port); struct uart_port *port);
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);
int adv_serial8250_register_port(struct uart_port *port); int adv950_uart_register_port(struct uart_port *port);
int __init adv_serial8250_init(void); int __init adv950_uart_init(void);
int adv_uart_register_driver(struct uart_driver *drv); int adv950_uart_register_driver(struct uart_driver *drv);
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);
int adv_uart_register_driver(struct uart_driver *drv); int adv950_uart_register_driver(struct uart_driver *drv);
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);
void __exit adv_serial8250_exit(void); void __exit adv950_uart_exit(void);
void adv_uart_unregister_driver(struct uart_driver *drv); void adv950_uart_unregister_driver(struct uart_driver *drv);
void adv_serial8250_unregister_port(int line); void adv950_uart_unregister_port(int line);
unsigned int unsigned int adv950_uart_get_divisor(struct uart_port *port, unsigned int baud);
adv_uart_get_divisor(struct uart_port *port, unsigned int baud); void adv950_uart_configure_port(struct uart_driver *drv, struct uart_state *state,
void uart_configure_port(struct uart_driver *drv, struct uart_state *state,
struct uart_port *port); struct uart_port *port);
struct old_serial_port { struct old_serial_port {
@ -50,7 +49,7 @@ struct old_serial_port {
/* /*
* This replaces serial_uart_config in include/linux/serial.h * This replaces serial_uart_config in include/linux/serial.h
*/ */
struct serial8250_config { struct adv950_uart_config {
const char *name; const char *name;
unsigned short fifo_size; unsigned short fifo_size;
unsigned short tx_loadsz; 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 * This routine is used by the interrupt handler to schedule processing in
* the software interrupt portion of the driver. * 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; 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. * reflect the actual hardware settings.
*/ */
void 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 baud)
{ {
unsigned int bits; 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; 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 * 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"). * where B0 is requested ("hang up").
*/ */
unsigned int 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) struct ktermios *old, unsigned int min, unsigned int max)
{ {
unsigned int try, baud, altbaud = 38400; unsigned int try, baud, altbaud = 38400;
@ -388,7 +388,7 @@ adv_uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
return 0; return 0;
} }
EXPORT_SYMBOL(adv_uart_get_baud_rate); EXPORT_SYMBOL(adv950_uart_get_baud_rate);
/** /**
* uart_get_divisor - return uart clock divisor * 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. * Calculate the uart clock divisor for the port.
*/ */
unsigned int 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; unsigned int quot;
@ -413,7 +413,7 @@ adv_uart_get_divisor(struct uart_port *port, unsigned int baud)
return quot; return quot;
} }
EXPORT_SYMBOL(adv_uart_get_divisor); EXPORT_SYMBOL(adv950_uart_get_divisor);
/* FIXME: Consistent locking policy */ /* FIXME: Consistent locking policy */
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state, 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 * @count: number of characters in string to write
* @write: function to write character to port * @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, unsigned int count,
void (*putchar)(struct uart_port *, int)) void (*putchar)(struct uart_port *, int))
{ {
@ -1745,7 +1745,7 @@ uart_get_console(struct uart_port *ports, int nr, struct console *co)
* eg: 115200n8r * eg: 115200n8r
*/ */
void 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; char *s = options;
@ -1791,7 +1791,7 @@ static const struct baud_rates baud_rates[] = {
* @flow: flow control character - 'r' (rts) * @flow: flow control character - 'r' (rts)
*/ */
int 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) int baud, int parity, int bits, int flow)
{ {
struct ktermios termios; 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 */ 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 uart_state *state = drv->state + uport->line;
struct tty_port *port = &state->port; 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; 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 uart_state *state = drv->state + uport->line;
struct tty_port *port = &state->port; struct tty_port *port = &state->port;
@ -2059,7 +2059,7 @@ uart_report_port(struct uart_driver *drv, struct uart_port *port)
void 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) struct uart_port *port)
{ {
unsigned int flags; unsigned int flags;
@ -2144,8 +2144,8 @@ static int uart_poll_init(struct tty_driver *driver, int line, char *options)
return -1; return -1;
if (options) { if (options) {
adv_uart_parse_options(options, &baud, &parity, &bits, &flow); adv950_uart_parse_options(options, &baud, &parity, &bits, &flow);
return adv_uart_set_options(port, NULL, baud, parity, bits, flow); return adv950_uart_set_options(port, NULL, baud, parity, bits, flow);
} }
return 0; 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 * drv->port should be NULL, and the per-port structures should be
* registered using uart_add_one_port after this call has succeeded. * 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; struct tty_driver *normal;
int i, retval; int i, retval;
@ -2297,7 +2297,7 @@ out:
* uart_remove_one_port() if it registered them with uart_add_one_port(). * uart_remove_one_port() if it registered them with uart_add_one_port().
* (ie, drv->port == NULL) * (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; struct tty_driver *p = drv->tty_driver;
tty_unregister_driver(p); 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 * level uart drivers to expand uart_port, rather than having yet
* more levels of structures. * 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 uart_state *state;
struct tty_port *port; 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); 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 * 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 * core driver. No further calls will be made to the low-level code
* for this port. * 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 uart_state *state = drv->state + uport->line;
struct tty_port *port = &state->port; 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? * 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) if (port1->iotype != port2->iotype)
return 0; return 0;
@ -2463,17 +2463,17 @@ int adv_uart_match_port(struct uart_port *port1, struct uart_port *port2)
} }
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(adv_uart_console_write); EXPORT_SYMBOL_GPL(adv950_uart_console_write);
EXPORT_SYMBOL_GPL(adv_uart_parse_options); EXPORT_SYMBOL_GPL(adv950_uart_parse_options);
EXPORT_SYMBOL_GPL(adv_uart_set_options); EXPORT_SYMBOL_GPL(adv950_uart_set_options);
EXPORT_SYMBOL(adv_uart_match_port); EXPORT_SYMBOL(adv950_uart_match_port);
EXPORT_SYMBOL(adv_uart_write_wakeup); EXPORT_SYMBOL(adv950_uart_write_wakeup);
EXPORT_SYMBOL(adv_uart_register_driver); EXPORT_SYMBOL(adv950_uart_register_driver);
EXPORT_SYMBOL(adv_uart_unregister_driver); EXPORT_SYMBOL(adv950_uart_unregister_driver);
EXPORT_SYMBOL(adv_uart_suspend_port); EXPORT_SYMBOL(adv950_uart_suspend_port);
EXPORT_SYMBOL(adv_uart_resume_port); EXPORT_SYMBOL(adv950_uart_resume_port);
EXPORT_SYMBOL(adv_uart_add_one_port); EXPORT_SYMBOL(adv950_uart_add_one_port);
EXPORT_SYMBOL(adv_uart_remove_one_port); EXPORT_SYMBOL(adv950_uart_remove_one_port);
MODULE_DESCRIPTION("Advantech Serial driver core"); MODULE_DESCRIPTION("Advantech Serial driver core");
MODULE_LICENSE("GPL"); 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 * 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 uart_port serial_port;
struct serial_private *priv; 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); serial_port.iobase, serial_port.irq, serial_port.iotype);
#endif #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]); //printk("port->unused[0] = %d\n",serial_port.unused[0]);
if (priv->line[i] < 0) { if (priv->line[i] < 0) {
printk(KERN_WARNING "Couldn't register serial port %s: %d\n", pci_name(dev), priv->line[i]); 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; struct pci_serial_quirk *quirk;
int i; int i;
for (i = 0; i < priv->nr; 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++) { for (i = 0; i < PCI_NUM_BAR_RESOURCES; i++) {
if (priv->remapped_bar[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; int i;
for (i = 0; i < priv->nr; i++) for (i = 0; i < priv->nr; i++)
if (priv->line[i] >= 0) 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; int i;
@ -1558,7 +1558,7 @@ void adv_pciserial_resume_ports(struct serial_private *priv)
for (i = 0; i < priv->nr; i++) for (i = 0; i < priv->nr; i++)
if (priv->line[i] >= 0) 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); dev);
} }
priv = adv_pciserial_init_ports(dev, board); priv = adv950_uart_pci_init_ports(dev, board);
if (!IS_ERR(priv)) { if (!IS_ERR(priv)) {
pci_set_drvdata(dev, priv); pci_set_drvdata(dev, priv);
return 0; return 0;
@ -1634,7 +1634,7 @@ static void pciserial_remove_one(struct pci_dev *dev)
pci_set_drvdata(dev, NULL); pci_set_drvdata(dev, NULL);
adv_pciserial_remove_ports(priv); adv950_uart_pci_remove_ports(priv);
pci_disable_device(dev); pci_disable_device(dev);
} }
@ -1668,7 +1668,7 @@ static int pciserial_resume_one(struct pci_dev *dev)
/* FIXME: We cannot simply error out here */ /* FIXME: We cannot simply error out here */
if (err) if (err)
printk(KERN_ERR "pciserial: Unable to re-enable ports, trying to continue.\n"); 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; return 0;
} }
@ -1818,7 +1818,7 @@ static struct pci_driver serial_pci_driver = {
.id_table = serial_pci_tbl, .id_table = serial_pci_tbl,
}; };
static int __init adv_serial8250_pci_init(void) static int __init adv950_uart_pci_init(void)
{ {
printk("\n"); printk("\n");
printk("===========================================================" printk("==========================================================="
@ -1849,23 +1849,23 @@ static int __init adv_serial8250_pci_init(void)
printk("Advantech Industrial Automation Group.\n"); printk("Advantech Industrial Automation Group.\n");
printk("===========================================================" printk("==========================================================="
"====\n"); "====\n");
if(adv_serial8250_init() >= 0) if(adv950_uart_init() >= 0)
return pci_register_driver(&serial_pci_driver); return pci_register_driver(&serial_pci_driver);
return -ENODEV; return -ENODEV;
} }
static void __exit adv_serial8250_pci_exit(void) static void __exit adv950_uart_pci_exit(void)
{ {
pci_unregister_driver(&serial_pci_driver); pci_unregister_driver(&serial_pci_driver);
adv_serial8250_exit(); adv950_uart_exit();
} }
EXPORT_SYMBOL_GPL(adv_pciserial_remove_ports); EXPORT_SYMBOL_GPL(adv950_uart_pci_remove_ports);
EXPORT_SYMBOL_GPL(adv_pciserial_suspend_ports); EXPORT_SYMBOL_GPL(adv950_uart_pci_suspend_ports);
EXPORT_SYMBOL_GPL(adv_pciserial_resume_ports); EXPORT_SYMBOL_GPL(adv950_uart_pci_resume_ports);
EXPORT_SYMBOL_GPL(adv_pciserial_init_ports); EXPORT_SYMBOL_GPL(adv950_uart_pci_init_ports);
module_init(adv_serial8250_pci_init); module_init(adv950_uart_pci_init);
module_exit(adv_serial8250_pci_exit); module_exit(adv950_uart_pci_exit);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Generic 8250/16x50 PCI serial probe module"); MODULE_DESCRIPTION("Generic 8250/16x50 PCI serial probe module");