static int __init softuart_init(void) { struct tty_driver *driver; int err; driver = alloc_tty_driver(MAX_SOFTUART_DEVICES); if (!driver) return -ENOMEM; driver->driver_name = "softuart"; driver->name = "softuart"; driver->major = 0; /* dynamic */ driver->minor_start = 0; driver->type = TTY_DRIVER_TYPE_SYSTEM; driver->subtype = SYSTEM_TYPE_SYSCONS; driver->init_termios = tty_std_termios; tty_set_operations(driver, &softuart_ops); err = tty_register_driver(driver); if (err) { put_tty_driver(driver); return err; } softuart_driver = driver; return 0; }
int shell_init() { printk("Enter ecall init\n"); shell_tty_drv = alloc_tty_driver(ES_TTY_MINORS); if (!shell_tty_drv) { printk("Cannot alloc shell tty driver\n"); return -1; } shell_tty_drv->owner = THIS_MODULE; shell_tty_drv->driver_name = "es_serial"; shell_tty_drv->name = "es_tty"; shell_tty_drv->major = ES_TTY_MAJOR; shell_tty_drv->minor_start = 0; shell_tty_drv->type = TTY_DRIVER_TYPE_SERIAL; shell_tty_drv->subtype = SERIAL_TYPE_NORMAL; shell_tty_drv->flags = TTY_DRIVER_REAL_RAW; shell_tty_drv->init_termios = tty_std_termios; shell_tty_drv->init_termios.c_cflag = B921600 | CS8 | CREAD | HUPCL | CLOCAL; tty_set_operations(shell_tty_drv, &shell_ops); if (tty_register_driver(shell_tty_drv)) { printk("Error registering shell tty driver\n"); put_tty_driver(shell_tty_drv); return -1; } printk("Finish ecall init\n"); return 0; }
static int scc_init_drivers(void) { int error; scc_driver = alloc_tty_driver(2); if (!scc_driver) return -ENOMEM; scc_driver->owner = THIS_MODULE; scc_driver->driver_name = "scc"; scc_driver->name = "ttyS"; scc_driver->major = TTY_MAJOR; scc_driver->minor_start = SCC_MINOR_BASE; scc_driver->type = TTY_DRIVER_TYPE_SERIAL; scc_driver->subtype = SERIAL_TYPE_NORMAL; scc_driver->init_termios = tty_std_termios; scc_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; scc_driver->init_termios.c_ispeed = 9600; scc_driver->init_termios.c_ospeed = 9600; scc_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(scc_driver, &scc_ops); if ((error = tty_register_driver(scc_driver))) { printk(KERN_ERR "scc: Couldn't register scc driver, error = %d\n", error); put_tty_driver(scc_driver); return 1; } return 0; }
int register_lte_tty_driver(void) { struct tty_driver *tty_driver; int i; int ret; for (i = 0; i < TTY_MAX_COUNT; i++) { tty_driver = alloc_tty_driver(GDM_TTY_MINOR); if (!tty_driver) return -ENOMEM; tty_driver->owner = THIS_MODULE; tty_driver->driver_name = DRIVER_STRING[i]; tty_driver->name = DEVICE_STRING[i]; tty_driver->major = GDM_TTY_MAJOR; tty_driver->type = TTY_DRIVER_TYPE_SERIAL; tty_driver->subtype = SERIAL_TYPE_NORMAL; tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_driver->init_termios = tty_std_termios; tty_driver->init_termios.c_cflag = B9600 | CS8 | HUPCL | CLOCAL; tty_driver->init_termios.c_lflag = ISIG | ICANON | IEXTEN; tty_set_operations(tty_driver, &gdm_tty_ops); ret = tty_register_driver(tty_driver); if (ret) { put_tty_driver(tty_driver); return ret; } gdm_driver[i] = tty_driver; } return ret; }
int __init rs_init(void) { tty_port_init(&serial_port); serial_driver = alloc_tty_driver(SERIAL_MAX_NUM_LINES); pr_info("%s %s\n", serial_name, serial_version); /* Initialize the tty_driver structure */ serial_driver->driver_name = "iss_serial"; serial_driver->name = "ttyS"; serial_driver->major = TTY_MAJOR; serial_driver->minor_start = 64; serial_driver->type = TTY_DRIVER_TYPE_SERIAL; serial_driver->subtype = SERIAL_TYPE_NORMAL; serial_driver->init_termios = tty_std_termios; serial_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; serial_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(serial_driver, &serial_ops); tty_port_link_device(&serial_port, serial_driver, 0); if (tty_register_driver(serial_driver)) panic("Couldn't register serial driver\n"); return 0; }
void console_init() { int i; for (i = 0; i < NB_CONSOLES; i++) { consoles[i].used = false; consoles[i].lines = 25; consoles[i].cols = 80; consoles[i].attr = DEFAULT_ATTRIBUTE_VALUE; consoles[i].disp_cur = true; consoles[i].cur_x = 0; consoles[i].cur_y = 0; consoles[i].escape_char = false; consoles[i].ansi_escape_code = false; consoles[i].ansi_second_val = false; consoles[i].val = 0; consoles[i].val2 = 0; consoles[i].bright = 1; clear_console(i); } /* Enregistre le driver */ tty_driver = alloc_tty_driver(NB_CONSOLES); tty_driver->driver_name = "console"; tty_driver->devfs_name = "tty"; tty_driver->type = TTY_DRIVER_TYPE_CONSOLE; tty_driver->init_termios = tty_std_termios; tty_driver->ops = &console_ops; tty_register_driver(tty_driver); }
static int vs_add_dev(struct pdp_info *dev) { struct tty_driver *tty_driver; tty_driver = get_tty_driver_by_id(dev); kref_init(&tty_driver->kref); tty_driver->magic = TTY_DRIVER_MAGIC; tty_driver->driver_name = "multipdp"; tty_driver->name = dev->vs_dev.tty_name; tty_driver->major = CSD_MAJOR_NUM; tty_driver->minor_start = get_minor_start_index(dev->id); tty_driver->num = 1; tty_driver->type = TTY_DRIVER_TYPE_SERIAL; tty_driver->subtype = SERIAL_TYPE_NORMAL; tty_driver->flags = TTY_DRIVER_REAL_RAW; /* tty_driver->refcount = dev->vs_dev.refcount; */ /* 2.6 kernel porting */ tty_driver->ttys = dev->vs_dev.tty_table; tty_driver->termios = dev->vs_dev.termios; tty_driver->termios_locked = dev->vs_dev.termios_locked; tty_set_operations(tty_driver, &multipdp_tty_ops); return tty_register_driver(tty_driver); }
static int __init srmcons_init(void) { if (srm_is_registered_console) { struct tty_driver *driver; int err; driver = alloc_tty_driver(MAX_SRM_CONSOLE_DEVICES); if (!driver) return -ENOMEM; driver->driver_name = "srm"; driver->name = "srm"; driver->major = 0; /* dynamic */ driver->minor_start = 0; driver->type = TTY_DRIVER_TYPE_SYSTEM; driver->subtype = SYSTEM_TYPE_SYSCONS; driver->init_termios = tty_std_termios; tty_set_operations(driver, &srmcons_ops); err = tty_register_driver(driver); if (err) { put_tty_driver(driver); return err; } srmcons_driver = driver; } return -ENODEV; }
int ipwireless_tty_init(void) { int result; ipw_tty_driver = alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS); if (!ipw_tty_driver) return -ENOMEM; ipw_tty_driver->owner = THIS_MODULE; ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME; ipw_tty_driver->name = "ttyIPWp"; ipw_tty_driver->major = 0; ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START; ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL; ipw_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; ipw_tty_driver->init_termios = tty_std_termios; ipw_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; ipw_tty_driver->init_termios.c_ispeed = 9600; ipw_tty_driver->init_termios.c_ospeed = 9600; tty_set_operations(ipw_tty_driver, &tty_ops); result = tty_register_driver(ipw_tty_driver); if (result) { printk(KERN_ERR IPWIRELESS_PCCARD_NAME ": failed to register tty driver\n"); put_tty_driver(ipw_tty_driver); return result; } return 0; }
/* * Function ircomm_tty_init() * * Init IrCOMM TTY layer/driver * */ static int __init ircomm_tty_init(void) { driver = alloc_tty_driver(IRCOMM_TTY_PORTS); if (!driver) return -ENOMEM; ircomm_tty = hashbin_new(HB_LOCK); if (ircomm_tty == NULL) { IRDA_ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__); put_tty_driver(driver); return -ENOMEM; } driver->owner = THIS_MODULE; driver->driver_name = "ircomm"; driver->name = "ircomm"; driver->major = IRCOMM_TTY_MAJOR; driver->minor_start = IRCOMM_TTY_MINOR; driver->type = TTY_DRIVER_TYPE_SERIAL; driver->subtype = SERIAL_TYPE_NORMAL; driver->init_termios = tty_std_termios; driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(driver, &ops); if (tty_register_driver(driver)) { IRDA_ERROR("%s(): Couldn't register serial driver\n", __FUNCTION__); put_tty_driver(driver); return -1; } return 0; }
static int __init acm_init(void) { int retval; acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS); if (!acm_tty_driver) return -ENOMEM; acm_tty_driver->owner = THIS_MODULE, acm_tty_driver->driver_name = "acm", acm_tty_driver->name = "ttyACM", acm_tty_driver->major = ACM_TTY_MAJOR, acm_tty_driver->minor_start = 0, acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL, acm_tty_driver->subtype = SERIAL_TYPE_NORMAL, acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; acm_tty_driver->init_termios = tty_std_termios; acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; tty_set_operations(acm_tty_driver, &acm_ops); retval = tty_register_driver(acm_tty_driver); if (retval) { put_tty_driver(acm_tty_driver); return retval; } retval = usb_register(&acm_driver); if (retval) { tty_unregister_driver(acm_tty_driver); put_tty_driver(acm_tty_driver); return retval; } info(DRIVER_VERSION ":" DRIVER_DESC); return 0; }
int ctc_tty_init(void) { int i; ctc_tty_info *info; struct tty_driver *device; DBF_TEXT(trace, 2, __FUNCTION__); driver = kmalloc(sizeof(ctc_tty_driver), GFP_KERNEL); if (driver == NULL) { printk(KERN_WARNING "Out of memory in ctc_tty_modem_init\n"); return -ENOMEM; } memset(driver, 0, sizeof(ctc_tty_driver)); device = alloc_tty_driver(CTC_TTY_MAX_DEVICES); if (!device) { kfree(driver); printk(KERN_WARNING "Out of memory in ctc_tty_modem_init\n"); return -ENOMEM; } device->devfs_name = "ctc/" CTC_TTY_NAME; device->name = CTC_TTY_NAME; device->major = CTC_TTY_MAJOR; device->minor_start = 0; device->type = TTY_DRIVER_TYPE_SERIAL; device->subtype = SERIAL_TYPE_NORMAL; device->init_termios = tty_std_termios; device->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; device->flags = TTY_DRIVER_REAL_RAW; device->driver_name = "ctc_tty", tty_set_operations(device, &ctc_ops); if (tty_register_driver(device)) { printk(KERN_WARNING "ctc_tty: Couldn't register serial-device\n"); put_tty_driver(device); kfree(driver); return -1; } driver->ctc_tty_device = device; for (i = 0; i < CTC_TTY_MAX_DEVICES; i++) { info = &driver->info[i]; init_MUTEX(&info->write_sem); tasklet_init(&info->tasklet, ctc_tty_task, (unsigned long) info); info->magic = CTC_ASYNC_MAGIC; info->line = i; info->tty = 0; info->count = 0; info->blocked_open = 0; init_waitqueue_head(&info->open_wait); init_waitqueue_head(&info->close_wait); skb_queue_head_init(&info->tx_queue); skb_queue_head_init(&info->rx_queue); init_timer(&info->stoptimer); info->stoptimer.function = ctc_tty_stopdev; info->stoptimer.data = (unsigned long)info; info->mcr = UART_MCR_RTS; } return 0; }
static int smbsim_serial_init(void) { SMBSIM_SERIAL_DEV *dev; int i, ret = 0; /* Create device class */ smbsim_serial_class = dev_class_create(DRV_NAME, NUM_DEVS); if (smbsim_serial_class == NULL) { TRACE_MSG(TRACE_LEVEL_ERROR, TRACE_FLAG_DEFAULT, "dev_class_create failed\n"); return -ENOMEM; } /* Allocate TTY driver data */ smbsim_serial_driver = alloc_tty_driver(NUM_DEVS); if (smbsim_serial_driver == NULL) { TRACE_MSG(TRACE_LEVEL_ERROR, TRACE_FLAG_DEFAULT, "alloc_tty_driver failed\n"); ret = -ENOMEM; goto fail1; } /* Initialize TTY driver data */ smbsim_serial_driver->driver_name = DRV_NAME; smbsim_serial_driver->name = "ttySmbSim"; smbsim_serial_driver->major = 0; smbsim_serial_driver->type = TTY_DRIVER_TYPE_SERIAL; smbsim_serial_driver->type = SERIAL_TYPE_NORMAL; smbsim_serial_driver->flags = TTY_DRIVER_REAL_RAW; smbsim_serial_driver->init_termios = tty_std_termios; smbsim_serial_driver->init_termios.c_lflag = 0; tty_set_operations(smbsim_serial_driver, &smbsim_serial_ops); /* Register TTY driver */ ret = tty_register_driver(smbsim_serial_driver); if (ret) { TRACE_ERR("tty_register_driver", ret); goto fail2; } /* Initialize devices */ memset(&smbsim_serial_devs, 0, sizeof(smbsim_serial_devs)); for (i = 0, dev = smbsim_serial_devs; i < NUM_DEVS; i++, dev++) { ret = smbsim_serial_dev_init(dev, i); if (ret) goto fail3; } TRACE_MSG(TRACE_LEVEL_INFO, TRACE_FLAG_DEFAULT, "Driver initialized\n"); return 0; fail3: tty_unregister_driver(smbsim_serial_driver); fail2: put_tty_driver(smbsim_serial_driver); fail1: dev_class_delete(smbsim_serial_class); return ret; }
/* * The serial driver boot-time initialization code! */ static int __init pdc_drv_init(void) { init_timer(&pdc_drv_timer); pdc_drv_timer.function = pdc_drv_poll; mod_timer(&pdc_drv_timer, jiffies + PDC_POLL_DELAY); show_pdc_drv_version(); /* Initialize the tty_driver structure */ memset(&pdc_drv_driver, 0, sizeof (struct tty_driver)); pdc_drv_driver.magic = TTY_DRIVER_MAGIC; pdc_drv_driver.driver_name = "pdc_console"; #ifdef CONFIG_DEVFS_FS pdc_drv_driver.name = "ttb/%d"; #else pdc_drv_driver.name = "ttyB"; #endif pdc_drv_driver.major = PDCCONS_MAJOR; pdc_drv_driver.minor_start = 0; pdc_drv_driver.num = NR_PORTS; pdc_drv_driver.type = TTY_DRIVER_TYPE_SERIAL; pdc_drv_driver.subtype = SERIAL_TYPE_NORMAL; pdc_drv_driver.init_termios = tty_std_termios; pdc_drv_driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; pdc_drv_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS; pdc_drv_driver.refcount = &pdc_drv_refcount; pdc_drv_driver.table = pdc_drv_table; pdc_drv_driver.termios = pdc_drv_termios; pdc_drv_driver.termios_locked = pdc_drv_termios_locked; pdc_drv_driver.open = pdc_open; pdc_drv_driver.close = pdc_close; pdc_drv_driver.write = pdc_write; pdc_drv_driver.put_char = pdc_put_char; pdc_drv_driver.flush_chars = pdc_flush_chars; pdc_drv_driver.write_room = pdc_write_room; pdc_drv_driver.chars_in_buffer = pdc_chars_in_buffer; pdc_drv_driver.flush_buffer = pdc_flush_buffer; pdc_drv_driver.ioctl = pdc_ioctl; pdc_drv_driver.throttle = pdc_throttle; pdc_drv_driver.unthrottle = pdc_unthrottle; pdc_drv_driver.set_termios = pdc_set_termios; pdc_drv_driver.stop = pdc_stop; pdc_drv_driver.start = pdc_start; pdc_drv_driver.hangup = pdc_hangup; pdc_drv_driver.break_ctl = pdc_break; pdc_drv_driver.send_xchar = pdc_send_xchar; pdc_drv_driver.wait_until_sent = pdc_wait_until_sent; pdc_drv_driver.read_proc = NULL; if (tty_register_driver(&pdc_drv_driver)) panic("Couldn't register pdc_console driver\n"); return 0; }
static int __init simrs_init(void) { struct serial_state *state; int retval; if (!ia64_platform_is("hpsim")) return -ENODEV; hp_simserial_driver = alloc_tty_driver(NR_PORTS); if (!hp_simserial_driver) return -ENOMEM; printk(KERN_INFO "SimSerial driver with no serial options enabled\n"); /* Initialize the tty_driver structure */ hp_simserial_driver->driver_name = "simserial"; hp_simserial_driver->name = "ttyS"; hp_simserial_driver->major = TTY_MAJOR; hp_simserial_driver->minor_start = 64; hp_simserial_driver->type = TTY_DRIVER_TYPE_SERIAL; hp_simserial_driver->subtype = SERIAL_TYPE_NORMAL; hp_simserial_driver->init_termios = tty_std_termios; hp_simserial_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; hp_simserial_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(hp_simserial_driver, &hp_ops); state = rs_table; tty_port_init(&state->port); state->port.ops = &hp_port_ops; state->port.close_delay = 0; /* XXX really 0? */ retval = hpsim_get_irq(KEYBOARD_INTR); if (retval < 0) { printk(KERN_ERR "%s: out of interrupt vectors!\n", __func__); goto err_free_tty; } state->irq = retval; /* the port is imaginary */ printk(KERN_INFO "ttyS0 at 0x03f8 (irq = %d) is a 16550\n", state->irq); tty_port_link_device(&state->port, hp_simserial_driver, 0); retval = tty_register_driver(hp_simserial_driver); if (retval) { printk(KERN_ERR "Couldn't register simserial driver\n"); goto err_free_tty; } return 0; err_free_tty: put_tty_driver(hp_simserial_driver); tty_port_destroy(&state->port); return retval; }
int ts27010_tty_init(void) { struct ts27010_tty_data *td; int err; int i; driver = alloc_tty_driver(NR_MUXS); if (driver == NULL) { err = -ENOMEM; goto err0; } td = kzalloc(sizeof(*td), GFP_KERNEL); if (td == NULL) { err = -ENOMEM; goto err1; } for (i = 0; i < NR_MUXS; i++) atomic_set(&td->chan[i].ref_count, 0); driver->driver_state = td; driver->driver_name = "ts0710mux"; driver->name = "ts0710mux"; driver->major = TS0710MUX_MAJOR; driver->major = 234; driver->minor_start = TS0710MUX_MINOR_START; driver->type = TTY_DRIVER_TYPE_SERIAL; driver->subtype = SERIAL_TYPE_NORMAL; driver->init_termios = tty_std_termios; driver->init_termios.c_iflag = 0; driver->init_termios.c_oflag = 0; driver->init_termios.c_cflag = B38400 | CS8 | CREAD; driver->init_termios.c_lflag = 0; driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW; driver->other = NULL; driver->owner = THIS_MODULE; tty_set_operations(driver, &ts27010_tty_ops); if (tty_register_driver(driver)) { pr_err("ts27010: can't register tty driver\n"); err = -EINVAL; goto err2; } return 0; err2: kfree(td); err1: put_tty_driver(driver); err0: return err; }
int capinc_tty_init(void) { struct tty_driver *drv = &capinc_tty_driver; /* Initialize the tty_driver structure */ memset(drv, 0, sizeof(struct tty_driver)); drv->magic = TTY_DRIVER_MAGIC; #if (LINUX_VERSION_CODE > 0x20100) drv->driver_name = "capi_nc"; #endif drv->name = "capi/%d"; drv->major = capi_ttymajor; drv->minor_start = 0; drv->num = CAPINC_NR_PORTS; drv->type = TTY_DRIVER_TYPE_SERIAL; drv->subtype = SERIAL_TYPE_NORMAL; drv->init_termios = tty_std_termios; drv->init_termios.c_iflag = ICRNL; drv->init_termios.c_oflag = OPOST | ONLCR; drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; drv->init_termios.c_lflag = 0; drv->flags = TTY_DRIVER_REAL_RAW|TTY_DRIVER_RESET_TERMIOS; drv->refcount = &capinc_tty_refcount; drv->table = capinc_tty_table; drv->termios = capinc_tty_termios; drv->termios_locked = capinc_tty_termios_locked; drv->open = capinc_tty_open; drv->close = capinc_tty_close; drv->write = capinc_tty_write; drv->put_char = capinc_tty_put_char; drv->flush_chars = capinc_tty_flush_chars; drv->write_room = capinc_tty_write_room; drv->chars_in_buffer = capinc_tty_chars_in_buffer; drv->ioctl = capinc_tty_ioctl; drv->set_termios = capinc_tty_set_termios; drv->throttle = capinc_tty_throttle; drv->unthrottle = capinc_tty_unthrottle; drv->stop = capinc_tty_stop; drv->start = capinc_tty_start; drv->hangup = capinc_tty_hangup; #if (LINUX_VERSION_CODE >= 131394) /* Linux 2.1.66 */ drv->break_ctl = capinc_tty_break_ctl; #endif drv->flush_buffer = capinc_tty_flush_buffer; drv->set_ldisc = capinc_tty_set_ldisc; #if (LINUX_VERSION_CODE >= 131343) drv->send_xchar = capinc_tty_send_xchar; drv->read_proc = capinc_tty_read_proc; #endif if (tty_register_driver(drv)) { printk(KERN_ERR "Couldn't register capi_nc driver\n"); return -1; } return 0; }
void hwc_tty_init (void) { if (!CONSOLE_IS_HWC) return; ctrlchar_init (); memset (&hwc_tty_driver, 0, sizeof (struct tty_driver)); memset (&hwc_tty_data, 0, sizeof (hwc_tty_data_struct)); hwc_tty_driver.magic = TTY_DRIVER_MAGIC; hwc_tty_driver.driver_name = "tty_hwc"; hwc_tty_driver.name = "ttyS"; hwc_tty_driver.name_base = 0; hwc_tty_driver.major = TTY_MAJOR; hwc_tty_driver.minor_start = 64; hwc_tty_driver.num = 1; hwc_tty_driver.type = TTY_DRIVER_TYPE_SYSTEM; hwc_tty_driver.subtype = SYSTEM_TYPE_TTY; hwc_tty_driver.init_termios = tty_std_termios; hwc_tty_driver.init_termios.c_iflag = IGNBRK | IGNPAR; hwc_tty_driver.init_termios.c_oflag = ONLCR; hwc_tty_driver.init_termios.c_lflag = ISIG | ECHO; hwc_tty_driver.flags = TTY_DRIVER_REAL_RAW; hwc_tty_driver.refcount = &hwc_tty_refcount; hwc_tty_driver.table = hwc_tty_table; hwc_tty_driver.termios = hwc_tty_termios; hwc_tty_driver.termios_locked = hwc_tty_termios_locked; hwc_tty_driver.open = hwc_tty_open; hwc_tty_driver.close = hwc_tty_close; hwc_tty_driver.write = hwc_tty_write; hwc_tty_driver.put_char = hwc_tty_put_char; hwc_tty_driver.flush_chars = hwc_tty_flush_chars; hwc_tty_driver.write_room = hwc_tty_write_room; hwc_tty_driver.chars_in_buffer = hwc_tty_chars_in_buffer; hwc_tty_driver.flush_buffer = hwc_tty_flush_buffer; hwc_tty_driver.ioctl = hwc_tty_ioctl; hwc_tty_driver.throttle = NULL; hwc_tty_driver.unthrottle = NULL; hwc_tty_driver.send_xchar = NULL; hwc_tty_driver.set_termios = NULL; hwc_tty_driver.set_ldisc = NULL; hwc_tty_driver.stop = NULL; hwc_tty_driver.start = NULL; hwc_tty_driver.hangup = NULL; hwc_tty_driver.break_ctl = NULL; hwc_tty_driver.wait_until_sent = NULL; hwc_tty_driver.read_proc = NULL; hwc_tty_driver.write_proc = NULL; if (tty_register_driver (&hwc_tty_driver)) panic ("Couldn't register hwc_tty driver\n"); }
static int __init citty_init(void) { int retval; int i; F_ENTER(); /* allocate the tty driver */ citty_tty_driver = alloc_tty_driver(CITTY_TTY_MINORS); if (!citty_tty_driver) return -ENOMEM; /* initialize the tty driver */ citty_tty_driver->owner = THIS_MODULE; citty_tty_driver->driver_name = "citty_tty"; citty_tty_driver->name = "citty"; citty_tty_driver->major = CITTY_TTY_MAJOR; citty_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; citty_tty_driver->subtype = SERIAL_TYPE_NORMAL; citty_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; citty_tty_driver->init_termios = tty_std_termios; /* B115200 | CS8 | CREAD | HUPCL | CLOCAL; */ citty_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; citty_tty_driver->init_termios.c_iflag = IGNBRK | IGNCR | IGNPAR; citty_tty_driver->init_termios.c_oflag = 0; citty_tty_driver->init_termios.c_lflag = 0; tty_set_operations(citty_tty_driver, &serial_ops); /* register the tty driver */ retval = tty_register_driver(citty_tty_driver); if (retval) { printk(KERN_ERR "failed to register citty tty driver"); put_tty_driver(citty_tty_driver); citty_tty_driver = NULL; return retval; } /* register tty devices */ for (i = 0; i < CITTY_TTY_MINORS; ++i) { /* Init buffer */ cci_init_buffer(&txCittyBuf[i]); sema_init(&sem_lock_tty[i], 1); tty_port_init(&citty_port_table[i]); tty_port_register_device(&citty_port_table[i], citty_tty_driver, i, NULL); } printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION "\n"); cctdev_init_module(); F_LEAVE(); return retval; }
/* * The serial driver boot-time initialization code! */ static int __init simrs_init (void) { int i, rc; struct serial_state *state; if (!ia64_platform_is("hpsim")) return -ENODEV; hp_simserial_driver = alloc_tty_driver(1); if (!hp_simserial_driver) return -ENOMEM; show_serial_version(); /* Initialize the tty_driver structure */ hp_simserial_driver->owner = THIS_MODULE; hp_simserial_driver->driver_name = "simserial"; hp_simserial_driver->name = "ttyS"; hp_simserial_driver->major = TTY_MAJOR; hp_simserial_driver->minor_start = 64; hp_simserial_driver->type = TTY_DRIVER_TYPE_SERIAL; hp_simserial_driver->subtype = SERIAL_TYPE_NORMAL; hp_simserial_driver->init_termios = tty_std_termios; hp_simserial_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; hp_simserial_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(hp_simserial_driver, &hp_ops); /* * Let's have a little bit of fun ! */ for (i = 0, state = rs_table; i < NR_PORTS; i++,state++) { if (state->type == PORT_UNKNOWN) continue; if (!state->irq) { if ((rc = assign_irq_vector(AUTO_ASSIGN)) < 0) panic("%s: out of interrupt vectors!\n", __FUNCTION__); state->irq = rc; ia64_ssc_connect_irq(KEYBOARD_INTR, state->irq); } printk(KERN_INFO "ttyS%d at 0x%04lx (irq = %d) is a %s\n", state->line, state->port, state->irq, uart_config[state->type].name); } if (tty_register_driver(hp_simserial_driver)) panic("Couldn't register simserial driver\n"); return 0; }
static int __init srmcons_init(void) { if (srm_is_registered_console) { srmcons_driver.init_termios = tty_std_termios; return tty_register_driver(&srmcons_driver); } return -ENODEV; }
int gdun_tty_setup(void) { int ret; if (gdun_tty_driver == NULL) { gdun_tty_driver = alloc_tty_driver(1); if (gdun_tty_driver == 0) return -ENOMEM; gdun_tty_driver->owner = THIS_MODULE; gdun_tty_driver->driver_name = "gdun"; gdun_tty_driver->name = "gdun"; gdun_tty_driver->major = 0; gdun_tty_driver->minor_start = 0; gdun_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; gdun_tty_driver->subtype = SERIAL_TYPE_NORMAL; gdun_tty_driver->init_termios = tty_std_termios; gdun_tty_driver->init_termios.c_iflag = 0; gdun_tty_driver->init_termios.c_oflag = 0; gdun_tty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; gdun_tty_driver->init_termios.c_lflag = 0; gdun_tty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_set_operations(gdun_tty_driver, &gdun_tty_ops); ret = tty_register_driver(gdun_tty_driver); if (ret) goto ERROR1; } else pr_info("use old driver %p\n", gdun_tty_driver); if (gdun_tty_dev == NULL) { /* this should be dynamic */ gdun_tty_dev = tty_register_device(gdun_tty_driver, 0, 0); if (IS_ERR(gdun_tty_dev)) { ret = (int)gdun_tty_dev; goto ERROR2; } } else pr_info("use old dev %p\n", gdun_tty_dev); pr_info("%s /dev/gdun0\n", __func__); return 0; ERROR2: tty_unregister_driver(gdun_tty_driver); ERROR1: put_tty_driver(gdun_tty_driver); gdun_tty_dev = NULL; gdun_tty_driver = NULL; return ret; }
/* * 3215 tty registration code called from tty_init(). * Most kernel services (incl. kmalloc) are available at this poimt. */ void __init tty3215_init(void) { /* Don't bother registering the tty if we already skipped the console */ if (!CONSOLE_IS_3215) return; /* * Initialize the tty_driver structure * Entries in tty3215_driver that are NOT initialized: * proc_entry, set_termios, flush_buffer, set_ldisc, write_proc */ memset(&tty3215_driver, 0, sizeof(struct tty_driver)); tty3215_driver.magic = TTY_DRIVER_MAGIC; tty3215_driver.driver_name = "tty3215"; tty3215_driver.name = "ttyS"; tty3215_driver.name_base = 0; tty3215_driver.major = TTY_MAJOR; tty3215_driver.minor_start = 64; tty3215_driver.num = NR_3215; tty3215_driver.type = TTY_DRIVER_TYPE_SYSTEM; tty3215_driver.subtype = SYSTEM_TYPE_TTY; tty3215_driver.init_termios = tty_std_termios; tty3215_driver.init_termios.c_iflag = IGNBRK | IGNPAR; tty3215_driver.init_termios.c_oflag = ONLCR | XTABS; tty3215_driver.init_termios.c_lflag = ISIG; tty3215_driver.flags = TTY_DRIVER_REAL_RAW; tty3215_driver.refcount = &tty3215_refcount; tty3215_driver.table = tty3215_table; tty3215_driver.termios = tty3215_termios; tty3215_driver.termios_locked = tty3215_termios_locked; tty3215_driver.open = tty3215_open; tty3215_driver.close = tty3215_close; tty3215_driver.write = tty3215_write; tty3215_driver.put_char = tty3215_put_char; tty3215_driver.flush_chars = tty3215_flush_chars; tty3215_driver.write_room = tty3215_write_room; tty3215_driver.chars_in_buffer = tty3215_chars_in_buffer; tty3215_driver.flush_buffer = tty3215_flush_buffer; tty3215_driver.ioctl = tty3215_ioctl; tty3215_driver.throttle = tty3215_throttle; tty3215_driver.unthrottle = tty3215_unthrottle; tty3215_driver.send_xchar = NULL; tty3215_driver.set_termios = NULL; tty3215_driver.stop = tty3215_stop; tty3215_driver.start = tty3215_start; tty3215_driver.hangup = NULL; tty3215_driver.break_ctl = NULL; tty3215_driver.wait_until_sent = NULL; tty3215_driver.read_proc = NULL; if (tty_register_driver(&tty3215_driver)) panic("Couldn't register tty3215 driver\n"); }
static int __init serial_init (void) { serial_driver.owner = THIS_MODULE; serial_driver.magic = TTY_DRIVER_MAGIC; serial_driver.driver_name = "nkconsole"; serial_driver.name = SERIAL_NK_NAME; /* GMv serial_driver.devfs_name = SERIAL_NK_NAME; */ serial_driver.major = SERIAL_NK_MAJOR; serial_driver.minor_start = SERIAL_NK_MINOR; serial_driver.num = MAX_PORT; serial_driver.type = TTY_DRIVER_TYPE_SERIAL; serial_driver.subtype = SERIAL_TYPE_NORMAL; serial_driver.init_termios = tty_std_termios; serial_driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; /* * For proper operation of /dev/ttyNK1, we need to either * perform "stty -F /dev/ttyNK1 -icrnl" at runtime, or to * remove the ICRNL flag immediately. This will not impact * /dev/ttyNK0, because its parameters are reset by shell. * Device /dev/ttyNK1 needs to be -icrnl because the console * history contains CRs and we should not convert them back * to newlines; this is not keyboard input anymore. */ #ifdef LATER serial_driver.init_termios.c_iflag &= ~ICRNL; #endif serial_driver.flags = TTY_DRIVER_REAL_RAW; kref_init(&serial_driver.kref); serial_driver.ttys = serial_table; serial_driver.termios = serial_termios; serial_driver.termios_locked = serial_termios_locked; serial_driver.ops = &serial_ops; serial_ops.open = serial_open; serial_ops.close = serial_close; serial_ops.write = serial_write; serial_ops.write_room = serial_write_room; serial_ops.chars_in_buffer = serial_chars_in_buffer; serial_ops.flush_buffer = serial_flush_buffer; serial_ops.throttle = serial_throttle; serial_ops.unthrottle = serial_unthrottle; serial_ops.send_xchar = serial_send_xchar; serial_ops.set_termios = serial_set_termios; serial_ops.stop = serial_stop; serial_ops.start = serial_start; serial_ops.wait_until_sent = serial_wait_until_sent; if (tty_register_driver(&serial_driver)) { printk(KERN_ERR "Couldn't register NK console driver\n"); } return 0; }
static int __init pdc_console_tty_driver_init(void) { int err; struct tty_driver *drv; /* Check if the console driver is still registered. * It is unregistered if the pdc console was not selected as the * primary console. */ struct console *tmp; console_lock(); for_each_console(tmp) if (tmp == &pdc_cons) break; console_unlock(); if (!tmp) { printk(KERN_INFO "PDC console driver not registered anymore, not creating %s\n", pdc_cons.name); return -ENODEV; } printk(KERN_INFO "The PDC console driver is still registered, removing CON_BOOT flag\n"); pdc_cons.flags &= ~CON_BOOT; drv = alloc_tty_driver(1); if (!drv) return -ENOMEM; drv->driver_name = "pdc_cons"; drv->name = "ttyB"; drv->major = MUX_MAJOR; drv->minor_start = 0; drv->type = TTY_DRIVER_TYPE_SYSTEM; drv->init_termios = tty_std_termios; drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; tty_set_operations(drv, &pdc_console_tty_ops); err = tty_register_driver(drv); if (err) { printk(KERN_ERR "Unable to register the PDC console TTY driver\n"); return err; } pdc_console_tty_driver = drv; /* No need to initialize the pdc_console_timer if tty isn't allocated */ init_timer(&pdc_console_timer); pdc_console_timer.function = pdc_console_poll; return 0; }
/* * Function ircomm_tty_init() * * Init IrCOMM TTY layer/driver * */ int __init ircomm_tty_init(void) { ircomm_tty = hashbin_new(HB_LOCAL); if (ircomm_tty == NULL) { ERROR(__FUNCTION__ "(), can't allocate hashbin!\n"); return -ENOMEM; } memset(&driver, 0, sizeof(struct tty_driver)); driver.magic = TTY_DRIVER_MAGIC; driver.driver_name = "ircomm"; #ifdef CONFIG_DEVFS_FS driver.name = "ircomm%d"; #else driver.name = "ircomm"; #endif driver.major = IRCOMM_TTY_MAJOR; driver.minor_start = IRCOMM_TTY_MINOR; driver.num = IRCOMM_TTY_PORTS; driver.type = TTY_DRIVER_TYPE_SERIAL; driver.subtype = SERIAL_TYPE_NORMAL; driver.init_termios = tty_std_termios; driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; driver.flags = TTY_DRIVER_REAL_RAW; driver.refcount = &ircomm_tty_refcount; driver.table = ircomm_tty_table; driver.termios = ircomm_tty_termios; driver.termios_locked = ircomm_tty_termios_locked; driver.open = ircomm_tty_open; driver.close = ircomm_tty_close; driver.write = ircomm_tty_write; driver.write_room = ircomm_tty_write_room; driver.chars_in_buffer = ircomm_tty_chars_in_buffer; driver.flush_buffer = ircomm_tty_flush_buffer; driver.ioctl = ircomm_tty_ioctl; driver.throttle = ircomm_tty_throttle; driver.unthrottle = ircomm_tty_unthrottle; driver.send_xchar = ircomm_tty_send_xchar; driver.set_termios = ircomm_tty_set_termios; driver.stop = ircomm_tty_stop; driver.start = ircomm_tty_start; driver.hangup = ircomm_tty_hangup; driver.wait_until_sent = ircomm_tty_wait_until_sent; #ifdef CONFIG_PROC_FS driver.read_proc = ircomm_tty_read_proc; #endif /* CONFIG_PROC_FS */ if (tty_register_driver(&driver)) { ERROR(__FUNCTION__ "Couldn't register serial driver\n"); return -1; } return 0; }
static int hsic_setup(struct usb_gadget *g) { struct device *tty_dev; int status; hsic_tty_driver = alloc_tty_driver(1); if (!hsic_tty_driver) return -ENOMEM; hsic_tty_driver->driver_name = "hsic_serial"; hsic_tty_driver->name = HSIC_PREFIX; /* uses dynamically assigned dev_t values */ hsic_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; hsic_tty_driver->subtype = SERIAL_TYPE_NORMAL; hsic_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_RESET_TERMIOS; hsic_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. */ hsic_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; hsic_tty_driver->init_termios.c_ispeed = 9600; hsic_tty_driver->init_termios.c_ospeed = 9600; tty_set_operations(hsic_tty_driver, &hsic_tty_ops); status = tty_register_driver(hsic_tty_driver); if (status) { put_tty_driver(hsic_tty_driver); pr_err("%s: cannot register, err %d\n", __func__, status); goto fail; } tty_dev = tty_register_device(hsic_tty_driver, 0, &g->dev); if (IS_ERR(tty_dev)) pr_warning("%s: no classdev, err %ld\n", __func__, PTR_ERR(tty_dev)); pr_debug("%s: registered hsic0 device\n", __func__); return status; fail: put_tty_driver(hsic_tty_driver); hsic_tty_driver = NULL; return status; }
int __init nb85e_uart_tty_init (void) { struct tty_driver *d = &nb85e_uart_tty_driver; d->driver_name = "nb85e_uart"; #ifdef CONFIG_DEVFS_FS d->name = "tts/%d"; #else d->name = "ttyS"; #endif d->major = TTY_MAJOR; d->minor_start = NB85E_UART_MINOR_BASE; d->num = 1; d->type = TTY_DRIVER_TYPE_SERIAL; d->subtype = SERIAL_TYPE_NORMAL; d->refcount = &nb85e_uart_tty_refcount; d->table = nb85e_uart_ttys; d->termios = nb85e_uart_tty_termios; d->termios_locked = nb85e_uart_tty_termios_locked; d->init_termios = tty_std_termios; d->init_termios.c_cflag = NB85E_UART_INIT_CFLAGS; d->open = nb85e_uart_tty_open; d->put_char = gs_put_char; d->write = gs_write; d->write_room = gs_write_room; d->start = gs_start; d->stop = gs_stop; d->close = gs_close; d->write = gs_write; d->put_char = gs_put_char; d->flush_chars = gs_flush_chars; d->write_room = gs_write_room; d->chars_in_buffer = gs_chars_in_buffer; d->set_termios = gs_set_termios; d->throttle = 0; /* NB85E_UART uarts have no hardware flow control */ d->unthrottle = 0; /* " */ d->stop = gs_stop; d->start = gs_start; d->hangup = gs_hangup; d->flush_buffer = gs_flush_buffer; init_nb85e_uart_tty_ports (); tty_register_driver (&nb85e_uart_tty_driver); }
static int __init pdc_console_tty_driver_init(void) { int err; /* Check if the console driver is still registered. * It is unregistered if the pdc console was not selected as the * primary console. */ struct console *tmp; console_lock(); for_each_console(tmp) if (tmp == &pdc_cons) break; console_unlock(); if (!tmp) { printk(KERN_INFO "PDC console driver not registered anymore, not creating %s\n", pdc_cons.name); return -ENODEV; } printk(KERN_INFO "The PDC console driver is still registered, removing CON_BOOT flag\n"); pdc_cons.flags &= ~CON_BOOT; tty_port_init(&tty_port); pdc_console_tty_driver = alloc_tty_driver(1); if (!pdc_console_tty_driver) return -ENOMEM; pdc_console_tty_driver->driver_name = "pdc_cons"; pdc_console_tty_driver->name = "ttyB"; pdc_console_tty_driver->major = MUX_MAJOR; pdc_console_tty_driver->minor_start = 0; pdc_console_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM; pdc_console_tty_driver->init_termios = tty_std_termios; pdc_console_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS; tty_set_operations(pdc_console_tty_driver, &pdc_console_tty_ops); tty_port_link_device(&tty_port, pdc_console_tty_driver, 0); err = tty_register_driver(pdc_console_tty_driver); if (err) { printk(KERN_ERR "Unable to register the PDC console TTY driver\n"); return err; } return 0; }
int uart_register_driver(struct uart_driver *drv) { struct tty_driver *normal; int i, retval; BUG_ON(drv->state); drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL); if (!drv->state) goto out; normal = alloc_tty_driver(drv->nr); if (!normal) goto out_kfree; drv->tty_driver = normal; normal->driver_name = drv->driver_name; normal->name = drv->dev_name; normal->major = drv->major; normal->minor_start = drv->minor; normal->type = TTY_DRIVER_TYPE_SERIAL; normal->subtype = SERIAL_TYPE_NORMAL; normal->init_termios = tty_std_termios; normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600; normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; normal->driver_state = drv; tty_set_operations(normal, &uart_ops); for (i = 0; i < drv->nr; i++) { struct uart_state *state = drv->state + i; struct tty_port *port = &state->port; tty_port_init(port); port->ops = &uart_port_ops; port->close_delay = HZ / 2; port->closing_wait = 30 * HZ; } retval = tty_register_driver(normal); if (retval >= 0) return retval; put_tty_driver(normal); out_kfree: kfree(drv->state); out: return -ENOMEM; }