2005-11-23 01:56:06 -05:00
|
|
|
#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>
|
2008-01-24 11:59:12 -05:00
|
|
|
#include <linux/of_device.h>
|
2005-11-23 01:56:06 -05:00
|
|
|
#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;
|
2006-07-03 07:36:01 -04:00
|
|
|
int irq_check_parent;
|
2005-11-23 01:56:06 -05:00
|
|
|
phys_addr_t taddr;
|
|
|
|
} legacy_serial_infos[MAX_LEGACY_SERIAL_PORTS];
|
2008-01-24 11:59:12 -05:00
|
|
|
|
|
|
|
static struct __initdata of_device_id parents[] = {
|
|
|
|
{.type = "soc",},
|
|
|
|
{.type = "tsi-bridge",},
|
2008-02-05 07:01:50 -05:00
|
|
|
{.type = "opb", },
|
|
|
|
{.compatible = "ibm,opb",},
|
2008-01-24 11:59:12 -05:00
|
|
|
{.compatible = "simple-bus",},
|
|
|
|
{.compatible = "wrs,epld-localbus",},
|
|
|
|
};
|
|
|
|
|
2005-11-23 01:56:06 -05:00
|
|
|
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,
|
2005-12-20 17:16:52 -05:00
|
|
|
phys_addr_t taddr, unsigned long irq,
|
2006-07-03 07:36:01 -04:00
|
|
|
upf_t flags, int irq_check_parent)
|
2005-11-23 01:56:06 -05:00
|
|
|
{
|
2006-07-12 01:35:54 -04:00
|
|
|
const u32 *clk, *spd;
|
|
|
|
u32 clock = BASE_BAUD * 16;
|
2005-11-23 01:56:06 -05:00
|
|
|
int index;
|
|
|
|
|
|
|
|
/* get clock freq. if present */
|
2007-04-03 08:26:41 -04:00
|
|
|
clk = of_get_property(np, "clock-frequency", NULL);
|
2005-11-24 12:08:56 -05:00
|
|
|
if (clk && *clk)
|
|
|
|
clock = *clk;
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
/* get default speed if present */
|
2007-04-03 08:26:41 -04:00
|
|
|
spd = of_get_property(np, "current-speed", NULL);
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
/* 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) {
|
2006-07-03 07:36:01 -04:00
|
|
|
printk(KERN_DEBUG "Moved legacy port %d -> %d\n",
|
2005-11-23 01:56:06 -05:00
|
|
|
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 {
|
2006-07-03 07:36:01 -04:00
|
|
|
printk(KERN_DEBUG "Replacing legacy port %d\n", index);
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
2005-11-28 19:21:59 -05:00
|
|
|
legacy_serial_ports[index].mapbase = base;
|
2005-11-23 01:56:06 -05:00
|
|
|
legacy_serial_ports[index].iotype = iotype;
|
|
|
|
legacy_serial_ports[index].uartclk = clock;
|
|
|
|
legacy_serial_ports[index].irq = irq;
|
2005-12-20 17:16:52 -05:00
|
|
|
legacy_serial_ports[index].flags = flags;
|
2005-11-23 01:56:06 -05:00
|
|
|
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;
|
2006-07-03 07:36:01 -04:00
|
|
|
legacy_serial_infos[index].irq_check_parent = irq_check_parent;
|
2005-11-23 01:56:06 -05:00
|
|
|
|
2006-07-03 07:36:01 -04:00
|
|
|
printk(KERN_DEBUG "Found legacy serial port %d for %s\n",
|
2005-11-23 01:56:06 -05:00
|
|
|
index, np->full_name);
|
2006-07-03 07:36:01 -04:00
|
|
|
printk(KERN_DEBUG " %s=%llx, taddr=%llx, irq=%lx, clk=%d, speed=%d\n",
|
2005-11-23 01:56:06 -05:00
|
|
|
(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;
|
|
|
|
}
|
|
|
|
|
2005-12-20 17:16:52 -05:00
|
|
|
static int __init add_legacy_soc_port(struct device_node *np,
|
|
|
|
struct device_node *soc_dev)
|
|
|
|
{
|
2006-07-04 00:14:07 -04:00
|
|
|
u64 addr;
|
2006-07-12 01:35:54 -04:00
|
|
|
const u32 *addrp;
|
serial: define FIXED_PORT flag for serial_core
At present, the serial core always allows setserial in userspace to change the
port address, irq and base clock of any serial port. That makes sense for
legacy ISA ports, but not for (say) embedded ns16550 compatible serial ports
at peculiar addresses. In these cases, the kernel code configuring the ports
must know exactly where they are, and their clocking arrangements (which can
be unusual on embedded boards). It doesn't make sense for userspace to change
these settings.
Therefore, this patch defines a UPF_FIXED_PORT flag for the uart_port
structure. If this flag is set when the serial port is configured, any
attempts to alter the port's type, io address, irq or base clock with
setserial are ignored.
In addition this patch uses the new flag for on-chip serial ports probed in
arch/powerpc/kernel/legacy_serial.c, and for other hard-wired serial ports
probed by drivers/serial/of_serial.c.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-06 17:48:49 -04:00
|
|
|
upf_t flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_SHARE_IRQ
|
|
|
|
| UPF_FIXED_PORT;
|
2006-08-22 22:20:27 -04:00
|
|
|
struct device_node *tsi = of_get_parent(np);
|
2005-12-20 17:16:52 -05:00
|
|
|
|
|
|
|
/* We only support ports that have a clock frequency properly
|
|
|
|
* encoded in the device-tree.
|
|
|
|
*/
|
2007-04-03 08:26:41 -04:00
|
|
|
if (of_get_property(np, "clock-frequency", NULL) == NULL)
|
2005-12-20 17:16:52 -05:00
|
|
|
return -1;
|
|
|
|
|
2008-07-01 13:52:41 -04:00
|
|
|
/* 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;
|
|
|
|
|
2007-02-13 15:35:38 -05:00
|
|
|
/* if rtas uses this device, don't try to use it as well */
|
2007-04-03 08:26:41 -04:00
|
|
|
if (of_get_property(np, "used-by-rtas", NULL) != NULL)
|
2007-02-13 15:35:38 -05:00
|
|
|
return -1;
|
|
|
|
|
2005-12-20 17:16:52 -05:00
|
|
|
/* Get the address */
|
|
|
|
addrp = of_get_address(soc_dev, 0, NULL, NULL);
|
|
|
|
if (addrp == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
addr = of_translate_address(soc_dev, addrp);
|
2006-07-03 03:24:15 -04:00
|
|
|
if (addr == OF_BAD_ADDR)
|
|
|
|
return -1;
|
2005-12-20 17:16:52 -05:00
|
|
|
|
|
|
|
/* 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
|
|
|
|
*/
|
2006-08-22 22:20:27 -04:00
|
|
|
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);
|
2005-12-20 17:16:52 -05:00
|
|
|
}
|
|
|
|
|
2005-11-23 01:56:06 -05:00
|
|
|
static int __init add_legacy_isa_port(struct device_node *np,
|
2006-01-03 17:15:21 -05:00
|
|
|
struct device_node *isa_brg)
|
2005-11-23 01:56:06 -05:00
|
|
|
{
|
2006-07-12 01:35:54 -04:00
|
|
|
const u32 *reg;
|
|
|
|
const char *typep;
|
2005-11-23 01:56:06 -05:00
|
|
|
int index = -1;
|
2006-07-04 00:14:07 -04:00
|
|
|
u64 taddr;
|
2005-11-23 01:56:06 -05:00
|
|
|
|
2006-07-03 03:24:15 -04:00
|
|
|
DBG(" -> add_legacy_isa_port(%s)\n", np->full_name);
|
|
|
|
|
2005-11-23 01:56:06 -05:00
|
|
|
/* Get the ISA port number */
|
2007-04-03 08:26:41 -04:00
|
|
|
reg = of_get_property(np, "reg", NULL);
|
2005-11-23 01:56:06 -05:00
|
|
|
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...
|
|
|
|
*/
|
2007-04-03 08:26:41 -04:00
|
|
|
typep = of_get_property(np, "ibm,aix-loc", NULL);
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
/* If we have a location index, then use it */
|
|
|
|
if (typep && *typep == 'S')
|
|
|
|
index = simple_strtol(typep+1, NULL, 0) - 1;
|
|
|
|
|
2006-07-04 00:14:07 -04:00
|
|
|
/* 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
|
|
|
|
*/
|
2005-11-23 01:56:06 -05:00
|
|
|
taddr = of_translate_address(np, reg);
|
2006-07-03 03:24:15 -04:00
|
|
|
if (taddr == OF_BAD_ADDR)
|
2006-07-04 00:14:07 -04:00
|
|
|
taddr = 0;
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
/* Add port, irq will be dealt with later */
|
2006-07-03 03:24:15 -04:00
|
|
|
return add_legacy_port(np, index, UPIO_PORT, reg[1], taddr,
|
2006-07-03 07:36:01 -04:00
|
|
|
NO_IRQ, UPF_BOOT_AUTOCONF, 0);
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2006-01-03 17:15:21 -05:00
|
|
|
#ifdef CONFIG_PCI
|
2005-11-23 01:56:06 -05:00
|
|
|
static int __init add_legacy_pci_port(struct device_node *np,
|
|
|
|
struct device_node *pci_dev)
|
|
|
|
{
|
2006-07-04 00:14:07 -04:00
|
|
|
u64 addr, base;
|
2006-07-12 01:35:54 -04:00
|
|
|
const u32 *addrp;
|
2005-11-30 00:57:28 -05:00
|
|
|
unsigned int flags;
|
2005-11-28 19:21:59 -05:00
|
|
|
int iotype, index = -1, lindex = 0;
|
2005-11-23 01:56:06 -05:00
|
|
|
|
2006-07-03 03:24:15 -04:00
|
|
|
DBG(" -> add_legacy_pci_port(%s)\n", np->full_name);
|
|
|
|
|
2005-11-23 01:56:06 -05:00
|
|
|
/* 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
|
2005-11-28 19:21:59 -05:00
|
|
|
* 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
|
2005-11-23 01:56:06 -05:00
|
|
|
*/
|
2007-04-03 08:26:41 -04:00
|
|
|
if (of_get_property(np, "clock-frequency", NULL) == NULL)
|
2005-11-23 01:56:06 -05:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* Get the PCI address. Assume BAR 0 */
|
2005-11-30 00:57:28 -05:00
|
|
|
addrp = of_get_pci_address(pci_dev, 0, NULL, &flags);
|
2005-11-23 01:56:06 -05:00
|
|
|
if (addrp == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* We only support BAR 0 for now */
|
2005-11-30 00:57:28 -05:00
|
|
|
iotype = (flags & IORESOURCE_MEM) ? UPIO_MEM : UPIO_PORT;
|
2005-11-23 01:56:06 -05:00
|
|
|
addr = of_translate_address(pci_dev, addrp);
|
2006-07-03 03:24:15 -04:00
|
|
|
if (addr == OF_BAD_ADDR)
|
|
|
|
return -1;
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
/* 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) {
|
2007-04-03 08:26:41 -04:00
|
|
|
const u32 *reg = of_get_property(np, "reg", NULL);
|
2005-11-23 01:56:06 -05:00
|
|
|
if (reg && (*reg < 4))
|
2005-11-28 19:21:59 -05:00
|
|
|
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
|
|
|
|
*/
|
2007-05-03 03:26:52 -04:00
|
|
|
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")) {
|
2005-11-28 19:21:59 -05:00
|
|
|
addr += 0x200 * lindex;
|
|
|
|
base += 0x200 * lindex;
|
|
|
|
} else {
|
|
|
|
addr += 8 * lindex;
|
|
|
|
base += 8 * lindex;
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
*/
|
2006-07-03 07:36:01 -04:00
|
|
|
return add_legacy_port(np, index, iotype, base, addr, NO_IRQ,
|
|
|
|
UPF_BOOT_AUTOCONF, np != pci_dev);
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
2006-01-03 17:15:21 -05:00
|
|
|
#endif
|
2005-11-23 01:56:06 -05:00
|
|
|
|
2006-03-25 19:07:35 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-11-23 01:56:06 -05:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
2005-12-20 17:16:52 -05:00
|
|
|
struct device_node *np, *stdout = NULL;
|
2006-07-12 01:35:54 -04:00
|
|
|
const char *path;
|
2005-11-23 01:56:06 -05:00
|
|
|
int index;
|
|
|
|
|
|
|
|
DBG(" -> find_legacy_serial_port()\n");
|
|
|
|
|
|
|
|
/* Now find out if one of these is out firmware console */
|
2007-04-03 08:26:41 -04:00
|
|
|
path = of_get_property(of_chosen, "linux,stdout-path", NULL);
|
2005-12-20 17:16:52 -05:00
|
|
|
if (path != NULL) {
|
|
|
|
stdout = of_find_node_by_path(path);
|
|
|
|
if (stdout)
|
|
|
|
DBG("stdout is %s\n", stdout->full_name);
|
|
|
|
} else {
|
2005-11-23 01:56:06 -05:00
|
|
|
DBG(" no linux,stdout-path !\n");
|
|
|
|
}
|
2005-12-20 17:16:52 -05:00
|
|
|
|
2008-01-24 11:59:12 -05:00
|
|
|
/* Iterate over all the 16550 ports, looking for known parents */
|
2007-11-29 14:45:47 -05:00
|
|
|
for_each_compatible_node(np, "serial", "ns16550") {
|
2008-01-24 11:59:12 -05:00
|
|
|
struct device_node *parent = of_get_parent(np);
|
|
|
|
if (!parent)
|
|
|
|
continue;
|
|
|
|
if (of_match_node(parents, parent) != NULL) {
|
2005-12-20 17:16:52 -05:00
|
|
|
index = add_legacy_soc_port(np, np);
|
|
|
|
if (index >= 0 && np == stdout)
|
|
|
|
legacy_serial_console = index;
|
|
|
|
}
|
2008-01-24 11:59:12 -05:00
|
|
|
of_node_put(parent);
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
|
|
|
|
2008-01-24 11:59:12 -05:00
|
|
|
/* Next, fill our array with ISA ports */
|
2007-11-29 14:45:47 -05:00
|
|
|
for_each_node_by_type(np, "serial") {
|
2005-11-23 01:56:06 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2006-01-03 17:15:21 -05:00
|
|
|
#ifdef CONFIG_PCI
|
2005-11-23 01:56:06 -05:00
|
|
|
/* 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
|
|
|
|
*/
|
2007-05-03 03:26:52 -04:00
|
|
|
if (of_device_is_compatible(np, "pciclass,0700") ||
|
|
|
|
of_device_is_compatible(np, "pciclass,070002"))
|
2005-11-23 01:56:06 -05:00
|
|
|
pci = np;
|
2007-05-03 03:26:52 -04:00
|
|
|
else if (of_device_is_compatible(parent, "pciclass,0700") ||
|
|
|
|
of_device_is_compatible(parent, "pciclass,070002"))
|
2005-11-23 01:56:06 -05:00
|
|
|
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);
|
|
|
|
}
|
2006-01-03 17:15:21 -05:00
|
|
|
#endif
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
DBG("legacy_serial_console = %d\n", legacy_serial_console);
|
2006-03-25 19:07:35 -05:00
|
|
|
if (legacy_serial_console >= 0)
|
|
|
|
setup_legacy_serial_console(legacy_serial_console);
|
2005-11-23 01:56:06 -05:00
|
|
|
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)
|
|
|
|
{
|
2006-07-03 07:36:01 -04:00
|
|
|
unsigned int virq;
|
|
|
|
|
2005-11-23 01:56:06 -05:00
|
|
|
DBG("fixup_port_irq(%d)\n", index);
|
|
|
|
|
2006-07-03 07:36:01 -04:00
|
|
|
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);
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
2006-07-03 07:36:01 -04:00
|
|
|
if (virq == NO_IRQ)
|
2005-11-23 01:56:06 -05:00
|
|
|
return;
|
|
|
|
|
2006-07-03 07:36:01 -04:00
|
|
|
port->irq = virq;
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __init fixup_port_pio(int index,
|
|
|
|
struct device_node *np,
|
|
|
|
struct plat_serial8250_port *port)
|
|
|
|
{
|
2006-01-03 17:15:21 -05:00
|
|
|
#ifdef CONFIG_PCI
|
2005-11-23 01:56:06 -05:00
|
|
|
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;
|
|
|
|
}
|
2006-01-03 17:15:21 -05:00
|
|
|
#endif
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
|
|
|
|
2005-11-28 19:21:59 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2005-11-23 01:56:06 -05:00
|
|
|
/*
|
|
|
|
* 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
|
2007-12-17 14:30:12 -05:00
|
|
|
* to fixup their interrupts and their IO ports.
|
2005-11-23 01:56:06 -05:00
|
|
|
*/
|
|
|
|
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);
|
2006-08-22 22:20:27 -04:00
|
|
|
if ((port->iotype == UPIO_MEM) || (port->iotype == UPIO_TSI))
|
2005-11-28 19:21:59 -05:00
|
|
|
fixup_port_mmio(i, np, port);
|
2005-11-23 01:56:06 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
DBG("Registering platform serial ports\n");
|
|
|
|
|
|
|
|
return platform_device_register(&serial_device);
|
|
|
|
}
|
2007-08-22 20:26:37 -04:00
|
|
|
device_initcall(serial_dev_init);
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2006-07-12 01:35:54 -04:00
|
|
|
const char *name;
|
|
|
|
const u32 *spd;
|
2005-11-23 01:56:06 -05:00
|
|
|
|
|
|
|
DBG(" -> check_legacy_serial_console()\n");
|
|
|
|
|
|
|
|
/* The user has requested a console so this is already set up. */
|
2007-02-12 03:54:17 -05:00
|
|
|
if (strstr(boot_command_line, "console=")) {
|
2005-11-23 01:56:06 -05:00
|
|
|
DBG(" console was specified !\n");
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!of_chosen) {
|
|
|
|
DBG(" of_chosen is NULL !\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2005-12-20 17:16:52 -05:00
|
|
|
|
|
|
|
if (legacy_serial_console < 0) {
|
|
|
|
DBG(" legacy_serial_console not found !\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
2005-11-23 01:56:06 -05:00
|
|
|
/* We are getting a weird phandle from OF ... */
|
|
|
|
/* ... So use the full path instead */
|
2007-04-03 08:26:41 -04:00
|
|
|
name = of_get_property(of_chosen, "linux,stdout-path", NULL);
|
2005-11-23 01:56:06 -05:00
|
|
|
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);
|
|
|
|
|
2007-04-03 08:26:41 -04:00
|
|
|
name = of_get_property(prom_stdout, "name", NULL);
|
2005-11-23 01:56:06 -05:00
|
|
|
if (!name) {
|
|
|
|
DBG(" stdout package has no name !\n");
|
|
|
|
goto not_found;
|
|
|
|
}
|
2007-04-03 08:26:41 -04:00
|
|
|
spd = of_get_property(prom_stdout, "current-speed", NULL);
|
2005-11-23 01:56:06 -05:00
|
|
|
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);
|
|
|
|
|