static int __init ts4700_isa16550_init(void)
{
int line;
unsigned int uart_irq[NR_UARTS];
unsigned int uart_adr[NR_UARTS];
uart_adr[0] = 0x2e8;
uart_irq[0] = 5;
uart_adr[1] = 0x3e8;
uart_irq[1] = 6;
if (strlen(io)) {
char *cp;
uart_adr[0] = simple_strtoul(io, &cp, 0);
if (cp && *cp)
uart_adr[1] = simple_strtoul(&cp[1], &cp, 0);
}
//printk("Using 0x%08lX and 0x%08lX\n", uart_adr[0], uart_adr[1]);
if (strlen(irq)) {
char *cp;
uart_irq[0] = simple_strtoul(irq, &cp, 0);
if (cp && *cp)
uart_irq[1] = simple_strtoul(&cp[1], &cp, 0);
}
//printk("Using irq %d and %d\n", uart_irq[0], uart_irq[1]);
req[0].type = PORT_16550A;
req[0].iotype = UPIO_MEM;
req[0].iobase = 0;
req[0].fifosize = 16;
req[0].flags = UPF_IOREMAP | UPF_SHARE_IRQ;
req[0].regshift = 0;
req[0].irq = 62 + uart_irq[0];
req[0].mapbase = 0x81008000UL + uart_adr[0];
req[0].membase = (char *)req[0].mapbase;
req[0].uartclk = 1843200;
line = serial8250_register_port(&req[0]);
req[1].type = PORT_16550A;
req[1].iotype = UPIO_MEM;
req[1].iobase = 0;
req[1].fifosize = 16;
req[1].flags = UPF_IOREMAP | UPF_SHARE_IRQ;
req[1].regshift = 0;
req[1].irq = 62 + uart_irq[1];
req[1].mapbase = 0x81008000UL + uart_adr[1];
req[1].membase = (char *)req[1].mapbase;
req[1].uartclk = 1843200;
line = serial8250_register_port(&req[1]);
if (line < 0)
return line;
else
return 0;
}
static int setup_serial(client_handle_t handle, struct serial_info * info,
kio_addr_t iobase, int irq)
{
struct uart_port port;
int line;
memset(&port, 0, sizeof (struct uart_port));
port.iobase = iobase;
port.irq = irq;
port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ;
port.uartclk = 1843200;
port.dev = &handle_to_dev(handle);
if (buggy_uart)
port.flags |= UPF_BUGGY_UART;
line = serial8250_register_port(&port);
if (line < 0) {
printk(KERN_NOTICE "serial_cs: serial8250_register_port() at "
"0x%04lx, irq %d failed\n", (u_long)iobase, irq);
return -EINVAL;
}
info->line[info->ndev] = line;
sprintf(info->node[info->ndev].dev_name, "ttyS%d", line);
info->node[info->ndev].major = TTY_MAJOR;
info->node[info->ndev].minor = 0x40 + line;
if (info->ndev > 0)
info->node[info->ndev - 1].next = &info->node[info->ndev];
info->ndev++;
return 0;
}
static int __devinit
serial_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
{
struct uart_port port;
int ret, line, flags = dev_id->driver_data;
if (flags & UNKNOWN_DEV) {
ret = serial_pnp_guess_board(dev, &flags);
if (ret < 0)
return ret;
}
memset(&port, 0, sizeof(struct uart_port));
port.irq = pnp_irq(dev,0);
port.iobase = pnp_port_start(dev, 0);
#ifdef SERIAL_DEBUG_PNP
printk("Setup PNP port: port %x, irq %d, type %d\n",
port.iobase, port.irq, port.iotype);
#endif
port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF;
port.uartclk = 1843200;
port.dev = &dev->dev;
line = serial8250_register_port(&port);
if (line >= 0)
pnp_set_drvdata(dev, (void *)((long)line + 1));
return line >= 0 ? 0 : -ENODEV;
}
void ibmasm_register_uart(struct service_processor *sp)
{
struct uart_port uport;
void __iomem *iomem_base;
iomem_base = sp->base_address + SCOUT_COM_B_BASE;
/* read the uart scratch register to determine if the UART
* is dedicated to the service processor or if the OS can use it
*/
if (0 == readl(iomem_base + UART_SCR)) {
dev_info(sp->dev, "IBM SP UART not registered, owned by service processor\n");
sp->serial_line = -1;
return;
}
memset(&uport, 0, sizeof(struct uart_port));
uport.irq = sp->irq;
uport.uartclk = 3686400;
uport.flags = UPF_AUTOPROBE | UPF_SHARE_IRQ;
uport.iotype = UPIO_MEM;
uport.membase = iomem_base;
sp->serial_line = serial8250_register_port(&uport);
if (sp->serial_line < 0) {
dev_err(sp->dev, "Failed to register serial port\n");
return;
}
enable_uart_interrupts(sp->base_address);
}
static int __devinit of_platform_serial_probe(struct platform_device *ofdev)
{
const struct of_device_id *match;
struct of_serial_info *info;
struct uart_port port;
int port_type;
int ret;
match = of_match_device(of_platform_serial_table, &ofdev->dev);
if (!match)
return -EINVAL;
if (of_find_property(ofdev->dev.of_node, "used-by-rtas", NULL))
return -EBUSY;
info = kmalloc(sizeof(*info), GFP_KERNEL);
if (info == NULL)
return -ENOMEM;
port_type = (unsigned long)match->data;
ret = of_platform_serial_setup(ofdev, port_type, &port);
if (ret)
goto out;
switch (port_type) {
#ifdef CONFIG_SERIAL_8250
case PORT_8250 ... PORT_MAX_8250:
ret = serial8250_register_port(&port);
break;
#endif
#ifdef CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL
case PORT_NWPSERIAL:
ret = nwpserial_register_port(&port);
break;
#endif
default:
/* need to add code for these */
case PORT_UNKNOWN:
dev_info(&ofdev->dev, "Unknown serial port found, ignored\n");
ret = -ENODEV;
break;
}
if (ret < 0)
goto out;
info->type = port_type;
info->line = ret;
dev_set_drvdata(&ofdev->dev, info);
return 0;
out:
kfree(info);
irq_dispose_mapping(port.irq);
return ret;
}
static int __init serial_init_chip(struct parisc_device *dev)
{
struct uart_port port;
unsigned long address;
int err;
if (!dev->irq) {
/* We find some unattached serial ports by walking native
* busses. These should be silently ignored. Otherwise,
* what we have here is a missing parent device, so tell
* the user what they're missing.
*/
if (parisc_parent(dev)->id.hw_type != HPHW_IOA)
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_INFO
"Serial: device 0x%llx not configured.\n"
"Enable support for Wax, Lasi, Asp or Dino.\n",
(unsigned long long)dev->hpa.start);
#else
;
#endif
return -ENODEV;
}
address = dev->hpa.start;
if (dev->id.sversion != 0x8d)
address += 0x800;
memset(&port, 0, sizeof(port));
port.iotype = UPIO_MEM;
/* 7.272727MHz on Lasi. Assumed the same for Dino, Wax and Timi. */
port.uartclk = 7272727;
port.mapbase = address;
port.membase = ioremap_nocache(address, 16);
port.irq = dev->irq;
port.flags = UPF_BOOT_AUTOCONF;
port.dev = &dev->dev;
err = serial8250_register_port(&port);
if (err < 0) {
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_WARNING
"serial8250_register_port returned error %d\n", err);
#else
;
#endif
iounmap(port.membase);
return err;
}
return 0;
}
static int __devinit
sw_serial_probe(struct platform_device *dev)
{
struct sw_serial_port *sport;
int ret;
sport = kzalloc(sizeof(struct sw_serial_port), GFP_KERNEL);
if (!sport)
return -ENOMEM;
sport->port_no = dev->id;
sport->pdev = dev;
ret = sw_serial_get_config(sport, dev->id);
if (ret) {
printk(KERN_ERR "Failed to get config information\n");
goto free_dev;
}
ret = sw_serial_get_resource(sport);
if (ret) {
printk(KERN_ERR "Failed to get resource\n");
goto free_dev;
}
platform_set_drvdata(dev, sport);
sport->port.irq = sport->irq;
sport->port.fifosize= 64;
sport->port.regshift= 2;
sport->port.iotype = UPIO_DWAPB32;
sport->port.flags = UPF_IOREMAP | UPF_BOOT_AUTOCONF;
sport->port.uartclk = sport->sclk;
sport->port.pm = sw_serial_pm;
sport->port.dev = &dev->dev;
sport->port.mapbase = sport->mmres->start;
sw_serial[sport->port_no] = serial8250_register_port(&sport->port);
UART_MSG("serial probe %d, membase %p irq %d mapbase 0x%08x\n",
dev->id, sport->port.membase, sport->port.irq, sport->port.mapbase);
return 0;
free_dev:
kfree(sport);
sport = NULL;
return ret;
}
static int __devinit
serial_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
{
struct uart_port port;
int ret, line, flags = dev_id->driver_data;
if (flags & UNKNOWN_DEV) {
ret = serial_pnp_guess_board(dev, &flags);
if (ret < 0)
return ret;
}
memset(&port, 0, sizeof(struct uart_port));
if (pnp_irq_valid(dev, 0))
port.irq = pnp_irq(dev, 0);
if (pnp_port_valid(dev, 0)) {
port.iobase = pnp_port_start(dev, 0);
port.iotype = UPIO_PORT;
} else if (pnp_mem_valid(dev, 0)) {
port.mapbase = pnp_mem_start(dev, 0);
port.iotype = UPIO_MEM;
port.flags = UPF_IOREMAP;
} else
return -ENODEV;
#ifdef SERIAL_DEBUG_PNP
printk(KERN_DEBUG
"Setup PNP port: port %x, mem 0x%lx, irq %d, type %d\n",
port.iobase, port.mapbase, port.irq, port.iotype);
#endif
port.flags |= UPF_SKIP_TEST | UPF_BOOT_AUTOCONF;
if (pnp_irq_flags(dev, 0) & IORESOURCE_IRQ_SHAREABLE)
port.flags |= UPF_SHARE_IRQ;
port.uartclk = 1843200;
port.dev = &dev->dev;
line = serial8250_register_port(&port);
if (line < 0)
return -ENODEV;
pnp_set_drvdata(dev, (void *)((long)line + 1));
return 0;
}
static int __init serial_init_chip(struct parisc_device *dev)
{
struct uart_port port;
unsigned long address;
int err;
if (!dev->irq) {
/*
*/
if (parisc_parent(dev)->id.hw_type != HPHW_IOA)
printk(KERN_INFO
"Serial: device 0x%llx not configured.\n"
"Enable support for Wax, Lasi, Asp or Dino.\n",
(unsigned long long)dev->hpa.start);
return -ENODEV;
}
address = dev->hpa.start;
if (dev->id.sversion != 0x8d)
address += 0x800;
memset(&port, 0, sizeof(port));
port.iotype = UPIO_MEM;
/* */
port.uartclk = 7272727;
port.mapbase = address;
port.membase = ioremap_nocache(address, 16);
port.irq = dev->irq;
port.flags = UPF_BOOT_AUTOCONF;
port.dev = &dev->dev;
err = serial8250_register_port(&port);
if (err < 0) {
printk(KERN_WARNING
"serial8250_register_port returned error %d\n", err);
iounmap(port.membase);
return err;
}
return 0;
}
static int register_serial_portandirq(unsigned int port, int irq)
{
struct uart_port uart;
switch ( port ) {
case 0x3f8:
case 0x2f8:
case 0x3e8:
case 0x2e8:
/* OK */
break;
default:
PRINTK_ERROR(KERN_ERR_MWAVE
"mwavedd::register_serial_portandirq:"
" Error: Illegal port %x\n", port );
return -1;
} /* switch */
/* port is okay */
switch ( irq ) {
case 3:
case 4:
case 5:
case 7:
/* OK */
break;
default:
PRINTK_ERROR(KERN_ERR_MWAVE
"mwavedd::register_serial_portandirq:"
" Error: Illegal irq %x\n", irq );
return -1;
} /* switch */
/* irq is okay */
memset(&uart, 0, sizeof(struct uart_port));
uart.uartclk = 1843200;
uart.iobase = port;
uart.irq = irq;
uart.iotype = UPIO_PORT;
uart.flags = UPF_SHARE_IRQ;
return serial8250_register_port(&uart);
}
/*
* Try to register a serial port
*/
static int __devinit of_platform_serial_probe(struct of_device *ofdev,
const struct of_device_id *id)
{
struct of_serial_info *info;
struct uart_port port;
int port_type;
int ret;
if (of_find_property(ofdev->node, "used-by-rtas", NULL))
return -EBUSY;
info = kmalloc(sizeof(*info), GFP_KERNEL);
if (info == NULL)
return -ENOMEM;
port_type = (unsigned long)id->data;
ret = of_platform_serial_setup(ofdev, port_type, &port);
if (ret)
goto out;
switch (port_type) {
case PORT_8250 ... PORT_MAX_8250:
ret = serial8250_register_port(&port);
break;
default:
/* need to add code for these */
case PORT_UNKNOWN:
dev_info(&ofdev->dev, "Unknown serial port found, ignored\n");
ret = -ENODEV;
break;
}
if (ret < 0)
goto out;
info->type = port_type;
info->line = ret;
ofdev->dev.driver_data = info;
return 0;
out:
kfree(info);
irq_dispose_mapping(port.irq);
return ret;
}
static int __init
serial_init_chip(struct parisc_device *dev)
{
static int serial_line_nr;
struct uart_port port;
unsigned long address;
int err;
if (!dev->irq) {
/* We find some unattached serial ports by walking native
* busses. These should be silently ignored. Otherwise,
* what we have here is a missing parent device, so tell
* the user what they're missing.
*/
if (dev->parent->id.hw_type != HPHW_IOA) {
printk(KERN_INFO "Serial: device 0x%lx not configured.\n"
"Enable support for Wax, Lasi, Asp or Dino.\n", dev->hpa);
}
return -ENODEV;
}
address = dev->hpa;
if (dev->id.sversion != 0x8d) {
address += 0x800;
}
memset(&port, 0, sizeof(struct uart_port));
port.mapbase = address;
port.irq = dev->irq;
port.iotype = UPIO_MEM;
port.flags = UPF_IOREMAP | UPF_BOOT_AUTOCONF;
port.uartclk = LASI_BASE_BAUD * 16;
port.dev = &dev->dev;
err = serial8250_register_port(&port);
if (err < 0) {
printk(KERN_WARNING "serial8250_register_port returned error %d\n", err);
return err;
}
return 0;
}
static int __devinit
serial_card_probe(struct expansion_card *ec, const struct ecard_id *id)
{
struct serial_card_info *info;
struct serial_card_type *type = id->data;
struct uart_port port;
unsigned long bus_addr;
unsigned int i;
info = kzalloc(sizeof(struct serial_card_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
info->num_ports = type->num_ports;
bus_addr = ecard_resource_start(ec, type->type);
info->vaddr = ecardm_iomap(ec, type->type, 0, 0);
if (!info->vaddr) {
kfree(info);
return -ENOMEM;
}
ecard_set_drvdata(ec, info);
memset(&port, 0, sizeof(struct uart_port));
port.irq = ec->irq;
port.flags = UPF_BOOT_AUTOCONF | UPF_SHARE_IRQ;
port.uartclk = type->uartclk;
port.iotype = UPIO_MEM;
port.regshift = 2;
port.dev = &ec->dev;
for (i = 0; i < info->num_ports; i ++) {
port.membase = info->vaddr + type->offset[i];
port.mapbase = bus_addr + type->offset[i];
info->ports[i] = serial8250_register_port(&port);
}
return 0;
}
static int __devinit dw8250_probe(struct platform_device *pdev)
{
#if defined(CONFIG_SYNO_ARMADA_ARCH) && !defined(CONFIG_USE_OF)
struct plat_serial8250_port *p = pdev->dev.platform_data;
#endif
struct uart_port port = {};
struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
struct resource *irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
struct device_node *np = pdev->dev.of_node;
u32 val;
struct dw8250_data *data;
if (!regs || !irq) {
dev_err(&pdev->dev, "no registers/irq defined\n");
return -EINVAL;
}
data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
if (!data)
return -ENOMEM;
port.private_data = data;
spin_lock_init(&port.lock);
port.mapbase = regs->start;
port.irq = irq->start;
port.handle_irq = dw8250_handle_irq;
port.type = PORT_8250;
port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_IOREMAP |
UPF_FIXED_PORT | UPF_FIXED_TYPE;
port.dev = &pdev->dev;
port.iotype = UPIO_MEM;
port.serial_in = dw8250_serial_in;
port.serial_out = dw8250_serial_out;
#if defined(CONFIG_SYNO_ARMADA_ARCH) && !defined(CONFIG_USE_OF)
port.iotype = p->iotype;
port.serial_in = dw8250_serial_in32;
port.serial_out = dw8250_serial_out32;
port.regshift = p->regshift;
port.uartclk = p->uartclk;
#else
if (!of_property_read_u32(np, "reg-io-width", &val)) {
switch (val) {
case 1:
break;
case 4:
port.iotype = UPIO_MEM32;
port.serial_in = dw8250_serial_in32;
port.serial_out = dw8250_serial_out32;
break;
default:
dev_err(&pdev->dev, "unsupported reg-io-width (%u)\n",
val);
return -EINVAL;
}
}
if (!of_property_read_u32(np, "reg-shift", &val))
port.regshift = val;
if (of_property_read_u32(np, "clock-frequency", &val)) {
dev_err(&pdev->dev, "no clock-frequency property set\n");
return -EINVAL;
}
port.uartclk = val;
#endif
data->line = serial8250_register_port(&port);
if (data->line < 0)
return data->line;
platform_set_drvdata(pdev, data);
return 0;
}
static int __devinit
sw_serial_probe(struct platform_device *dev)
{
struct sw_serial_port *sport;
struct sw_serial_data *sdata;
int ret;
UART_INF("%s: uart%d probe\n", __func__, dev->id);
sport = kzalloc(sizeof(struct sw_serial_port), GFP_KERNEL);
if (!sport) {
UART_ERR("%s: uart%d alloc memory for sw_serial port failed\n",
__func__, dev->id);
return -ENOMEM;
}
sdata = devm_kzalloc(&dev->dev, sizeof(*sdata), GFP_KERNEL);
if (!sdata) {
UART_ERR("%s: uart%d alloc memory for sdata failed\n", __func__,
dev->id);
return -ENOMEM;
}
sw_serial_uart[dev->id] = sport;
sport->port_no = dev->id;
sport->pdev = dev;
ret = sw_serial_get_config(sport, dev->id);
if (ret) {
UART_ERR("%s: uart%d failed to get config information\n",
__func__, sport->port_no);
goto free_dev;
}
platform_set_drvdata(dev, sport);
ret = sw_serial_get_resource(sport);
if (ret) {
UART_ERR("%s: uart%d failed to get resource\n", __func__,
sport->port_no);
goto free_dev;
}
sport->port.private_data = sdata;
spin_lock_init(&sport->port.lock);
sport->port.irq = sport->irq;
sport->port.fifosize = 64;
sport->port.regshift = 2;
sport->port.iotype = UPIO_MEM32;
sport->port.type = PORT_U6_16550A;
sport->port.flags = UPF_IOREMAP | UPF_BOOT_AUTOCONF;
sport->port.serial_in = sunxi_serial_in;
sport->port.serial_out = sunxi_serial_out;
sport->port.uartclk = sport->sclk;
sport->port.pm = sw_serial_pm;
sport->port.dev = &dev->dev;
sport->port.membase = (unsigned char __iomem *)sport->mmres->start + OFFSET;
sport->port.mapbase = sport->mmres->start;
if (sport->irq != AW_IRQ_UART0)
sdata->line = serial8250_register_port(&sport->port);
else {
UART_INF("%s: uart%d have been register as console\n", __func__,
sport->port_no);
sdata->line = 0;
}
if (sdata->line < 0) {
ret = sdata->line;
goto free_dev;
}
if (sdata->line) {
clk_reset(sport->mod_clk, AW_CCU_CLK_RESET);
clk_disable(sport->mod_clk);
clk_disable(sport->bus_clk);
}
UART_INF("%s: uart%d probe done\n", __func__, sport->port_no);
return 0;
free_dev:
kfree(sport);
kfree(sdata);
sport = NULL;
sdata = NULL;
return ret;
}
