static void __init unix98_pty_init(void) { devfs_mk_dir("pts"); ptm_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX); if (!ptm_driver) panic("Couldn't allocate Unix98 ptm driver"); pts_driver = alloc_tty_driver(NR_UNIX98_PTY_MAX); if (!pts_driver) panic("Couldn't allocate Unix98 pts driver"); ptm_driver->owner = THIS_MODULE; ptm_driver->driver_name = "pty_master"; ptm_driver->name = "ptm"; ptm_driver->major = UNIX98_PTY_MASTER_MAJOR; ptm_driver->minor_start = 0; ptm_driver->type = TTY_DRIVER_TYPE_PTY; ptm_driver->subtype = PTY_TYPE_MASTER; ptm_driver->init_termios = tty_std_termios; ptm_driver->init_termios.c_iflag = 0; ptm_driver->init_termios.c_oflag = 0; ptm_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; ptm_driver->init_termios.c_lflag = 0; ptm_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS | TTY_DRIVER_DEVPTS_MEM; ptm_driver->other = pts_driver; tty_set_operations(ptm_driver, &pty_ops); ptm_driver->ioctl = pty_unix98_ioctl; pts_driver->owner = THIS_MODULE; pts_driver->driver_name = "pty_slave"; pts_driver->name = "pts"; pts_driver->major = UNIX98_PTY_SLAVE_MAJOR; pts_driver->minor_start = 0; pts_driver->type = TTY_DRIVER_TYPE_PTY; pts_driver->subtype = PTY_TYPE_SLAVE; pts_driver->init_termios = tty_std_termios; pts_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; pts_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS | TTY_DRIVER_DEVPTS_MEM; pts_driver->other = ptm_driver; tty_set_operations(pts_driver, &pty_ops); if (tty_register_driver(ptm_driver)) panic("Couldn't register Unix98 ptm driver"); if (tty_register_driver(pts_driver)) panic("Couldn't register Unix98 pts driver"); pty_table[1].data = &ptm_driver->refcount; }
static void __init legacy_pty_init(void) { pty_driver = alloc_tty_driver(NR_PTYS); if (!pty_driver) panic("Couldn't allocate pty driver"); pty_slave_driver = alloc_tty_driver(NR_PTYS); if (!pty_slave_driver) panic("Couldn't allocate pty slave driver"); pty_driver->owner = THIS_MODULE; pty_driver->driver_name = "pty_master"; pty_driver->name = "pty"; pty_driver->devfs_name = "pty/m"; pty_driver->major = PTY_MASTER_MAJOR; pty_driver->minor_start = 0; pty_driver->type = TTY_DRIVER_TYPE_PTY; pty_driver->subtype = PTY_TYPE_MASTER; pty_driver->init_termios = tty_std_termios; pty_driver->init_termios.c_iflag = 0; pty_driver->init_termios.c_oflag = 0; pty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; pty_driver->init_termios.c_lflag = 0; pty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW; pty_driver->other = pty_slave_driver; tty_set_operations(pty_driver, &pty_ops); pty_driver->ioctl = pty_bsd_ioctl; pty_slave_driver->owner = THIS_MODULE; pty_slave_driver->driver_name = "pty_slave"; pty_slave_driver->name = "ttyp"; pty_slave_driver->devfs_name = "pty/s"; pty_slave_driver->major = PTY_SLAVE_MAJOR; pty_slave_driver->minor_start = 0; pty_slave_driver->type = TTY_DRIVER_TYPE_PTY; pty_slave_driver->subtype = PTY_TYPE_SLAVE; pty_slave_driver->init_termios = tty_std_termios; pty_slave_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; pty_slave_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW; pty_slave_driver->other = pty_driver; tty_set_operations(pty_slave_driver, &pty_ops); if (tty_register_driver(pty_driver)) panic("Couldn't register pty driver"); if (tty_register_driver(pty_slave_driver)) panic("Couldn't register pty slave driver"); }
int __init rs_init(void) { tty_port_init(&serial_port); serial_driver = alloc_tty_driver(SERIAL_MAX_NUM_LINES); printk ("%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; }
static int __init srmcons_init(void) { setup_timer(&srmcons_singleton.timer, srmcons_receive_chars, (unsigned long)&srmcons_singleton); if (srm_is_registered_console) { struct tty_driver *driver; int err; driver = alloc_tty_driver(MAX_SRM_CONSOLE_DEVICES); if (!driver) return -ENOMEM; tty_port_init(&srmcons_singleton.port); 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); tty_port_link_device(&srmcons_singleton.port, driver, 0); err = tty_register_driver(driver); if (err) { put_tty_driver(driver); tty_port_destroy(&srmcons_singleton.port); return err; } srmcons_driver = driver; } return -ENODEV; }
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; }
static int __init tty_lan_init(void) { int i; int retval; tty_lan_driver = alloc_tty_driver(TTY_LAN_MINORS_NUM); if(!tty_lan_driver) return -ENOMEM; tty_lan_driver->owner = THIS_MODULE; tty_lan_driver->driver_name = "tty_lan"; tty_lan_driver->name = "ttty_lan"; tty_lan_driver->major = TTY_LAN_MAJOR, tty_lan_driver->minor_start = 0; tty_lan_driver->type = TTY_DRIVER_TYPE_SERIAL; tty_lan_driver->subtype = SERIAL_TYPE_NORMAL; tty_lan_driver->flags = TTY_DRIVER_REAL_RAW; tty_lan_driver->init_termios = tty_std_termios; tty_lan_driver->init_termios.c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL; tty_set_operations(tty_lan_driver, &tty_lan_ops); retval = tty_register_driver(tty_lan_driver); if(retval){ printk(KERN_ERR"Failed to register tty_lan_driver!\n"); put_tty_driver(tty_lan_driver); return retval; } for(i = 0; i < TTY_LAN_MINORS_NUM; i++) tty_register_device(tty_lan_driver, i, NULL); 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; }
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; }
static int __init 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; }
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; }
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); }
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; }
int shell_init(void) { 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 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; }
int __init init_console(void) { serial_driver = alloc_tty_driver(1); if (!serial_driver) return -ENOMEM; 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; }
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; }
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; }
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 * */ 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", __func__); put_tty_driver(driver); return -ENOMEM; } <<<<<<< HEAD
static int __init tty0tty_init(void) { int retval; int i; #ifdef SCULL_DEBUG printk(KERN_DEBUG "%s - \n", __FUNCTION__); #endif /* allocate the tty driver */ tty0tty_tty_driver = alloc_tty_driver(TTY0TTY_MINORS); if (!tty0tty_tty_driver) return -ENOMEM; /* initialize the tty driver */ tty0tty_tty_driver->owner = THIS_MODULE; tty0tty_tty_driver->driver_name = "tty0tty"; tty0tty_tty_driver->name = "tnt"; /* no more devfs subsystem */ tty0tty_tty_driver->major = TTY0TTY_MAJOR; tty0tty_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; tty0tty_tty_driver->subtype = SERIAL_TYPE_NORMAL; tty0tty_tty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW ; /* no more devfs subsystem */ tty0tty_tty_driver->init_termios = tty_std_termios; tty0tty_tty_driver->init_termios.c_iflag = 0; tty0tty_tty_driver->init_termios.c_oflag = 0; tty0tty_tty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; tty0tty_tty_driver->init_termios.c_lflag = 0; tty0tty_tty_driver->init_termios.c_ispeed = 38400; tty0tty_tty_driver->init_termios.c_ospeed = 38400; tty_set_operations(tty0tty_tty_driver, &serial_ops); for(i=0;i<TTY0TTY_MINORS;i++) { tty_port_init(&tport[i]); tty_port_link_device(&tport[i],tty0tty_tty_driver, i); } retval = tty_register_driver(tty0tty_tty_driver); if (retval) { printk(KERN_ERR "failed to register tty0tty tty driver"); put_tty_driver(tty0tty_tty_driver); return retval; } printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION "\n"); return retval; }
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; }
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 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; }
static int userial_init(void) { unsigned i; int status; gs_tty_driver = alloc_tty_driver(MAX_U_SERIAL_PORTS); if (!gs_tty_driver) return -ENOMEM; gs_tty_driver->driver_name = "g_serial"; gs_tty_driver->name = PREFIX; /* uses dynamically assigned dev_t values */ gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; gs_tty_driver->subtype = SERIAL_TYPE_NORMAL; gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; gs_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_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; gs_tty_driver->init_termios.c_ispeed = 9600; gs_tty_driver->init_termios.c_ospeed = 9600; tty_set_operations(gs_tty_driver, &gs_tty_ops); for (i = 0; i < MAX_U_SERIAL_PORTS; i++) mutex_init(&ports[i].lock); /* export the driver ... */ status = tty_register_driver(gs_tty_driver); if (status) { pr_err("%s: cannot register, err %d\n", __func__, status); goto fail; } pr_debug("%s: registered %d ttyGS* device%s\n", __func__, MAX_U_SERIAL_PORTS, (MAX_U_SERIAL_PORTS == 1) ? "" : "s"); return status; fail: put_tty_driver(gs_tty_driver); gs_tty_driver = NULL; return status; }
static int __init ttyprintk_init(void) { int ret = -ENOMEM; void *rp; ttyprintk_driver = alloc_tty_driver(1); if (!ttyprintk_driver) return ret; ttyprintk_driver->owner = THIS_MODULE; ttyprintk_driver->driver_name = "ttyprintk"; ttyprintk_driver->name = "ttyprintk"; ttyprintk_driver->major = TTYAUX_MAJOR; ttyprintk_driver->minor_start = 3; ttyprintk_driver->num = 1; ttyprintk_driver->type = TTY_DRIVER_TYPE_CONSOLE; ttyprintk_driver->init_termios = tty_std_termios; ttyprintk_driver->init_termios.c_oflag = OPOST | OCRNL | ONOCR | ONLRET; ttyprintk_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_set_operations(ttyprintk_driver, &ttyprintk_ops); ret = tty_register_driver(ttyprintk_driver); if (ret < 0) { ; goto error; } /* create our unnumbered device */ rp = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 3), NULL, ttyprintk_driver->name); if (IS_ERR(rp)) { ; ret = PTR_ERR(rp); goto error; } tty_port_init(&tpk_port.port); tpk_port.port.ops = &null_ops; mutex_init(&tpk_port.port_write_mutex); return 0; error: put_tty_driver(ttyprintk_driver); ttyprintk_driver = NULL; return ret; }