static int __init viocons_init2(void)
{
atomic_t wait_flag;
int rc;
/* +2 for fudge */
rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
if (rc)
printk(VIOCONS_KERN_WARN "error opening to primary %d\n", rc);
if (viopath_hostLp == HvLpIndexInvalid)
vio_set_hostlp();
/*
* And if the primary is not the same as the hosting LP, open to the
* hosting lp
*/
if ((viopath_hostLp != HvLpIndexInvalid) &&
(viopath_hostLp != HvLpConfig_getPrimaryLpIndex())) {
printk(VIOCONS_KERN_INFO "open path to hosting (%d)\n",
viopath_hostLp);
rc = viopath_open(viopath_hostLp, viomajorsubtype_chario,
VIOCHAR_WINDOW + 2); /* +2 for fudge */
if (rc)
printk(VIOCONS_KERN_WARN
"error opening to partition %d: %d\n",
viopath_hostLp, rc);
}
if (vio_setHandler(viomajorsubtype_chario, vioHandleCharEvent) < 0)
printk(VIOCONS_KERN_WARN
"error seting handler for console events!\n");
/*
* First, try to open the console to the hosting lp.
* Wait on a semaphore for the response.
*/
atomic_set(&wait_flag, 0);
if ((viopath_isactive(viopath_hostLp)) &&
(send_open(viopath_hostLp, (void *)&wait_flag) == 0)) {
printk(VIOCONS_KERN_INFO "hosting partition %d\n",
viopath_hostLp);
while (atomic_read(&wait_flag) == 0)
mb();
atomic_set(&wait_flag, 0);
}
/*
* If we don't have an active console, try the primary
*/
if ((!viopath_isactive(port_info[0].lp)) &&
(viopath_isactive(HvLpConfig_getPrimaryLpIndex())) &&
(send_open(HvLpConfig_getPrimaryLpIndex(), (void *)&wait_flag)
== 0)) {
printk(VIOCONS_KERN_INFO "opening console to primary partition\n");
while (atomic_read(&wait_flag) == 0)
mb();
}
/* Initialize the tty_driver structure */
viotty_driver = alloc_tty_driver(VTTY_PORTS);
viotty_driver->owner = THIS_MODULE;
viotty_driver->driver_name = "vioconsole";
viotty_driver->devfs_name = "vcs/";
viotty_driver->name = "tty";
viotty_driver->name_base = 1;
viotty_driver->major = TTY_MAJOR;
viotty_driver->minor_start = 1;
viotty_driver->type = TTY_DRIVER_TYPE_CONSOLE;
viotty_driver->subtype = 1;
viotty_driver->init_termios = tty_std_termios;
viotty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
tty_set_operations(viotty_driver, &serial_ops);
if (tty_register_driver(viotty_driver)) {
printk(VIOCONS_KERN_WARN "couldn't register console driver\n");
put_tty_driver(viotty_driver);
viotty_driver = NULL;
}
viocons_init_cfu_buffer();
unregister_console(&viocons_early);
register_console(&viocons);
return 0;
}
void __init
kgdb_console_init(void)
{
register_console(&kgdb_console);
}
static int __init amba_late_console_init(void)
{
if (!(amba_console.flags & CON_ENABLED))
register_console(&amba_console);
return 0;
}
void __init sb1250_serial_console_init(void)
{
register_console(&sb1250_ser_cons);
}
void __init arc_console_init(void)
{
register_console(&arc_cons);
}
static void pstore_register_console(void)
{
register_console(&pstore_console);
}
void __init sgi_prom_console_init(void )
{
register_console(&sercons);
}
static int __init netx_console_init(void)
{
register_console(&netx_console);
return 0;
}
static int __init sirfsoc_uart_console_init(void)
{
register_console(&sirfsoc_uart_console);
return 0;
}
static int ram_console_init(struct ram_console_buffer *buffer,
#endif
size_t buffer_size, const char *bootinfo,
char *old_buf)
{
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
int numerr;
uint8_t *par;
#endif
ram_console_buffer = buffer;
ram_console_buffer_size =
buffer_size - sizeof(struct ram_console_buffer);
if (ram_console_buffer_size > buffer_size) {
pr_err("[K] ram_console: buffer %p, invalid size %zu, "
"datasize %zu\n", buffer, buffer_size,
ram_console_buffer_size);
return 0;
}
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
ECC_BLOCK_SIZE) + 1) * ECC_SIZE;
if (ram_console_buffer_size > buffer_size) {
pr_err("[K] ram_console: buffer %p, invalid size %zu, "
"non-ecc datasize %zu\n",
buffer, buffer_size, ram_console_buffer_size);
return 0;
}
ram_console_par_buffer = buffer->data + ram_console_buffer_size;
ram_console_rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);
if (ram_console_rs_decoder == NULL) {
printk(KERN_INFO "[K] ram_console: init_rs failed\n");
return 0;
}
ram_console_corrected_bytes = 0;
ram_console_bad_blocks = 0;
par = ram_console_par_buffer +
DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
numerr = ram_console_decode_rs8(buffer, sizeof(*buffer), par);
if (numerr > 0) {
printk(KERN_INFO "[K] ram_console: error in header, %d\n", numerr);
ram_console_corrected_bytes += numerr;
} else if (numerr < 0) {
printk(KERN_INFO
"[K] ram_console: uncorrectable error in header\n");
ram_console_bad_blocks++;
}
#endif
if (buffer->sig == RAM_CONSOLE_SIG) {
if (buffer->size > ram_console_buffer_size
|| buffer->start > buffer->size)
printk(KERN_INFO "[K] ram_console: found existing invalid "
"buffer, size %d, start %d\n",
buffer->size, buffer->start);
else {
printk(KERN_INFO "[K] ram_console: found existing buffer, "
"size %d, start %d\n",
buffer->size, buffer->start);
ram_console_save_old(buffer, bootinfo, old_buf);
}
} else {
printk(KERN_INFO "[K] ram_console: no valid data in buffer "
"(sig = 0x%08x)\n", buffer->sig);
}
buffer->sig = RAM_CONSOLE_SIG;
buffer->start = 0;
buffer->size = 0;
register_console(&ram_console);
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE
console_verbose();
#endif
return 0;
}
void __init omahauart_console_init(void)
{
register_console(&omaha_console);
}
static int __init ram_console_init(struct ram_console_buffer *buffer,
size_t buffer_size, const char *bootinfo,
char *old_buf)
{
int i;
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
int numerr;
uint8_t *par;
#endif
ram_console_buffer = buffer;
ram_console_buffer_size =
buffer_size - sizeof(struct ram_console_buffer);
if (ram_console_buffer_size > buffer_size) {
pr_err("ram_console: buffer %p, invalid size %zu, "
"datasize %zu\n", buffer, buffer_size,
ram_console_buffer_size);
return 0;
}
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ERROR_CORRECTION
ram_console_buffer_size -= (DIV_ROUND_UP(ram_console_buffer_size,
ECC_BLOCK_SIZE) + 1) * ECC_SIZE;
if (ram_console_buffer_size > buffer_size) {
pr_err("ram_console: buffer %p, invalid size %zu, "
"non-ecc datasize %zu\n",
buffer, buffer_size, ram_console_buffer_size);
return 0;
}
ram_console_par_buffer = buffer->data + ram_console_buffer_size;
/* first consecutive root is 0
* primitive element to generate roots = 1
*/
ram_console_rs_decoder = init_rs(ECC_SYMSIZE, ECC_POLY, 0, 1, ECC_SIZE);
if (ram_console_rs_decoder == NULL) {
printk(KERN_INFO "ram_console: init_rs failed\n");
return 0;
}
ram_console_corrected_bytes = 0;
ram_console_bad_blocks = 0;
par = ram_console_par_buffer +
DIV_ROUND_UP(ram_console_buffer_size, ECC_BLOCK_SIZE) * ECC_SIZE;
numerr = ram_console_decode_rs8(buffer, sizeof(*buffer), par);
if (numerr > 0) {
printk(KERN_INFO "ram_console: error in header, %d\n", numerr);
ram_console_corrected_bytes += numerr;
} else if (numerr < 0) {
printk(KERN_INFO
"ram_console: uncorrectable error in header\n");
ram_console_bad_blocks++;
}
#endif
if (buffer->sig == RAM_CONSOLE_SIG) {
if (buffer->size > ram_console_buffer_size
|| buffer->start > buffer->size)
printk(KERN_INFO "ram_console: found existing invalid "
"buffer, size %d, start %d\n",
buffer->size, buffer->start);
else {
printk(KERN_INFO "ram_console: found existing buffer, "
"size %d, start %d\n",
buffer->size, buffer->start);
ram_console_save_old(buffer, bootinfo, old_buf);
}
} else {
printk(KERN_INFO "ram_console: no valid data in buffer "
"(sig = 0x%08x)\n", buffer->sig);
}
buffer->sig = RAM_CONSOLE_SIG;
buffer->start = 0;
buffer->size = 0;
buffer->hw_status = 0;
buffer->shutdown_mode = 0;
buffer->jiffies_current = buffer->jiffies_wdk_kick = buffer->jiffies_idle = INITIAL_JIFFIES;
for (i = 0; i < RC_CPU_COUNT; i++) {
buffer->last_irq_enter[i] = 0;
buffer->jiffies_last_irq_enter[i] = 0;
buffer->last_irq_exit[i] = 0;
buffer->jiffies_last_irq_exit[i] = 0;
buffer->jiffies_last_sched[i] = 0;
memset(buffer->last_sched_comm[i], i, TASK_COMM_LEN);
}
register_console(&ram_console);
#ifdef CONFIG_ANDROID_RAM_CONSOLE_ENABLE_VERBOSE
//console_verbose();
#endif
return 0;
}
void __init dz_serial_console_init(void)
{
dz_init_ports();
register_console(&dz_sercons);
}
static int __init ks8695_console_init(void)
{
register_console(&ks8695_console);
return 0;
}
static int __init apbuart_console_init(void)
{
grlib_apbuart_configure();
register_console(&grlib_apbuart_console);
return 0;
}
static int __init cpm_uart_console_init(void)
{
register_console(&cpm_scc_uart_console);
return 0;
}
static int __init mcf_console_init(void)
{
register_console(&mcf_console);
return 0;
}
static int __init ks8695_console_init(void)
{
add_preferred_console(SERIAL_KS8695_DEVNAME, 0, NULL);
register_console(&ks8695_console);
return 0;
}
static int __init sb1250_cfe_console_init(void)
{
register_console(&sb1250_cfe_cons);
return 0;
}
void memcons_setup (void)
{
register_console (&memcons);
printk (KERN_INFO "Console: static memory buffer (memcons)\n");
}
void __init sa1100_rs_console_init(void)
{
sa1100_init_ports();
register_console(&sa1100_console);
}
__initfunc(void config_amiga(void))
{
amiga_debug_init();
amiga_identify();
mach_sched_init = amiga_sched_init;
mach_keyb_init = amiga_keyb_init;
mach_kbdrate = amiga_kbdrate;
kbd_reset_setup = amiga_kbd_reset_setup;
mach_init_IRQ = amiga_init_IRQ;
mach_default_handler = &amiga_default_handler;
#ifndef CONFIG_APUS
mach_request_irq = amiga_request_irq;
mach_free_irq = amiga_free_irq;
enable_irq = amiga_enable_irq;
disable_irq = amiga_disable_irq;
#endif
mach_get_model = amiga_get_model;
mach_get_hardware_list = amiga_get_hardware_list;
mach_get_irq_list = amiga_get_irq_list;
mach_gettimeoffset = amiga_gettimeoffset;
if (AMIGAHW_PRESENT(A3000_CLK)){
mach_gettod = a3000_gettod;
}
else{ /* if (AMIGAHW_PRESENT(A2000_CLK)) */
mach_gettod = a2000_gettod;
}
mach_max_dma_address = 0xffffffff; /*
* default MAX_DMA=0xffffffff
* on all machines. If we don't
* do so, the SCSI code will not
* be able to allocate any mem
* for transfers, unless we are
* dealing with a Z2 mem only
* system. /Jes
*/
mach_hwclk = amiga_hwclk;
mach_set_clock_mmss = amiga_set_clock_mmss;
#ifdef CONFIG_AMIGA_FLOPPY
mach_floppy_setup = amiga_floppy_setup;
#endif
mach_reset = amiga_reset;
conswitchp = &dummy_con;
kd_mksound = amiga_mksound;
#ifdef CONFIG_MAGIC_SYSRQ
mach_sysrq_key = 0x5f; /* HELP */
mach_sysrq_shift_state = 0x03; /* SHIFT+ALTGR */
mach_sysrq_shift_mask = 0xff; /* all modifiers except CapsLock */
mach_sysrq_xlate = amiga_sysrq_xlate;
#endif
#ifdef CONFIG_HEARTBEAT
mach_heartbeat = amiga_heartbeat;
#endif
/* Fill in the clock values (based on the 700 kHz E-Clock) */
amiga_masterclock = 40*amiga_eclock; /* 28 MHz */
amiga_colorclock = 5*amiga_eclock; /* 3.5 MHz */
/* clear all DMA bits */
custom.dmacon = DMAF_ALL;
/* ensure that the DMA master bit is set */
custom.dmacon = DMAF_SETCLR | DMAF_MASTER;
/* initialize chipram allocator */
amiga_chip_init ();
/* debugging using chipram */
if (!strcmp( m68k_debug_device, "mem" )){
if (!AMIGAHW_PRESENT(CHIP_RAM))
printk("Warning: no chipram present for debugging\n");
else {
amiga_savekmsg_init();
amiga_console_driver.write = amiga_mem_console_write;
register_console(&amiga_console_driver);
}
}
/* our beloved beeper */
if (AMIGAHW_PRESENT(AMI_AUDIO))
amiga_init_sound();
/*
* if it is an A3000, set the magic bit that forces
* a hard rekick
*/
if (AMIGAHW_PRESENT(MAGIC_REKICK))
*(unsigned char *)ZTWO_VADDR(0xde0002) |= 0x80;
}
static int __init xencons_init(void)
{
int rc;
if (!is_running_on_xen())
return -ENODEV;
if (xc_mode == XC_OFF)
return 0;
if (!is_initial_xendomain()) {
rc = xencons_ring_init();
if (rc)
return rc;
}
xencons_driver = alloc_tty_driver((xc_mode == XC_TTY) ?
MAX_NR_CONSOLES : 1);
if (xencons_driver == NULL)
return -ENOMEM;
DRV(xencons_driver)->name = "xencons";
DRV(xencons_driver)->major = TTY_MAJOR;
DRV(xencons_driver)->type = TTY_DRIVER_TYPE_SERIAL;
DRV(xencons_driver)->subtype = SERIAL_TYPE_NORMAL;
DRV(xencons_driver)->init_termios = tty_std_termios;
DRV(xencons_driver)->flags =
TTY_DRIVER_REAL_RAW |
TTY_DRIVER_RESET_TERMIOS |
TTY_DRIVER_NO_DEVFS;
DRV(xencons_driver)->termios = xencons_termios;
DRV(xencons_driver)->termios_locked = xencons_termios_locked;
switch (xc_mode) {
case XC_XVC:
DRV(xencons_driver)->name = "xvc";
DRV(xencons_driver)->major = XEN_XVC_MAJOR;
DRV(xencons_driver)->minor_start = XEN_XVC_MINOR;
DRV(xencons_driver)->name_base = xc_num;
break;
case XC_SERIAL:
DRV(xencons_driver)->name = "ttyS";
DRV(xencons_driver)->minor_start = 64 + xc_num;
DRV(xencons_driver)->name_base = xc_num;
break;
default:
DRV(xencons_driver)->name = "tty";
DRV(xencons_driver)->minor_start = 1;
DRV(xencons_driver)->name_base = 1;
break;
}
tty_set_operations(xencons_driver, &xencons_ops);
if ((rc = tty_register_driver(DRV(xencons_driver))) != 0) {
printk("WARNING: Failed to register Xen virtual "
"console driver as '%s%d'\n",
DRV(xencons_driver)->name,
DRV(xencons_driver)->name_base);
put_tty_driver(xencons_driver);
xencons_driver = NULL;
return rc;
}
tty_register_device(xencons_driver, 0, NULL);
if (is_initial_xendomain()) {
xencons_priv_irq = bind_virq_to_irqhandler(
VIRQ_CONSOLE,
0,
xencons_priv_interrupt,
0,
"console",
NULL);
BUG_ON(xencons_priv_irq < 0);
}
printk("Xen virtual console successfully installed as %s%d\n",
DRV(xencons_driver)->name, xc_num);
/* Check about framebuffer messing up the console */
if (!is_initial_xendomain() &&
!xenbus_exists(XBT_NIL, "device", "vfb")) {
/* FIXME: this is ugly */
unregister_console(&kcons_info);
kcons_info.flags |= CON_CONSDEV;
register_console(&kcons_info);
}
return 0;
}
int bsp_usb_console_init(void)
{
struct console* uart_console;
struct usb_cdc_line_coding coding;
int status = 0;
/* alloc first tty driver for console */
gs_console_tty_driver = alloc_tty_driver(1);
if (!gs_console_tty_driver)
return -ENOMEM;
gs_console_tty_driver->driver_name = "console_ser";
gs_console_tty_driver->name = g_acm_tty_type_table[ACM_CONSOLE_IDX].name;
/* uses dynamically assigned dev_t values */
gs_console_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
gs_console_tty_driver->subtype = SERIAL_TYPE_NORMAL;
gs_console_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
gs_console_tty_driver->init_termios = tty_std_termios;
/* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
* MS-Windows. Otherwise, most of these flags shouldn't affect
* anything unless we were to actually hook up to a serial line.
*/
gs_console_tty_driver->init_termios.c_cflag =
B9600 | CS8 | CREAD | HUPCL | CLOCAL;
gs_console_tty_driver->init_termios.c_ispeed = 9600;
gs_console_tty_driver->init_termios.c_ospeed = 9600;
gs_console_tty_driver->num = 1;
coding.dwDTERate = cpu_to_le32(9600);
coding.bCharFormat = 8;
coding.bParityType = USB_CDC_NO_PARITY;
coding.bDataBits = USB_CDC_1_STOP_BITS;
tty_set_operations(gs_console_tty_driver, &gs_tty_ops);
/* export the driver ... */
status = tty_register_driver(gs_console_tty_driver);
if (status) {
pr_err("%s: cannot register, err %d\n",
__func__, status);
goto console_init_fail;
}
mutex_init(&ports[0].lock);
status = gs_port_alloc(0, &coding);
if (status) {
goto console_init_fail;
}
if (gs_acm_is_console_enable()) {
/* reg from uart shell to usb shell */
uart_console = bsp_get_uart_console();
if (uart_console) {
unregister_console(uart_console);
}
register_console(&gs_console);
console_start(&gs_console);
}
return 0;
console_init_fail:
put_tty_driver(gs_console_tty_driver);
return status;
}
/**
* xuartps_console_init - Initialization call
*
* Returns 0 on success, negative error otherwise
**/
static int __init xuartps_console_init(void)
{
register_console(&xuartps_console);
return 0;
}
static int __init clps711xuart_console_init(void)
{
register_console(&clps711x_console);
return 0;
}
static int __init
serial_pxa_console_init(void)
{
register_console(&serial_pxa_console);
return 0;
}
static int __init m68328_console_init(void)
{
register_console(&m68328_driver);
return 0;
}
static int __init sa1100_rs_console_init(void)
{
sa1100_init_ports();
register_console(&sa1100_console);
return 0;
}
static int __init ulite_console_init(void)
{
register_console(&ulite_console);
return 0;
}
