[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / powerpc / kernel / legacy_serial.c

#include <linux/kernel.h>
#include <linux/serial.h>
#include <linux/serial_8250.h>
#include <linux/serial_core.h>
#include <linux/console.h>
#include <linux/pci.h>
#include <linux/of_device.h>
#include <asm/io.h>
#include <asm/mmu.h>
#include <asm/prom.h>
#include <asm/serial.h>
#include <asm/udbg.h>
#include <asm/pci-bridge.h>
#include <asm/ppc-pci.h>

#undef DEBUG

#ifdef DEBUG
#define DBG(fmt...) do { printk(fmt); } while(0)
#else
#define DBG(fmt...) do { } while(0)
#endif

#define MAX_LEGACY_SERIAL_PORTS	8

static struct plat_serial8250_port
legacy_serial_ports[MAX_LEGACY_SERIAL_PORTS+1];
static struct legacy_serial_info {
	struct device_node		*np;
	unsigned int			speed;
	unsigned int			clock;
	int				irq_check_parent;
	phys_addr_t			taddr;
} legacy_serial_infos[MAX_LEGACY_SERIAL_PORTS];

static struct __initdata of_device_id parents[] = {
	{.type = "soc",},
	{.type = "tsi-bridge",},
	{.type = "opb", },
	{.compatible = "ibm,opb",},
	{.compatible = "simple-bus",},
	{.compatible = "wrs,epld-localbus",},
};

static unsigned int legacy_serial_count;
static int legacy_serial_console = -1;

static int __init add_legacy_port(struct device_node *np, int want_index,
				  int iotype, phys_addr_t base,
				  phys_addr_t taddr, unsigned long irq,
				  upf_t flags, int irq_check_parent)
{
	const u32 *clk, *spd;
	u32 clock = BASE_BAUD * 16;
	int index;

	/* get clock freq. if present */
	clk = of_get_property(np, "clock-frequency", NULL);
	if (clk && *clk)
		clock = *clk;

	/* get default speed if present */
	spd = of_get_property(np, "current-speed", NULL);

	/* If we have a location index, then try to use it */
	if (want_index >= 0 && want_index < MAX_LEGACY_SERIAL_PORTS)
		index = want_index;
	else
		index = legacy_serial_count;

	/* if our index is still out of range, that mean that
	 * array is full, we could scan for a free slot but that
	 * make little sense to bother, just skip the port
	 */
	if (index >= MAX_LEGACY_SERIAL_PORTS)
		return -1;
	if (index >= legacy_serial_count)
		legacy_serial_count = index + 1;

	/* Check if there is a port who already claimed our slot */
	if (legacy_serial_infos[index].np != 0) {
		/* if we still have some room, move it, else override */
		if (legacy_serial_count < MAX_LEGACY_SERIAL_PORTS) {
			printk(KERN_DEBUG "Moved legacy port %d -> %d\n",
			       index, legacy_serial_count);
			legacy_serial_ports[legacy_serial_count] =
				legacy_serial_ports[index];
			legacy_serial_infos[legacy_serial_count] =
				legacy_serial_infos[index];
			legacy_serial_count++;
		} else {
			printk(KERN_DEBUG "Replacing legacy port %d\n", index);
		}
	}

	/* Now fill the entry */
	memset(&legacy_serial_ports[index], 0,
	       sizeof(struct plat_serial8250_port));
	if (iotype == UPIO_PORT)
		legacy_serial_ports[index].iobase = base;
	else
		legacy_serial_ports[index].mapbase = base;
	legacy_serial_ports[index].iotype = iotype;
	legacy_serial_ports[index].uartclk = clock;
	legacy_serial_ports[index].irq = irq;
	legacy_serial_ports[index].flags = flags;
	legacy_serial_infos[index].taddr = taddr;
	legacy_serial_infos[index].np = of_node_get(np);
	legacy_serial_infos[index].clock = clock;
	legacy_serial_infos[index].speed = spd ? *spd : 0;
	legacy_serial_infos[index].irq_check_parent = irq_check_parent;

	printk(KERN_DEBUG "Found legacy serial port %d for %s\n",
	       index, np->full_name);
	printk(KERN_DEBUG "  %s=%llx, taddr=%llx, irq=%lx, clk=%d, speed=%d\n",
	       (iotype == UPIO_PORT) ? "port" : "mem",
	       (unsigned long long)base, (unsigned long long)taddr, irq,
	       legacy_serial_ports[index].uartclk,
	       legacy_serial_infos[index].speed);

	return index;
}

static int __init add_legacy_soc_port(struct device_node *np,
				      struct device_node *soc_dev)
{
	u64 addr;
	const u32 *addrp;
	upf_t flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ
		| UPF_FIXED_PORT;
	struct device_node *tsi = of_get_parent(np);

	/* We only support ports that have a clock frequency properly
	 * encoded in the device-tree.
	 */
	if (of_get_property(np, "clock-frequency", NULL) == NULL)
		return -1;

	/* if reg-shift or offset, don't try to use it */
	if ((of_get_property(np, "reg-shift", NULL) != NULL) ||
		(of_get_property(np, "reg-offset", NULL) != NULL))
		return -1;

	/* if rtas uses this device, don't try to use it as well */
	if (of_get_property(np, "used-by-rtas", NULL) != NULL)
		return -1;

	/* Get the address */
	addrp = of_get_address(soc_dev, 0, NULL, NULL);
	if (addrp == NULL)
		return -1;

	addr = of_translate_address(soc_dev, addrp);
	if (addr == OF_BAD_ADDR)
		return -1;

	/* Add port, irq will be dealt with later. We passed a translated
	 * IO port value. It will be fixed up later along with the irq
	 */
	if (tsi && !strcmp(tsi->type, "tsi-bridge"))
		return add_legacy_port(np, -1, UPIO_TSI, addr, addr, NO_IRQ, flags, 0);
	else
		return add_legacy_port(np, -1, UPIO_MEM, addr, addr, NO_IRQ, flags, 0);
}

static int __init add_legacy_isa_port(struct device_node *np,
				      struct device_node *isa_brg)
{
	const u32 *reg;
	const char *typep;
	int index = -1;
	u64 taddr;

	DBG(" -> add_legacy_isa_port(%s)\n", np->full_name);

	/* Get the ISA port number */
	reg = of_get_property(np, "reg", NULL);
	if (reg == NULL)
		return -1;

	/* Verify it's an IO port, we don't support anything else */
	if (!(reg[0] & 0x00000001))
		return -1;

	/* Now look for an "ibm,aix-loc" property that gives us ordering
	 * if any...
	 */
	typep = of_get_property(np, "ibm,aix-loc", NULL);

	/* If we have a location index, then use it */
	if (typep && *typep == 'S')
		index = simple_strtol(typep+1, NULL, 0) - 1;

	/* Translate ISA address. If it fails, we still register the port
	 * with no translated address so that it can be picked up as an IO
	 * port later by the serial driver
	 */
	taddr = of_translate_address(np, reg);
	if (taddr == OF_BAD_ADDR)
		taddr = 0;

	/* Add port, irq will be dealt with later */
	return add_legacy_port(np, index, UPIO_PORT, reg[1], taddr,
			       NO_IRQ, UPF_BOOT_AUTOCONF, 0);

}

#ifdef CONFIG_PCI
static int __init add_legacy_pci_port(struct device_node *np,
				      struct device_node *pci_dev)
{
	u64 addr, base;
	const u32 *addrp;
	unsigned int flags;
	int iotype, index = -1, lindex = 0;

	DBG(" -> add_legacy_pci_port(%s)\n", np->full_name);

	/* We only support ports that have a clock frequency properly
	 * encoded in the device-tree (that is have an fcode). Anything
	 * else can't be used that early and will be normally probed by
	 * the generic 8250_pci driver later on. The reason is that 8250
	 * compatible UARTs on PCI need all sort of quirks (port offsets
	 * etc...) that this code doesn't know about
	 */
	if (of_get_property(np, "clock-frequency", NULL) == NULL)
		return -1;

	/* Get the PCI address. Assume BAR 0 */
	addrp = of_get_pci_address(pci_dev, 0, NULL, &flags);
	if (addrp == NULL)
		return -1;

	/* We only support BAR 0 for now */
	iotype = (flags & IORESOURCE_MEM) ? UPIO_MEM : UPIO_PORT;
	addr = of_translate_address(pci_dev, addrp);
	if (addr == OF_BAD_ADDR)
		return -1;

	/* Set the IO base to the same as the translated address for MMIO,
	 * or to the domain local IO base for PIO (it will be fixed up later)
	 */
	if (iotype == UPIO_MEM)
		base = addr;
	else
		base = addrp[2];

	/* Try to guess an index... If we have subdevices of the pci dev,
	 * we get to their "reg" property
	 */
	if (np != pci_dev) {
		const u32 *reg = of_get_property(np, "reg", NULL);
		if (reg && (*reg < 4))
			index = lindex = *reg;
	}

	/* Local index means it's the Nth port in the PCI chip. Unfortunately
	 * the offset to add here is device specific. We know about those
	 * EXAR ports and we default to the most common case. If your UART
	 * doesn't work for these settings, you'll have to add your own special
	 * cases here
	 */
	if (of_device_is_compatible(pci_dev, "pci13a8,152") ||
	    of_device_is_compatible(pci_dev, "pci13a8,154") ||
	    of_device_is_compatible(pci_dev, "pci13a8,158")) {
		addr += 0x200 * lindex;
		base += 0x200 * lindex;
	} else {
		addr += 8 * lindex;
		base += 8 * lindex;
	}

	/* Add port, irq will be dealt with later. We passed a translated
	 * IO port value. It will be fixed up later along with the irq
	 */
	return add_legacy_port(np, index, iotype, base, addr, NO_IRQ,
			       UPF_BOOT_AUTOCONF, np != pci_dev);
}
#endif

static void __init setup_legacy_serial_console(int console)
{
	struct legacy_serial_info *info =
		&legacy_serial_infos[console];
	void __iomem *addr;

	if (info->taddr == 0)
		return;
	addr = ioremap(info->taddr, 0x1000);
	if (addr == NULL)
		return;
	if (info->speed == 0)
		info->speed = udbg_probe_uart_speed(addr, info->clock);
	DBG("default console speed = %d\n", info->speed);
	udbg_init_uart(addr, info->speed, info->clock);
}

/*
 * This is called very early, as part of setup_system() or eventually
 * setup_arch(), basically before anything else in this file. This function
 * will try to build a list of all the available 8250-compatible serial ports
 * in the machine using the Open Firmware device-tree. It currently only deals
 * with ISA and PCI busses but could be extended. It allows a very early boot
 * console to be initialized, that list is also used later to provide 8250 with
 * the machine non-PCI ports and to properly pick the default console port
 */
void __init find_legacy_serial_ports(void)
{
	struct device_node *np, *stdout = NULL;
	const char *path;
	int index;

	DBG(" -> find_legacy_serial_port()\n");

	/* Now find out if one of these is out firmware console */
	path = of_get_property(of_chosen, "linux,stdout-path", NULL);
	if (path != NULL) {
		stdout = of_find_node_by_path(path);
		if (stdout)
			DBG("stdout is %s\n", stdout->full_name);
	} else {
		DBG(" no linux,stdout-path !\n");
	}

	/* Iterate over all the 16550 ports, looking for known parents */
	for_each_compatible_node(np, "serial", "ns16550") {
		struct device_node *parent = of_get_parent(np);
		if (!parent)
			continue;
		if (of_match_node(parents, parent) != NULL) {
			index = add_legacy_soc_port(np, np);
			if (index >= 0 && np == stdout)
				legacy_serial_console = index;
		}
		of_node_put(parent);
	}

	/* Next, fill our array with ISA ports */
	for_each_node_by_type(np, "serial") {
		struct device_node *isa = of_get_parent(np);
		if (isa && !strcmp(isa->name, "isa")) {
			index = add_legacy_isa_port(np, isa);
			if (index >= 0 && np == stdout)
				legacy_serial_console = index;
		}
		of_node_put(isa);
	}

#ifdef CONFIG_PCI
	/* Next, try to locate PCI ports */
	for (np = NULL; (np = of_find_all_nodes(np));) {
		struct device_node *pci, *parent = of_get_parent(np);
		if (parent && !strcmp(parent->name, "isa")) {
			of_node_put(parent);
			continue;
		}
		if (strcmp(np->name, "serial") && strcmp(np->type, "serial")) {
			of_node_put(parent);
			continue;
		}
		/* Check for known pciclass, and also check wether we have
		 * a device with child nodes for ports or not
		 */
		if (of_device_is_compatible(np, "pciclass,0700") ||
		    of_device_is_compatible(np, "pciclass,070002"))
			pci = np;
		else if (of_device_is_compatible(parent, "pciclass,0700") ||
			 of_device_is_compatible(parent, "pciclass,070002"))
			pci = parent;
		else {
			of_node_put(parent);
			continue;
		}
		index = add_legacy_pci_port(np, pci);
		if (index >= 0 && np == stdout)
			legacy_serial_console = index;
		of_node_put(parent);
	}
#endif

	DBG("legacy_serial_console = %d\n", legacy_serial_console);
	if (legacy_serial_console >= 0)
		setup_legacy_serial_console(legacy_serial_console);
	DBG(" <- find_legacy_serial_port()\n");
}

static struct platform_device serial_device = {
	.name	= "serial8250",
	.id	= PLAT8250_DEV_PLATFORM,
	.dev	= {
		.platform_data = legacy_serial_ports,
	},
};

static void __init fixup_port_irq(int index,
				  struct device_node *np,
				  struct plat_serial8250_port *port)
{
	unsigned int virq;

	DBG("fixup_port_irq(%d)\n", index);

	virq = irq_of_parse_and_map(np, 0);
	if (virq == NO_IRQ && legacy_serial_infos[index].irq_check_parent) {
		np = of_get_parent(np);
		if (np == NULL)
			return;
		virq = irq_of_parse_and_map(np, 0);
		of_node_put(np);
	}
	if (virq == NO_IRQ)
		return;

	port->irq = virq;
}

static void __init fixup_port_pio(int index,
				  struct device_node *np,
				  struct plat_serial8250_port *port)
{
#ifdef CONFIG_PCI
	struct pci_controller *hose;

	DBG("fixup_port_pio(%d)\n", index);

	hose = pci_find_hose_for_OF_device(np);
	if (hose) {
		unsigned long offset = (unsigned long)hose->io_base_virt -
#ifdef CONFIG_PPC64
			pci_io_base;
#else
			isa_io_base;
#endif
		DBG("port %d, IO %lx -> %lx\n",
		    index, port->iobase, port->iobase + offset);
		port->iobase += offset;
	}
#endif
}

static void __init fixup_port_mmio(int index,
				   struct device_node *np,
				   struct plat_serial8250_port *port)
{
	DBG("fixup_port_mmio(%d)\n", index);

	port->membase = ioremap(port->mapbase, 0x100);
}

/*
 * This is called as an arch initcall, hopefully before the PCI bus is
 * probed and/or the 8250 driver loaded since we need to register our
 * platform devices before 8250 PCI ones are detected as some of them
 * must properly "override" the platform ones.
 *
 * This function fixes up the interrupt value for platform ports as it
 * couldn't be done earlier before interrupt maps have been parsed. It
 * also "corrects" the IO address for PIO ports for the same reason,
 * since earlier, the PHBs virtual IO space wasn't assigned yet. It then
 * registers all those platform ports for use by the 8250 driver when it
 * finally loads.
 */
static int __init serial_dev_init(void)
{
	int i;

	if (legacy_serial_count == 0)
		return -ENODEV;

	/*
	 * Before we register the platfrom serial devices, we need
	 * to fixup their interrupts and their IO ports.
	 */
	DBG("Fixing serial ports interrupts and IO ports ...\n");

	for (i = 0; i < legacy_serial_count; i++) {
		struct plat_serial8250_port *port = &legacy_serial_ports[i];
		struct device_node *np = legacy_serial_infos[i].np;

		if (port->irq == NO_IRQ)
			fixup_port_irq(i, np, port);
		if (port->iotype == UPIO_PORT)
			fixup_port_pio(i, np, port);
		if ((port->iotype == UPIO_MEM) || (port->iotype == UPIO_TSI))
			fixup_port_mmio(i, np, port);
	}

	DBG("Registering platform serial ports\n");

	return platform_device_register(&serial_device);
}
device_initcall(serial_dev_init);


/*
 * This is called very early, as part of console_init() (typically just after
 * time_init()). This function is respondible for trying to find a good
 * default console on serial ports. It tries to match the open firmware
 * default output with one of the available serial console drivers, either
 * one of the platform serial ports that have been probed earlier by
 * find_legacy_serial_ports() or some more platform specific ones.
 */
static int __init check_legacy_serial_console(void)
{
	struct device_node *prom_stdout = NULL;
	int speed = 0, offset = 0;
	const char *name;
	const u32 *spd;

	DBG(" -> check_legacy_serial_console()\n");

	/* The user has requested a console so this is already set up. */
	if (strstr(boot_command_line, "console=")) {
		DBG(" console was specified !\n");
		return -EBUSY;
	}

	if (!of_chosen) {
		DBG(" of_chosen is NULL !\n");
		return -ENODEV;
	}

	if (legacy_serial_console < 0) {
		DBG(" legacy_serial_console not found !\n");
		return -ENODEV;
	}
	/* We are getting a weird phandle from OF ... */
	/* ... So use the full path instead */
	name = of_get_property(of_chosen, "linux,stdout-path", NULL);
	if (name == NULL) {
		DBG(" no linux,stdout-path !\n");
		return -ENODEV;
	}
	prom_stdout = of_find_node_by_path(name);
	if (!prom_stdout) {
		DBG(" can't find stdout package %s !\n", name);
		return -ENODEV;
	}
	DBG("stdout is %s\n", prom_stdout->full_name);

	name = of_get_property(prom_stdout, "name", NULL);
	if (!name) {
		DBG(" stdout package has no name !\n");
		goto not_found;
	}
	spd = of_get_property(prom_stdout, "current-speed", NULL);
	if (spd)
		speed = *spd;

	if (0)
		;
#ifdef CONFIG_SERIAL_8250_CONSOLE
	else if (strcmp(name, "serial") == 0) {
		int i;
		/* Look for it in probed array */
		for (i = 0; i < legacy_serial_count; i++) {
			if (prom_stdout != legacy_serial_infos[i].np)
				continue;
			offset = i;
			speed = legacy_serial_infos[i].speed;
			break;
		}
		if (i >= legacy_serial_count)
			goto not_found;
	}
#endif /* CONFIG_SERIAL_8250_CONSOLE */
#ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
	else if (strcmp(name, "ch-a") == 0)
		offset = 0;
	else if (strcmp(name, "ch-b") == 0)
		offset = 1;
#endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
	else
		goto not_found;
	of_node_put(prom_stdout);

	DBG("Found serial console at ttyS%d\n", offset);

	if (speed) {
		static char __initdata opt[16];
		sprintf(opt, "%d", speed);
		return add_preferred_console("ttyS", offset, opt);
	} else
		return add_preferred_console("ttyS", offset, NULL);

 not_found:
	DBG("No preferred console found !\n");
	of_node_put(prom_stdout);
	return -ENODEV;
}
console_initcall(check_legacy_serial_console);
Commit	Line	Data
463ce0e1 BH	1	#include <linux/kernel.h>
	2	#include <linux/serial.h>
	3	#include <linux/serial_8250.h>
	4	#include <linux/serial_core.h>
	5	#include <linux/console.h>
	6	#include <linux/pci.h>
1a7507c7	7	#include <linux/of_device.h>
463ce0e1 BH	8	#include <asm/io.h>
	9	#include <asm/mmu.h>
	10	#include <asm/prom.h>
	11	#include <asm/serial.h>
	12	#include <asm/udbg.h>
	13	#include <asm/pci-bridge.h>
	14	#include <asm/ppc-pci.h>
	15
	16	#undef DEBUG
	17
	18	#ifdef DEBUG
	19	#define DBG(fmt...) do { printk(fmt); } while(0)
	20	#else
	21	#define DBG(fmt...) do { } while(0)
	22	#endif
	23
	24	#define MAX_LEGACY_SERIAL_PORTS 8
	25
	26	static struct plat_serial8250_port
	27	legacy_serial_ports[MAX_LEGACY_SERIAL_PORTS+1];
	28	static struct legacy_serial_info {
	29	struct device_node *np;
	30	unsigned int speed;
	31	unsigned int clock;
0ebfff14	32	int irq_check_parent;
463ce0e1 BH	33	phys_addr_t taddr;
463ce0e1 BH	34	} legacy_serial_infos[MAX_LEGACY_SERIAL_PORTS];
1a7507c7 PG	35
	36	static struct __initdata of_device_id parents[] = {
	37	{.type = "soc",},
	38	{.type = "tsi-bridge",},
f5903ede ME	39	{.type = "opb", },
f5903ede ME	40	{.compatible = "ibm,opb",},
1a7507c7 PG	41	{.compatible = "simple-bus",},
	42	{.compatible = "wrs,epld-localbus",},
	43	};
	44
463ce0e1 BH	45	static unsigned int legacy_serial_count;
	46	static int legacy_serial_console = -1;
	47
	48	static int __init add_legacy_port(struct device_node *np, int want_index,
	49	int iotype, phys_addr_t base,
b580d46c	50	phys_addr_t taddr, unsigned long irq,
0ebfff14	51	upf_t flags, int irq_check_parent)
463ce0e1	52	{
a7f67bdf JK	53	const u32 clk, spd;
a7f67bdf JK	54	u32 clock = BASE_BAUD * 16;
463ce0e1 BH	55	int index;
	56
	57	/* get clock freq. if present */
e2eb6392	58	clk = of_get_property(np, "clock-frequency", NULL);
31df1678 DW	59	if (clk && *clk)
31df1678 DW	60	clock = *clk;
463ce0e1 BH	61
463ce0e1 BH	62	/* get default speed if present */
e2eb6392	63	spd = of_get_property(np, "current-speed", NULL);
463ce0e1 BH	64
	65	/* If we have a location index, then try to use it */
	66	if (want_index >= 0 && want_index < MAX_LEGACY_SERIAL_PORTS)
	67	index = want_index;
	68	else
	69	index = legacy_serial_count;
	70
	71	/* if our index is still out of range, that mean that
	72	* array is full, we could scan for a free slot but that
	73	* make little sense to bother, just skip the port
	74	*/
	75	if (index >= MAX_LEGACY_SERIAL_PORTS)
	76	return -1;
	77	if (index >= legacy_serial_count)
	78	legacy_serial_count = index + 1;
	79
	80	/* Check if there is a port who already claimed our slot */
	81	if (legacy_serial_infos[index].np != 0) {
	82	/* if we still have some room, move it, else override */
	83	if (legacy_serial_count < MAX_LEGACY_SERIAL_PORTS) {
0ebfff14	84	printk(KERN_DEBUG "Moved legacy port %d -> %d\n",
463ce0e1 BH	85	index, legacy_serial_count);
	86	legacy_serial_ports[legacy_serial_count] =
	87	legacy_serial_ports[index];
	88	legacy_serial_infos[legacy_serial_count] =
	89	legacy_serial_infos[index];
	90	legacy_serial_count++;
	91	} else {
0ebfff14	92	printk(KERN_DEBUG "Replacing legacy port %d\n", index);
463ce0e1 BH	93	}
	94	}
	95
	96	/* Now fill the entry */
	97	memset(&legacy_serial_ports[index], 0,
	98	sizeof(struct plat_serial8250_port));
	99	if (iotype == UPIO_PORT)
	100	legacy_serial_ports[index].iobase = base;
	101	else
8dacaedf	102	legacy_serial_ports[index].mapbase = base;
463ce0e1 BH	103	legacy_serial_ports[index].iotype = iotype;
	104	legacy_serial_ports[index].uartclk = clock;
	105	legacy_serial_ports[index].irq = irq;
b580d46c	106	legacy_serial_ports[index].flags = flags;
463ce0e1 BH	107	legacy_serial_infos[index].taddr = taddr;
	108	legacy_serial_infos[index].np = of_node_get(np);
	109	legacy_serial_infos[index].clock = clock;
	110	legacy_serial_infos[index].speed = spd ? *spd : 0;
0ebfff14	111	legacy_serial_infos[index].irq_check_parent = irq_check_parent;
463ce0e1	112
0ebfff14	113	printk(KERN_DEBUG "Found legacy serial port %d for %s\n",
463ce0e1	114	index, np->full_name);
0ebfff14	115	printk(KERN_DEBUG " %s=%llx, taddr=%llx, irq=%lx, clk=%d, speed=%d\n",
463ce0e1 BH	116	(iotype == UPIO_PORT) ? "port" : "mem",
	117	(unsigned long long)base, (unsigned long long)taddr, irq,
	118	legacy_serial_ports[index].uartclk,
	119	legacy_serial_infos[index].speed);
	120
	121	return index;
	122	}
	123
b580d46c KG	124	static int __init add_legacy_soc_port(struct device_node *np,
	125	struct device_node *soc_dev)
	126	{
f704b8d1	127	u64 addr;
a7f67bdf	128	const u32 *addrp;
abb4a239 DG	129	upf_t flags = UPF_BOOT_AUTOCONF \| UPF_SKIP_TEST \| UPF_SHARE_IRQ
abb4a239 DG	130	\| UPF_FIXED_PORT;
be9633e9	131	struct device_node *tsi = of_get_parent(np);
b580d46c KG	132
	133	/* We only support ports that have a clock frequency properly
	134	* encoded in the device-tree.
	135	*/
e2eb6392	136	if (of_get_property(np, "clock-frequency", NULL) == NULL)
b580d46c KG	137	return -1;
b580d46c KG	138
1e6d1f26 JL	139	/* if reg-shift or offset, don't try to use it */
	140	if ((of_get_property(np, "reg-shift", NULL) != NULL) \|\|
	141	(of_get_property(np, "reg-offset", NULL) != NULL))
	142	return -1;
	143
8d38a5b2	144	/* if rtas uses this device, don't try to use it as well */
e2eb6392	145	if (of_get_property(np, "used-by-rtas", NULL) != NULL)
8d38a5b2 AB	146	return -1;
8d38a5b2 AB	147
b580d46c KG	148	/* Get the address */
	149	addrp = of_get_address(soc_dev, 0, NULL, NULL);
	150	if (addrp == NULL)
	151	return -1;
	152
	153	addr = of_translate_address(soc_dev, addrp);
7c6efda5 BH	154	if (addr == OF_BAD_ADDR)
7c6efda5 BH	155	return -1;
b580d46c KG	156
	157	/* Add port, irq will be dealt with later. We passed a translated
	158	* IO port value. It will be fixed up later along with the irq
	159	*/
be9633e9 ZR	160	if (tsi && !strcmp(tsi->type, "tsi-bridge"))
	161	return add_legacy_port(np, -1, UPIO_TSI, addr, addr, NO_IRQ, flags, 0);
	162	else
	163	return add_legacy_port(np, -1, UPIO_MEM, addr, addr, NO_IRQ, flags, 0);
b580d46c KG	164	}
b580d46c KG	165
463ce0e1	166	static int __init add_legacy_isa_port(struct device_node *np,
017e0fad	167	struct device_node *isa_brg)
463ce0e1	168	{
a7f67bdf JK	169	const u32 *reg;
a7f67bdf JK	170	const char *typep;
463ce0e1	171	int index = -1;
f704b8d1	172	u64 taddr;
463ce0e1	173
7c6efda5 BH	174	DBG(" -> add_legacy_isa_port(%s)\n", np->full_name);
7c6efda5 BH	175
463ce0e1	176	/* Get the ISA port number */
e2eb6392	177	reg = of_get_property(np, "reg", NULL);
463ce0e1 BH	178	if (reg == NULL)
	179	return -1;
	180
	181	/* Verify it's an IO port, we don't support anything else */
	182	if (!(reg[0] & 0x00000001))
	183	return -1;
	184
	185	/* Now look for an "ibm,aix-loc" property that gives us ordering
	186	* if any...
	187	*/
e2eb6392	188	typep = of_get_property(np, "ibm,aix-loc", NULL);
463ce0e1 BH	189
	190	/* If we have a location index, then use it */
	191	if (typep && *typep == 'S')
	192	index = simple_strtol(typep+1, NULL, 0) - 1;
	193
f704b8d1 BH	194	/* Translate ISA address. If it fails, we still register the port
	195	* with no translated address so that it can be picked up as an IO
	196	* port later by the serial driver
	197	*/
463ce0e1	198	taddr = of_translate_address(np, reg);
7c6efda5	199	if (taddr == OF_BAD_ADDR)
f704b8d1	200	taddr = 0;
463ce0e1 BH	201
463ce0e1 BH	202	/* Add port, irq will be dealt with later */
7c6efda5	203	return add_legacy_port(np, index, UPIO_PORT, reg[1], taddr,
0ebfff14	204	NO_IRQ, UPF_BOOT_AUTOCONF, 0);
463ce0e1 BH	205
	206	}
	207
017e0fad	208	#ifdef CONFIG_PCI
463ce0e1 BH	209	static int __init add_legacy_pci_port(struct device_node *np,
	210	struct device_node *pci_dev)
	211	{
f704b8d1	212	u64 addr, base;
a7f67bdf	213	const u32 *addrp;
d2dd482b	214	unsigned int flags;
8dacaedf	215	int iotype, index = -1, lindex = 0;
463ce0e1	216
7c6efda5 BH	217	DBG(" -> add_legacy_pci_port(%s)\n", np->full_name);
7c6efda5 BH	218
463ce0e1 BH	219	/* We only support ports that have a clock frequency properly
	220	* encoded in the device-tree (that is have an fcode). Anything
	221	* else can't be used that early and will be normally probed by
8dacaedf BH	222	* the generic 8250_pci driver later on. The reason is that 8250
	223	* compatible UARTs on PCI need all sort of quirks (port offsets
	224	* etc...) that this code doesn't know about
463ce0e1	225	*/
e2eb6392	226	if (of_get_property(np, "clock-frequency", NULL) == NULL)
463ce0e1	227	return -1;
463ce0e1 BH	228
463ce0e1 BH	229	/* Get the PCI address. Assume BAR 0 */
d2dd482b	230	addrp = of_get_pci_address(pci_dev, 0, NULL, &flags);
463ce0e1 BH	231	if (addrp == NULL)
	232	return -1;
	233
	234	/* We only support BAR 0 for now */
d2dd482b	235	iotype = (flags & IORESOURCE_MEM) ? UPIO_MEM : UPIO_PORT;
463ce0e1	236	addr = of_translate_address(pci_dev, addrp);
7c6efda5 BH	237	if (addr == OF_BAD_ADDR)
7c6efda5 BH	238	return -1;
463ce0e1 BH	239
	240	/* Set the IO base to the same as the translated address for MMIO,
	241	* or to the domain local IO base for PIO (it will be fixed up later)
	242	*/
	243	if (iotype == UPIO_MEM)
	244	base = addr;
	245	else
	246	base = addrp[2];
	247
	248	/* Try to guess an index... If we have subdevices of the pci dev,
	249	* we get to their "reg" property
	250	*/
	251	if (np != pci_dev) {
e2eb6392	252	const u32 *reg = of_get_property(np, "reg", NULL);
463ce0e1	253	if (reg && (*reg < 4))
8dacaedf BH	254	index = lindex = *reg;
	255	}
	256
	257	/* Local index means it's the Nth port in the PCI chip. Unfortunately
	258	* the offset to add here is device specific. We know about those
	259	* EXAR ports and we default to the most common case. If your UART
	260	* doesn't work for these settings, you'll have to add your own special
	261	* cases here
	262	*/
55b61fec SR	263	if (of_device_is_compatible(pci_dev, "pci13a8,152") \|\|
	264	of_device_is_compatible(pci_dev, "pci13a8,154") \|\|
	265	of_device_is_compatible(pci_dev, "pci13a8,158")) {
8dacaedf BH	266	addr += 0x200 * lindex;
	267	base += 0x200 * lindex;
	268	} else {
	269	addr += 8 * lindex;
	270	base += 8 * lindex;
463ce0e1 BH	271	}
	272
	273	/* Add port, irq will be dealt with later. We passed a translated
	274	* IO port value. It will be fixed up later along with the irq
	275	*/
0ebfff14 BH	276	return add_legacy_port(np, index, iotype, base, addr, NO_IRQ,
0ebfff14 BH	277	UPF_BOOT_AUTOCONF, np != pci_dev);
463ce0e1	278	}
017e0fad	279	#endif
463ce0e1	280
37a801c7 MN	281	static void __init setup_legacy_serial_console(int console)
	282	{
	283	struct legacy_serial_info *info =
	284	&legacy_serial_infos[console];
	285	void __iomem *addr;
	286
	287	if (info->taddr == 0)
	288	return;
	289	addr = ioremap(info->taddr, 0x1000);
	290	if (addr == NULL)
	291	return;
	292	if (info->speed == 0)
	293	info->speed = udbg_probe_uart_speed(addr, info->clock);
	294	DBG("default console speed = %d\n", info->speed);
	295	udbg_init_uart(addr, info->speed, info->clock);
	296	}
	297
463ce0e1 BH	298	/*
	299	* This is called very early, as part of setup_system() or eventually
	300	* setup_arch(), basically before anything else in this file. This function
	301	* will try to build a list of all the available 8250-compatible serial ports
	302	* in the machine using the Open Firmware device-tree. It currently only deals
	303	* with ISA and PCI busses but could be extended. It allows a very early boot
	304	* console to be initialized, that list is also used later to provide 8250 with
	305	* the machine non-PCI ports and to properly pick the default console port
	306	*/
	307	void __init find_legacy_serial_ports(void)
	308	{
b580d46c	309	struct device_node np, stdout = NULL;
a7f67bdf	310	const char *path;
463ce0e1 BH	311	int index;
	312
	313	DBG(" -> find_legacy_serial_port()\n");
	314
	315	/* Now find out if one of these is out firmware console */
e2eb6392	316	path = of_get_property(of_chosen, "linux,stdout-path", NULL);
b580d46c KG	317	if (path != NULL) {
	318	stdout = of_find_node_by_path(path);
	319	if (stdout)
	320	DBG("stdout is %s\n", stdout->full_name);
	321	} else {
463ce0e1	322	DBG(" no linux,stdout-path !\n");
463ce0e1	323	}
b580d46c	324
1a7507c7	325	/* Iterate over all the 16550 ports, looking for known parents */
3329c0d1	326	for_each_compatible_node(np, "serial", "ns16550") {
1a7507c7 PG	327	struct device_node *parent = of_get_parent(np);
	328	if (!parent)
	329	continue;
	330	if (of_match_node(parents, parent) != NULL) {
b580d46c KG	331	index = add_legacy_soc_port(np, np);
	332	if (index >= 0 && np == stdout)
	333	legacy_serial_console = index;
	334	}
1a7507c7	335	of_node_put(parent);
463ce0e1 BH	336	}
463ce0e1 BH	337
1a7507c7	338	/* Next, fill our array with ISA ports */
3329c0d1	339	for_each_node_by_type(np, "serial") {
463ce0e1 BH	340	struct device_node *isa = of_get_parent(np);
	341	if (isa && !strcmp(isa->name, "isa")) {
	342	index = add_legacy_isa_port(np, isa);
	343	if (index >= 0 && np == stdout)
	344	legacy_serial_console = index;
	345	}
	346	of_node_put(isa);
	347	}
	348
017e0fad	349	#ifdef CONFIG_PCI
463ce0e1 BH	350	/* Next, try to locate PCI ports */
	351	for (np = NULL; (np = of_find_all_nodes(np));) {
	352	struct device_node pci, parent = of_get_parent(np);
	353	if (parent && !strcmp(parent->name, "isa")) {
	354	of_node_put(parent);
	355	continue;
	356	}
	357	if (strcmp(np->name, "serial") && strcmp(np->type, "serial")) {
	358	of_node_put(parent);
	359	continue;
	360	}
	361	/* Check for known pciclass, and also check wether we have
	362	* a device with child nodes for ports or not
	363	*/
55b61fec SR	364	if (of_device_is_compatible(np, "pciclass,0700") \|\|
55b61fec SR	365	of_device_is_compatible(np, "pciclass,070002"))
463ce0e1	366	pci = np;
55b61fec SR	367	else if (of_device_is_compatible(parent, "pciclass,0700") \|\|
55b61fec SR	368	of_device_is_compatible(parent, "pciclass,070002"))
463ce0e1 BH	369	pci = parent;
	370	else {
	371	of_node_put(parent);
	372	continue;
	373	}
	374	index = add_legacy_pci_port(np, pci);
	375	if (index >= 0 && np == stdout)
	376	legacy_serial_console = index;
	377	of_node_put(parent);
	378	}
017e0fad	379	#endif
463ce0e1 BH	380
463ce0e1 BH	381	DBG("legacy_serial_console = %d\n", legacy_serial_console);
37a801c7 MN	382	if (legacy_serial_console >= 0)
37a801c7 MN	383	setup_legacy_serial_console(legacy_serial_console);
463ce0e1 BH	384	DBG(" <- find_legacy_serial_port()\n");
	385	}
	386
	387	static struct platform_device serial_device = {
	388	.name = "serial8250",
	389	.id = PLAT8250_DEV_PLATFORM,
	390	.dev = {
	391	.platform_data = legacy_serial_ports,
	392	},
	393	};
	394
	395	static void __init fixup_port_irq(int index,
	396	struct device_node *np,
	397	struct plat_serial8250_port *port)
	398	{
0ebfff14 BH	399	unsigned int virq;
0ebfff14 BH	400
463ce0e1 BH	401	DBG("fixup_port_irq(%d)\n", index);
463ce0e1 BH	402
0ebfff14 BH	403	virq = irq_of_parse_and_map(np, 0);
	404	if (virq == NO_IRQ && legacy_serial_infos[index].irq_check_parent) {
	405	np = of_get_parent(np);
	406	if (np == NULL)
	407	return;
	408	virq = irq_of_parse_and_map(np, 0);
	409	of_node_put(np);
463ce0e1	410	}
0ebfff14	411	if (virq == NO_IRQ)
463ce0e1 BH	412	return;
463ce0e1 BH	413
0ebfff14	414	port->irq = virq;
463ce0e1 BH	415	}
	416
	417	static void __init fixup_port_pio(int index,
	418	struct device_node *np,
	419	struct plat_serial8250_port *port)
	420	{
017e0fad	421	#ifdef CONFIG_PCI
463ce0e1 BH	422	struct pci_controller *hose;
	423
	424	DBG("fixup_port_pio(%d)\n", index);
	425
	426	hose = pci_find_hose_for_OF_device(np);
	427	if (hose) {
	428	unsigned long offset = (unsigned long)hose->io_base_virt -
	429	#ifdef CONFIG_PPC64
	430	pci_io_base;
	431	#else
	432	isa_io_base;
	433	#endif
	434	DBG("port %d, IO %lx -> %lx\n",
	435	index, port->iobase, port->iobase + offset);
	436	port->iobase += offset;
	437	}
017e0fad	438	#endif
463ce0e1 BH	439	}
463ce0e1 BH	440
8dacaedf BH	441	static void __init fixup_port_mmio(int index,
	442	struct device_node *np,
	443	struct plat_serial8250_port *port)
	444	{
	445	DBG("fixup_port_mmio(%d)\n", index);
	446
	447	port->membase = ioremap(port->mapbase, 0x100);
	448	}
	449
463ce0e1 BH	450	/*
	451	* This is called as an arch initcall, hopefully before the PCI bus is
	452	* probed and/or the 8250 driver loaded since we need to register our
	453	* platform devices before 8250 PCI ones are detected as some of them
	454	* must properly "override" the platform ones.
	455	*
	456	* This function fixes up the interrupt value for platform ports as it
	457	* couldn't be done earlier before interrupt maps have been parsed. It
	458	* also "corrects" the IO address for PIO ports for the same reason,
	459	* since earlier, the PHBs virtual IO space wasn't assigned yet. It then
	460	* registers all those platform ports for use by the 8250 driver when it
	461	* finally loads.
	462	*/
	463	static int __init serial_dev_init(void)
	464	{
	465	int i;
	466
	467	if (legacy_serial_count == 0)
	468	return -ENODEV;
	469
	470	/*
	471	* Before we register the platfrom serial devices, we need
00d70419	472	* to fixup their interrupts and their IO ports.
463ce0e1 BH	473	*/
	474	DBG("Fixing serial ports interrupts and IO ports ...\n");
	475
	476	for (i = 0; i < legacy_serial_count; i++) {
	477	struct plat_serial8250_port *port = &legacy_serial_ports[i];
	478	struct device_node *np = legacy_serial_infos[i].np;
	479
	480	if (port->irq == NO_IRQ)
	481	fixup_port_irq(i, np, port);
	482	if (port->iotype == UPIO_PORT)
	483	fixup_port_pio(i, np, port);
be9633e9	484	if ((port->iotype == UPIO_MEM) \|\| (port->iotype == UPIO_TSI))
8dacaedf	485	fixup_port_mmio(i, np, port);
463ce0e1 BH	486	}
	487
	488	DBG("Registering platform serial ports\n");
	489
	490	return platform_device_register(&serial_device);
	491	}
ee56c474	492	device_initcall(serial_dev_init);
463ce0e1 BH	493
	494
	495	/*
	496	* This is called very early, as part of console_init() (typically just after
	497	* time_init()). This function is respondible for trying to find a good
	498	* default console on serial ports. It tries to match the open firmware
	499	* default output with one of the available serial console drivers, either
	500	* one of the platform serial ports that have been probed earlier by
	501	* find_legacy_serial_ports() or some more platform specific ones.
	502	*/
	503	static int __init check_legacy_serial_console(void)
	504	{
	505	struct device_node *prom_stdout = NULL;
	506	int speed = 0, offset = 0;
a7f67bdf JK	507	const char *name;
a7f67bdf JK	508	const u32 *spd;
463ce0e1 BH	509
	510	DBG(" -> check_legacy_serial_console()\n");
	511
	512	/* The user has requested a console so this is already set up. */
b8757b21	513	if (strstr(boot_command_line, "console=")) {
463ce0e1 BH	514	DBG(" console was specified !\n");
	515	return -EBUSY;
	516	}
	517
	518	if (!of_chosen) {
	519	DBG(" of_chosen is NULL !\n");
	520	return -ENODEV;
	521	}
b580d46c KG	522
	523	if (legacy_serial_console < 0) {
	524	DBG(" legacy_serial_console not found !\n");
	525	return -ENODEV;
	526	}
463ce0e1 BH	527	/* We are getting a weird phandle from OF ... */
463ce0e1 BH	528	/* ... So use the full path instead */
e2eb6392	529	name = of_get_property(of_chosen, "linux,stdout-path", NULL);
463ce0e1 BH	530	if (name == NULL) {
	531	DBG(" no linux,stdout-path !\n");
	532	return -ENODEV;
	533	}
	534	prom_stdout = of_find_node_by_path(name);
	535	if (!prom_stdout) {
	536	DBG(" can't find stdout package %s !\n", name);
	537	return -ENODEV;
	538	}
	539	DBG("stdout is %s\n", prom_stdout->full_name);
	540
e2eb6392	541	name = of_get_property(prom_stdout, "name", NULL);
463ce0e1 BH	542	if (!name) {
	543	DBG(" stdout package has no name !\n");
	544	goto not_found;
	545	}
e2eb6392	546	spd = of_get_property(prom_stdout, "current-speed", NULL);
463ce0e1 BH	547	if (spd)
	548	speed = *spd;
	549
	550	if (0)
	551	;
	552	#ifdef CONFIG_SERIAL_8250_CONSOLE
	553	else if (strcmp(name, "serial") == 0) {
	554	int i;
	555	/* Look for it in probed array */
	556	for (i = 0; i < legacy_serial_count; i++) {
	557	if (prom_stdout != legacy_serial_infos[i].np)
	558	continue;
	559	offset = i;
	560	speed = legacy_serial_infos[i].speed;
	561	break;
	562	}
	563	if (i >= legacy_serial_count)
	564	goto not_found;
	565	}
	566	#endif /* CONFIG_SERIAL_8250_CONSOLE */
	567	#ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
	568	else if (strcmp(name, "ch-a") == 0)
	569	offset = 0;
	570	else if (strcmp(name, "ch-b") == 0)
	571	offset = 1;
	572	#endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
	573	else
	574	goto not_found;
	575	of_node_put(prom_stdout);
	576
	577	DBG("Found serial console at ttyS%d\n", offset);
	578
	579	if (speed) {
	580	static char __initdata opt[16];
	581	sprintf(opt, "%d", speed);
	582	return add_preferred_console("ttyS", offset, opt);
	583	} else
	584	return add_preferred_console("ttyS", offset, NULL);
	585
	586	not_found:
	587	DBG("No preferred console found !\n");
	588	of_node_put(prom_stdout);
	589	return -ENODEV;
	590	}
	591	console_initcall(check_legacy_serial_console);
	592