static int clps711x_probe(struct device_d *dev)
{
struct clps711x_uart *s;
char syscon_dev[18];
BUG_ON(dev->num_resources != 2);
BUG_ON((dev->id != 0) && (dev->id != 1));
s = xzalloc(sizeof(struct clps711x_uart));
s->uart_clk = clk_get(dev, NULL);
BUG_ON(IS_ERR(s->uart_clk));
s->UBRLCR = dev_get_mem_region(dev, 0);
s->UARTDR = dev_get_mem_region(dev, 1);
sprintf(syscon_dev, "clps711x-syscon%i", dev->id + 1);
s->syscon = syscon_base_lookup_by_pdevname(syscon_dev);
BUG_ON(IS_ERR(s->syscon));
dev->priv = s;
s->cdev.dev = dev;
s->cdev.f_caps = CONSOLE_STDIN | CONSOLE_STDOUT | CONSOLE_STDERR;
s->cdev.tstc = clps711x_tstc;
s->cdev.putc = clps711x_putc;
s->cdev.getc = clps711x_getc;
s->cdev.flush = clps711x_flush;
s->cdev.setbrg = clps711x_setbaudrate;
clps711x_init_port(&s->cdev);
return console_register(&s->cdev);
}
static int netconsole_init(void)
{
struct nc_priv *priv;
struct console_device *cdev;
priv = xzalloc(sizeof(*priv));
cdev = &priv->cdev;
cdev->tstc = nc_tstc;
cdev->putc = nc_putc;
cdev->getc = nc_getc;
g_priv = priv;
priv->fifo = kfifo_alloc(1024);
console_register(cdev);
dev_add_param(&cdev->class_dev, "ip", nc_remoteip_set, NULL, 0);
dev_add_param(&cdev->class_dev, "port", nc_port_set, NULL, 0);
dev_set_param(&cdev->class_dev, "port", "6666");
printf("registered netconsole as %s%d\n", cdev->class_dev.name, cdev->class_dev.id);
return 0;
}
static int netconsole_init(void)
{
struct nc_priv *priv;
struct console_device *cdev;
int ret;
priv = xzalloc(sizeof(*priv));
cdev = &priv->cdev;
cdev->tstc = nc_tstc;
cdev->putc = nc_putc;
cdev->getc = nc_getc;
cdev->devname = "netconsole";
cdev->devid = DEVICE_ID_SINGLE;
cdev->set_active = nc_set_active;
g_priv = priv;
priv->fifo = kfifo_alloc(1024);
ret = console_register(cdev);
if (ret) {
pr_err("registering failed with %s\n", strerror(-ret));
kfree(priv);
return ret;
}
priv->port = 6666;
dev_add_param_ip(&cdev->class_dev, "ip", NULL, NULL, &priv->ip, NULL);
dev_add_param_int(&cdev->class_dev, "port", NULL, NULL, &priv->port, "%u", NULL);
pr_info("registered as %s%d\n", cdev->class_dev.name, cdev->class_dev.id);
return 0;
}
static int s3c_serial_probe(struct device_d *dev)
{
struct resource *iores;
struct s3c_uart *priv;
struct console_device *cdev;
priv = xzalloc(sizeof(struct s3c_uart));
cdev = &priv->cdev;
iores = dev_request_mem_resource(dev, 0);
if (IS_ERR(iores))
return PTR_ERR(iores);
priv->regs = IOMEM(iores->start);
dev->priv = priv;
cdev->dev = dev;
cdev->tstc = s3c_serial_tstc;
cdev->putc = s3c_serial_putc;
cdev->getc = s3c_serial_getc;
cdev->flush = s3c_serial_flush;
cdev->setbrg = s3c_serial_setbaudrate;
s3c_serial_init_port(cdev);
/* Enable UART */
console_register(cdev);
return 0;
}
static int clps711x_probe(struct device_d *dev)
{
struct clps711x_uart *s;
int err, id = dev->id;
char syscon_dev[8];
if (dev->device_node)
id = of_alias_get_id(dev->device_node, "serial");
if (id != 0 && id != 1)
return -EINVAL;
s = xzalloc(sizeof(struct clps711x_uart));
s->uart_clk = clk_get(dev, NULL);
if (IS_ERR(s->uart_clk)) {
err = PTR_ERR(s->uart_clk);
goto out_err;
}
s->base = dev_get_mem_region(dev, 0);
if (!dev->device_node) {
sprintf(syscon_dev, "syscon%i", id + 1);
s->syscon = syscon_base_lookup_by_pdevname(syscon_dev);
} else {
s->syscon = syscon_base_lookup_by_phandle(dev->device_node,
"syscon");
}
if (IS_ERR(s->syscon)) {
err = PTR_ERR(s->syscon);
goto out_err;
}
dev->priv = s;
s->cdev.dev = dev;
s->cdev.tstc = clps711x_tstc;
s->cdev.putc = clps711x_putc;
s->cdev.getc = clps711x_getc;
s->cdev.flush = clps711x_flush;
s->cdev.setbrg = clps711x_setbaudrate;
clps711x_init_port(&s->cdev);
err = console_register(&s->cdev);
out_err:
if (err)
free(s);
return err;
}
static int linux_console_probe(struct device_d *dev)
{
struct console_device *cdev;
struct linux_console_data *data = dev->platform_data;
cdev = xzalloc(sizeof(struct console_device));
cdev->dev = dev;
cdev->f_caps = data->flags;
cdev->tstc = linux_console_tstc;
cdev->putc = linux_console_putc;
cdev->getc = linux_console_getc;
console_register(cdev);
return 0;
}
static int stm_serial_probe(struct device_d *dev)
{
stm_device.cdev.dev = dev;
dev->type_data = &stm_device.cdev;
stm_serial_init_port(&stm_device.cdev);
stm_serial_setbaudrate(&stm_device.cdev, CONFIG_BAUDRATE);
/* Enable UART */
writel(TXE | RXE | UARTEN, dev->map_base + UARTDBGCR);
console_register(&stm_device.cdev);
stm_device.notify.notifier_call = stm_clocksource_clock_change;
clock_register_client(&stm_device.notify);
return 0;
}
static int arm_dcc_probe(struct device_d *dev)
{
struct console_device *cdev;
cdev = &arm_dcc_dev;
cdev->dev = dev;
cdev->f_caps = CONSOLE_STDIN | CONSOLE_STDOUT | CONSOLE_STDERR;
cdev->tstc = arm_dcc_tstc;
cdev->putc = arm_dcc_putc;
cdev->getc = arm_dcc_getc;
/* Enable UART */
console_register(cdev);
return 0;
}
static int linux_console_probe(struct device_d *dev)
{
struct console_device *cdev;
struct linux_console_data *data = dev->platform_data;
cdev = xzalloc(sizeof(struct console_device));
cdev->dev = dev;
if (data->stdinfd >= 0) {
cdev->tstc = linux_console_tstc;
cdev->getc = linux_console_getc;
}
if (data->stdoutfd >= 0)
cdev->putc = linux_console_putc;
console_register(cdev);
return 0;
}
static int blackfin_serial_probe(struct device_d *dev)
{
struct console_device *cdev;
cdev = xzalloc(sizeof(struct console_device));
cdev->dev = dev;
cdev->f_caps = CONSOLE_STDIN | CONSOLE_STDOUT | CONSOLE_STDERR;
cdev->tstc = blackfin_serial_tstc;
cdev->putc = blackfin_serial_putc;
cdev->getc = blackfin_serial_getc;
cdev->setbrg = blackfin_serial_setbaudrate;
blackfin_serial_init_port(cdev);
console_register(cdev);
return 0;
}
static int pl010_probe(struct device_d *dev)
{
struct console_device *cdev;
cdev = xzalloc(sizeof(struct console_device));
dev->priv = dev_request_mem_region(dev, 0);
cdev->dev = dev;
cdev->tstc = pl010_tstc;
cdev->putc = pl010_putc;
cdev->getc = pl010_getc;
cdev->setbrg = pl010_setbaudrate;
pl010_init_port(cdev);
console_register(cdev);
return 0;
}
static int altera_serial_jtag_probe(struct device_d *dev) {
struct console_device *cdev;
struct altera_serial_jtag_priv *priv;
priv = xzalloc(sizeof(*priv));
cdev = &priv->cdev;
priv->regs = dev_request_mem_region(dev, 0);
cdev->dev = dev;
cdev->tstc = altera_serial_jtag_tstc;
cdev->putc = altera_serial_jtag_putc;
cdev->getc = altera_serial_jtag_getc;
cdev->setbrg = altera_serial_jtag_setbaudrate;
console_register(cdev);
return 0;
}
static int netx_serial_probe(struct device_d *dev)
{
struct console_device *cdev;
cdev = xzalloc(sizeof(struct console_device));
dev->priv = dev_request_mem_region(dev, 0);
cdev->dev = dev;
cdev->f_caps = CONSOLE_STDIN | CONSOLE_STDOUT | CONSOLE_STDERR;
cdev->tstc = netx_serial_tstc;
cdev->putc = netx_serial_putc;
cdev->getc = netx_serial_getc;
cdev->setbrg = netx_serial_setbaudrate;
netx_serial_init_port(cdev);
console_register(cdev);
return 0;
}
static int __init gpio_keys_probe(struct device_d *dev)
{
int ret, i, gpio;
struct gpio_keys_platform_data *pdata;
struct console_device *cdev;
pdata = dev->platform_data;
if (!pdata) {
/* small (so we copy it) but critical! */
pr_err("missing platform_data\n");
return -ENODEV;
}
if (!pdata->fifo_size)
pdata->fifo_size = 50;
pdata->recv_fifo = kfifo_alloc(pdata->fifo_size);
for (i = 0; i < pdata->nbuttons; i++) {
gpio = pdata->buttons[i].gpio;
ret = gpio_request(gpio, "gpio_keys");
if (ret) {
pr_err("gpio_keys: (%d) can not be requested\n", gpio);
return ret;
}
gpio_direction_input(gpio);
}
pdata->poller.func = gpio_key_poller;
cdev = &pdata->cdev;
dev->type_data = cdev;
cdev->dev = dev;
cdev->f_caps = CONSOLE_STDIN;
cdev->tstc = gpio_keys_tstc;
cdev->getc = gpio_keys_getc;
console_register(&pdata->cdev);
return poller_register(&pdata->poller);
}
void main(struct multiboot *mboot) {
int rc;
/* init the kmsg buffer and printk */
console_sys_init();
kmsg_init();
console_register(&kmsg_con);
/* arch might want to setup stuff */
arch_early_init();
printk("kmsg: buffer setup!\n");
printk("sys: kernel relocation: 0x%x -> 0x%x size 0x%x\n",
&kernel_base, &kernel_end,
(uintptr_t)&kernel_end - (uintptr_t)&kernel_base);
parse_multiboot(mboot);
paging_fini();
heap_install();
/* arch should finish init now */
arch_late_init();
printk("sys: init done!\n");
drivers_init();
do_mount();
do_test();
syscall_init();
/* wait forever */
asm volatile("mov $0x1337, %eax");
asm volatile("mov $0x1337, %ebx");
asm volatile("mov $0x1337, %ecx");
asm volatile("mov $0x1337, %edx");
start_sched();
panic("finished with main, but no idle task was started\n");
}
static int init_serial() {
outportb(PORT + 1, 0x00); // Disable all interrupts
outportb(PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
outportb(PORT + 0, 0x03); // Set divisor to 3 (lo byte) 38400 baud
outportb(PORT + 1, 0x00); // (hi byte)
outportb(PORT + 3, 0x03); // 8 bits, no parity, one stop bit
outportb(PORT + 2, 0xC7); // Enable FIFO, clear them, with 14-byte threshold
outportb(PORT + 4, 0x0B); // IRQs enabled, RTS/DSR set
static console_t con = {
.writestring = serial_writestring,
.setcolor = serial_setcolor,
.getcolor = serial_getcolor
};
console_register(con);
serial_writestring("Serial debugging console is up ");
return 1;
}
static int linux_console_probe(struct device_d *dev)
{
struct console_device *cdev;
struct linux_console_data *data = dev->platform_data;
cdev = xzalloc(sizeof(struct console_device));
cdev->dev = dev;
if (data->stdinfd >= 0) {
cdev->tstc = linux_console_tstc;
cdev->getc = linux_console_getc;
}
if (data->stdoutfd >= 0)
cdev->putc = linux_console_putc;
console_register(cdev);
pr_info("%s: registered as %s%d\n", dev->name, cdev->class_dev.name,
cdev->class_dev.id);
return 0;
}
static int netx_serial_probe(struct device_d *dev)
{
struct resource *iores;
struct console_device *cdev;
cdev = xzalloc(sizeof(struct console_device));
iores = dev_request_mem_resource(dev, 0);
if (IS_ERR(iores))
return PTR_ERR(iores);
dev->priv = IOMEM(iores->start);
cdev->dev = dev;
cdev->tstc = netx_serial_tstc;
cdev->putc = netx_serial_putc;
cdev->getc = netx_serial_getc;
cdev->setbrg = netx_serial_setbaudrate;
netx_serial_init_port(cdev);
console_register(cdev);
return 0;
}
static int s3c24x0_serial_probe(struct device_d *dev)
{
struct console_device *cdev;
cdev = malloc(sizeof(struct console_device));
dev->type_data = cdev;
cdev->dev = dev;
cdev->f_caps = CONSOLE_STDIN | CONSOLE_STDOUT | CONSOLE_STDERR;
cdev->tstc = s3c24x0_serial_tstc;
cdev->putc = s3c24x0_serial_putc;
cdev->getc = s3c24x0_serial_getc;
cdev->flush = s3c24x0_serial_flush;
cdev->setbrg = s3c24x0_serial_setbaudrate;
s3c24x0_serial_init_port(cdev);
/* Enable UART */
console_register(cdev);
return 0;
}
static int ar933x_serial_probe(struct device_d *dev)
{
struct console_device *cdev;
struct ar933x_uart_priv *priv;
u32 uart_cs;
cdev = xzalloc(sizeof(struct console_device));
priv = xzalloc(sizeof(struct ar933x_uart_priv));
priv->base = dev_request_mem_region(dev, 0);
if (IS_ERR(priv->base))
return PTR_ERR(priv->base);
dev->priv = priv;
cdev->dev = dev;
cdev->tstc = ar933x_serial_tstc;
cdev->putc = ar933x_serial_putc;
cdev->getc = ar933x_serial_getc;
cdev->setbrg = ar933x_serial_setbaudrate;
priv->clk = clk_get(dev, NULL);
if (IS_ERR(priv->clk)) {
dev_err(dev, "unable to get UART clock\n");
return PTR_ERR(priv->clk);
}
uart_cs = (AR933X_UART_CS_IF_MODE_DCE << AR933X_UART_CS_IF_MODE_S)
| AR933X_UART_CS_TX_READY_ORIDE
| AR933X_UART_CS_RX_READY_ORIDE;
ar933x_serial_writel(cdev, uart_cs, AR933X_UART_CS_REG);
/* FIXME: need ar933x_serial_init_port(cdev); */
console_register(cdev);
return 0;
}
/*
* lcd_an_register
* @lcd: LCD data.
* This function will register a LCD driver.
*/
void lcd_an_register(LCD_AN *lcd)
{
int32_t status = SUCCESS;
/* Initialize LCD. */
lcd->clr_rs(lcd);
lcd->set_rw(lcd);
lcd->clr_en(lcd);
#if (LCD_AN_INIT_DELAY > 0)
/* Need to wait at least 15ms on power up. */
sleep_fms(LCD_AN_INIT_DELAY);
#endif
/* Initialize LCD in 4-bit mode ignore status from initial commands. */
lcd_an_write_register(lcd, LCD_IGNORE_WAIT, 0x33);
lcd_an_write_register(lcd, LCD_IGNORE_WAIT, 0x32);
status = lcd_an_write_register(lcd, 0, 0x28);
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, 0, 0x08);
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, 0, 0x01);
#if (LCD_AN_CLEAR_DELAY > 0)
/* Wait for sometime before writing any more data. */
sleep_fms(LCD_AN_CLEAR_DELAY);
#endif
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, 0, 0x06);
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, 0, 0x0C);
}
if (status == SUCCESS)
{
/* Reset the cursor location. */
lcd->cur_column = lcd->cur_row = 0;
/* Register this LCD driver with console. */
lcd->console.fs.write = &lcd_an_write;
lcd->console.fs.ioctl = &lcd_an_ioctl;
console_register(&lcd->console);
/* There is always some space available for data to be sent. */
lcd->console.fs.flags |= FS_SPACE_AVAILABLE;
#ifdef LCD_AN_DEBUG
lcd_an_fd = fs_open("\\console\\lcd1", 0);
#endif
}
} /* lcd_an_register */
/*
* lcd_an_register
* @lcd: LCD data.
* This function will register a LCD driver.
*/
void lcd_an_register(LCD_AN *lcd)
{
int32_t status = SUCCESS;
/* Initialize LCD. */
LCD_AN_TGT_CLR_RS(lcd);
LCD_AN_TGT_SET_RW(lcd);
LCD_AN_TGT_CLR_EN(lcd);
#if (LCD_AN_INIT_DELAY > 0)
/* Need to wait at least 15ms on power up. */
sleep_ms(LCD_AN_INIT_DELAY);
#endif
/* Send first 0x3. */
lcd_an_send_nibble(lcd, 0x3);
/* Controller still think that we are using 8bit mode so we can still read
* the status bit. */
status = lcd_an_wait_8bit(lcd);
if (status == SUCCESS)
{
/* Send second 0x3. */
LCD_AN_TGT_CLR_RW(lcd);
lcd_an_send_nibble(lcd, 0x3);
/* Wait for LCD to process the command in 8 bit mode. */
status = lcd_an_wait_8bit(lcd);
}
if (status == SUCCESS)
{
/* Send third 0x3. */
LCD_AN_TGT_CLR_RW(lcd);
lcd_an_send_nibble(lcd, 0x3);
/* Wait for LCD to process the command in 8 bit mode. */
status = lcd_an_wait_8bit(lcd);
}
if (status == SUCCESS)
{
/* Switch to 4-bit mode. */
LCD_AN_TGT_CLR_RW(lcd);
lcd_an_send_nibble(lcd, 0x2);
/* Wait for LCD to process the command in 8 bit mode. */
status = lcd_an_wait_8bit(lcd);
}
/* LCD configuration. */
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, FALSE, 0x28);
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, FALSE, 0x28);
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, FALSE, 0x08);
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, FALSE, 0x01);
#if (LCD_AN_CLEAR_DELAY > 0)
/* Wait for sometime before writing any more data. */
sleep_ms(LCD_AN_CLEAR_DELAY);
#endif
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, FALSE, 0x06);
}
if (status == SUCCESS)
{
status = lcd_an_write_register(lcd, FALSE, 0x0C);
}
if (status == SUCCESS)
{
/* Reset the cursor location. */
lcd->cur_column = lcd->cur_row = 0;
/* Register this LCD driver with console. */
lcd->console.fs.write = &lcd_an_write;
lcd->console.fs.ioctl = &lcd_an_ioctl;
console_register(&lcd->console);
/* There is always some space available for data to be sent. */
lcd->console.fs.flags |= FS_SPACE_AVAILABLE;
#ifdef LCD_AN_DEBUG
lcd_an_fd = fs_open("\\console\\lcd1", 0);
/* Connect LCD with debug console. */
fs_connect(lcd_an_fd, debug_fd);
#endif
}
} /* lcd_an_register */
