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 */