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; }
/** * tty_port_register_device - register tty device * @port: tty_port of the device * @driver: tty_driver for this device * @index: index of the tty * @device: parent if exists, otherwise NULL * * It is the same as tty_register_device except the provided @port is linked to * a concrete tty specified by @index. Use this or tty_port_install (or both). * Call tty_port_link_device as a last resort. */ struct device *tty_port_register_device(struct tty_port *port, struct tty_driver *driver, unsigned index, struct device *device) { tty_port_link_device(port, driver, index); return tty_register_device(driver, index, device); }
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; }
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; }
/** * tty_port_register_device_attr - register tty device * @port: tty_port of the device * @driver: tty_driver for this device * @index: index of the tty * @device: parent if exists, otherwise NULL * @drvdata: Driver data to be set to device. * @attr_grp: Attribute group to be set on device. * * It is the same as tty_register_device_attr except the provided @port is * linked to a concrete tty specified by @index. Use this or tty_port_install * (or both). Call tty_port_link_device as a last resort. */ struct device *tty_port_register_device_attr(struct tty_port *port, struct tty_driver *driver, unsigned index, struct device *device, void *drvdata, const struct attribute_group **attr_grp) { tty_port_link_device(port, driver, index); return tty_register_device_attr(driver, index, device, drvdata, attr_grp); }
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; }
/** * tty_port_register_device_attr - register tty device * @port: tty_port of the device * @driver: tty_driver for this device * @index: index of the tty * @device: parent if exists, otherwise NULL * @drvdata: Driver data to be set to device. * @attr_grp: Attribute group to be set on device. * * It is the same as tty_register_device_attr except the provided @port is * linked to a concrete tty specified by @index. Use this or tty_port_install * (or both). Call tty_port_link_device as a last resort. */ struct device *tty_port_register_device_attr(struct tty_port *port, struct tty_driver *driver, unsigned index, struct device *device, void *drvdata, const struct attribute_group **attr_grp) { struct device *dev; tty_port_link_device(port, driver, index); dev = serdev_tty_port_register(port, device, driver, index); if (PTR_ERR(dev) != -ENODEV) /* Skip creating cdev if we registered a serdev device */ return dev; return tty_register_device_attr(driver, index, device, drvdata, attr_grp); }
static int stty_driver_init(struct stty_device *device) { struct tty_driver *driver; int ret = 0; mutex_init(&(device->stat_lock)); device->port = stty_port_init(); if (!device->port) { return -ENOMEM; } driver = alloc_tty_driver(STTY_DEV_MAX_NR); if (!driver) return -ENOMEM; /* * Initialize the tty_driver structure * Entries in stty_driver that are NOT initialized: * proc_entry, set_termios, flush_buffer, set_ldisc, write_proc */ driver->owner = THIS_MODULE; driver->driver_name = device->pdata->name; driver->name = device->pdata->name; driver->major = 0; driver->type = TTY_DRIVER_TYPE_SYSTEM; driver->subtype = SYSTEM_TYPE_TTY; driver->init_termios = tty_std_termios; driver->driver_state = (void*)device; device->driver = driver; /* initialize the tty driver */ tty_set_operations(driver, &stty_ops); tty_port_link_device(device->port, driver, 0); ret = tty_register_driver(driver); if (ret) { put_tty_driver(driver); tty_port_destroy(device->port); return ret; } return ret; }
static int __init hvsi_init(void) { int i; hvsi_driver = alloc_tty_driver(hvsi_count); if (!hvsi_driver) return -ENOMEM; hvsi_driver->driver_name = "hvsi"; hvsi_driver->name = "hvsi"; hvsi_driver->major = HVSI_MAJOR; hvsi_driver->minor_start = HVSI_MINOR; hvsi_driver->type = TTY_DRIVER_TYPE_SYSTEM; hvsi_driver->init_termios = tty_std_termios; hvsi_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL; hvsi_driver->init_termios.c_ispeed = 9600; hvsi_driver->init_termios.c_ospeed = 9600; hvsi_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(hvsi_driver, &hvsi_ops); for (i=0; i < hvsi_count; i++) { struct hvsi_struct *hp = &hvsi_ports[i]; int ret = 1; tty_port_link_device(&hp->port, hvsi_driver, i); ret = request_irq(hp->virq, hvsi_interrupt, 0, "hvsi", hp); if (ret) printk(KERN_ERR "HVSI: couldn't reserve irq 0x%x (error %i)\n", hp->virq, ret); } hvsi_wait = wait_for_state; /* irqs active now */ if (tty_register_driver(hvsi_driver)) panic("Couldn't register hvsi console driver\n"); printk(KERN_DEBUG "HVSI: registered %i devices\n", hvsi_count); return 0; }
static int __init ram_console_tty_init(void) { int ret = -ENOMEM; tty_port_init(&ram_console_port.port); ram_console_port.port.ops = &null_ops; mutex_init(&ram_console_port.port_write_mutex); ram_console_tty_driver = tty_alloc_driver(1, TTY_DRIVER_UNNUMBERED_NODE); if (IS_ERR(ram_console_tty_driver)) return PTR_ERR(ram_console_tty_driver); ram_console_tty_driver->driver_name = "ramconsole"; ram_console_tty_driver->name = "ttyR"; ram_console_tty_driver->major = TTYAUX_MAJOR; ram_console_tty_driver->minor_start = 4; ram_console_tty_driver->type = TTY_DRIVER_TYPE_CONSOLE; ram_console_tty_driver->init_termios = tty_std_termios; ram_console_tty_driver->init_termios.c_oflag = OPOST | OCRNL | ONOCR | ONLRET; ram_console_tty_driver->flags |= TTY_DRIVER_REAL_RAW; tty_set_operations(ram_console_tty_driver, &ram_console_tty_ops); tty_port_link_device(&ram_console_port.port, ram_console_tty_driver, 0); ret = tty_register_driver(ram_console_tty_driver); if (ret < 0) { printk(KERN_ERR "Couldn't register ram_console_tty driver\n"); goto error; } printk("Registered ram_console_tty Major %d, Minor %d\n", TTYAUX_MAJOR, 4); return 0; error: tty_unregister_driver(ram_console_tty_driver); put_tty_driver(ram_console_tty_driver); ram_console_tty_driver = NULL; return ret; }
static int smbsim_serial_dev_init(SMBSIM_SERIAL_DEV * dev, int index) { DEV_NODE_PARAMS dev_params; int ret; /* Initialize device node parameters */ memset(&dev_params, 0, sizeof(dev_params)); dev_params.ioctl = smbsim_serial_ioctl; dev_params.ctx = dev; /* Create device node */ dev->dev_node = dev_node_create(smbsim_serial_class, &dev_params); if (dev->dev_node == NULL) { TRACE_MSG(TRACE_LEVEL_ERROR, TRACE_FLAG_DEFAULT, "dev_node_create failed\n"); return -ENOMEM; } /* Initialize virtual serial port */ ret = smbsim_serial_port_init(&dev->port, smbsim_serial_dev_read_handler); if (ret) { TRACE_ERR("smbsim_serial_port_init", ret); goto fail1; } /* Initialize TTY port */ tty_port_init(&dev->tty_port); dev->tty_port.ops = &smbsim_serial_port_ops; tty_port_link_device(&dev->tty_port, smbsim_serial_driver, index); return 0; fail1: dev_node_delete(dev->dev_node); return ret; }
static int __init nfcon_init(void) { int res; stderr_id = nf_get_id("NF_STDERR"); if (!stderr_id) return -ENODEV; nfcon_tty_driver = alloc_tty_driver(1); if (!nfcon_tty_driver) return -ENOMEM; tty_port_init(&nfcon_tty_port); nfcon_tty_driver->driver_name = "nfcon"; nfcon_tty_driver->name = "nfcon"; nfcon_tty_driver->type = TTY_DRIVER_TYPE_SYSTEM; nfcon_tty_driver->subtype = SYSTEM_TYPE_TTY; nfcon_tty_driver->init_termios = tty_std_termios; nfcon_tty_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(nfcon_tty_driver, &nfcon_tty_ops); tty_port_link_device(&nfcon_tty_port, nfcon_tty_driver, 0); res = tty_register_driver(nfcon_tty_driver); if (res) { pr_err("failed to register nfcon tty driver\n"); put_tty_driver(nfcon_tty_driver); tty_port_destroy(&nfcon_tty_port); return res; } if (!(nf_console.flags & CON_ENABLED)) register_console(&nf_console); return 0; }
int shell_init(void ) //clean warning { 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); tty_port_init(&shell_tty_port); shell_tty_port.ops = &shell_port_ops; tty_port_link_device(&shell_tty_port, shell_tty_drv, 0); 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; }
/* * The serial driver boot-time initialization code! */ static int __init amiga_serial_probe(struct platform_device *pdev) { unsigned long flags; struct serial_state * state; int error; serial_driver = alloc_tty_driver(NR_PORTS); if (!serial_driver) return -ENOMEM; show_serial_version(); /* Initialize the tty_driver structure */ serial_driver->driver_name = "amiserial"; 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); state = rs_table; state->port = (int)&custom.serdatr; /* Just to give it a value */ state->custom_divisor = 0; state->icount.cts = state->icount.dsr = state->icount.rng = state->icount.dcd = 0; state->icount.rx = state->icount.tx = 0; state->icount.frame = state->icount.parity = 0; state->icount.overrun = state->icount.brk = 0; tty_port_init(&state->tport); state->tport.ops = &amiga_port_ops; tty_port_link_device(&state->tport, serial_driver, 0); error = tty_register_driver(serial_driver); if (error) goto fail_put_tty_driver; printk(KERN_INFO "ttyS0 is the amiga builtin serial port\n"); /* Hardware set up */ state->baud_base = amiga_colorclock; state->xmit_fifo_size = 1; /* set ISRs, and then disable the rx interrupts */ error = request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state); if (error) goto fail_unregister; error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, 0, "serial RX", state); if (error) goto fail_free_irq; local_irq_save(flags); /* turn off Rx and Tx interrupts */ custom.intena = IF_RBF | IF_TBE; mb(); /* clear any pending interrupt */ custom.intreq = IF_RBF | IF_TBE; mb(); local_irq_restore(flags); /* * set the appropriate directions for the modem control flags, * and clear RTS and DTR */ ciab.ddra |= (SER_DTR | SER_RTS); /* outputs */ ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR); /* inputs */ platform_set_drvdata(pdev, state); return 0; fail_free_irq: free_irq(IRQ_AMIGA_TBE, state); fail_unregister: tty_unregister_driver(serial_driver); fail_put_tty_driver: tty_port_destroy(&state->tport); put_tty_driver(serial_driver); return error; }
static int __init nullmodem_init(void) { int retval; int i; dprintf("%s - \n", __FUNCTION__); init_timer(&nullmodem_timer); setup_timer(&nullmodem_timer, nullmodem_timer_proc, 0); tport = kmalloc(2*NULLMODEM_PAIRS*sizeof(struct tty_port),GFP_KERNEL); for (i = 0; i < NULLMODEM_PAIRS; ++i) { struct nullmodem_pair *pair = &pair_table[i]; memset(pair, 0, sizeof(*pair)); pair->a.other = &pair->b; pair->a.pair = pair; pair->b.other = &pair->a; pair->b.pair = pair; pair->a.char_length = 10 * FACTOR; pair->b.char_length = 10 * FACTOR; spin_lock_init(&pair->spin); init_waitqueue_head(&pair->control_lines_wait); dprintf("%s - initialized pair %d -> %p\n", __FUNCTION__, i, pair); } /* allocate the tty driver */ nullmodem_tty_driver = tty_alloc_driver(NULLMODEM_PAIRS*2, TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW); if (IS_ERR(nullmodem_tty_driver)) return -ENOMEM; /* initialize the tty driver */ nullmodem_tty_driver->owner = THIS_MODULE; nullmodem_tty_driver->driver_name = "nullmodem"; nullmodem_tty_driver->name = "nmp"; /* no more devfs subsystem */ nullmodem_tty_driver->major = NULLMODEM_MAJOR; nullmodem_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; nullmodem_tty_driver->subtype = SERIAL_TYPE_NORMAL; /* no more devfs subsystem */ nullmodem_tty_driver->init_termios = tty_std_termios; nullmodem_tty_driver->init_termios.c_iflag = 0; nullmodem_tty_driver->init_termios.c_oflag = 0; nullmodem_tty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; nullmodem_tty_driver->init_termios.c_lflag = 0; nullmodem_tty_driver->init_termios.c_ispeed = 38400; nullmodem_tty_driver->init_termios.c_ospeed = 38400; tty_set_operations(nullmodem_tty_driver, &serial_ops); for (i = 0; i < NULLMODEM_PAIRS; ++i) { tty_port_init(&tport[i]); tty_port_link_device(&tport[i],nullmodem_tty_driver, i); } /* register the tty driver */ retval = tty_register_driver(nullmodem_tty_driver); if (retval) { printk(KERN_ERR "failed to register nullmodem tty driver\n"); put_tty_driver(nullmodem_tty_driver); return retval; } last_timer_jiffies = jiffies; nullmodem_timer.expires = last_timer_jiffies + TIMER_INTERVAL; add_timer(&nullmodem_timer); printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION "\n"); return retval; }
static int __init mts_tty_init(void) { int ret = 0; struct device *tty_dev = NULL; struct mts_tty *mts_tty_drv = NULL; mts_tty_drv = kzalloc(sizeof(struct mts_tty), GFP_KERNEL); if (mts_tty_drv == NULL) { printk( "mts_tty_init: memory alloc fail %d - %d\n", 0, 0); return 0; } mts_tty_drv->mts_tty_port = kzalloc(sizeof(struct tty_port), GFP_KERNEL); if (mts_tty_drv->mts_tty_port == NULL) { printk( "mts_tty_init: memory alloc fail %d - %d\n", 0, 0); kfree(mts_tty_drv); return 0; } tty_port_init(mts_tty_drv->mts_tty_port); mts_tty = mts_tty_drv; mts_tty_drv->tty_drv = alloc_tty_driver(MAX_DIAG_MTS_DRV); if (!mts_tty_drv->tty_drv) { printk( "mts_tty_init: tty alloc driver fail %d - %d\n", 1, 0); kfree(mts_tty_drv->mts_tty_port); kfree(mts_tty_drv); return 0; } mts_tty_drv->tty_drv->name = "mts_tty"; mts_tty_drv->tty_drv->owner = THIS_MODULE; mts_tty_drv->tty_drv->driver_name = "mts_tty"; /* uses dynamically assigned dev_t values */ mts_tty_drv->tty_drv->type = TTY_DRIVER_TYPE_SERIAL; mts_tty_drv->tty_drv->subtype = SERIAL_TYPE_NORMAL; mts_tty_drv->tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_RESET_TERMIOS; /* initializing the mts driver */ mts_tty_drv->tty_drv->init_termios = tty_std_termios; mts_tty_drv->tty_drv->init_termios.c_iflag = IGNBRK | IGNPAR; mts_tty_drv->tty_drv->init_termios.c_oflag = 0; mts_tty_drv->tty_drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; mts_tty_drv->tty_drv->init_termios.c_lflag = 0; tty_set_operations(mts_tty_drv->tty_drv, &mts_tty_ops); tty_port_link_device(mts_tty_drv->mts_tty_port, mts_tty_drv->tty_drv, 0); ret = tty_register_driver(mts_tty_drv->tty_drv); if (ret) { printk("fail to mts tty_register_driver\n"); put_tty_driver(mts_tty_drv->tty_drv); tty_port_destroy(mts_tty_drv->mts_tty_port); mts_tty_drv->tty_drv = NULL; kfree(mts_tty_drv->mts_tty_port); kfree(mts_tty_drv); return 0; } tty_dev = tty_register_device(mts_tty_drv->tty_drv, 0, NULL); if (IS_ERR(tty_dev)) { printk("fail to mts tty_register_device\n"); tty_unregister_driver(mts_tty_drv->tty_drv); put_tty_driver(mts_tty_drv->tty_drv); tty_port_destroy(mts_tty_drv->mts_tty_port); kfree(mts_tty_drv->mts_tty_port); kfree(mts_tty_drv); return 0; } /* mts_tty->pm_notify.notifier_call = mts_pm_notify; register_pm_notifier(&mts_tty->pm_notify); init_waitqueue_head(&mts_tty->waitq); */ mts_tty->run = 0; // mts_tty->pm_notify_info = 0; printk( "mts_tty_init success\n"); return 0; }
static int __init tty0tty_init(void) { int retval; int i; if (pairs > 128) pairs = 128; if (pairs < 1) pairs = 1; tport = kmalloc(2 * pairs * sizeof(struct tty_port), GFP_KERNEL); tty0tty_table = kmalloc(2 * pairs * sizeof(struct tty0tty_serial *), GFP_KERNEL); for (i = 0; i < 2 * pairs; i++) { tty0tty_table[i] = NULL; } #ifdef SCULL_DEBUG printk(KERN_DEBUG "%s - \n", __FUNCTION__); #endif /* allocate the tty driver */ tty0tty_tty_driver = alloc_tty_driver(2 * pairs); 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->minor_start = TTY0TTY_MINOR; 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 < 2 * pairs; i++) { tty_port_init(&tport[i]); #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0) tty_port_link_device(&tport[i], tty0tty_tty_driver, i); #endif } 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; }
/* rs_init inits the driver */ static int __init rs68328_init(void) { unsigned long flags; int i; struct m68k_serial *info; serial_driver = alloc_tty_driver(NR_PORTS); if (!serial_driver) return -ENOMEM; show_serial_version(); /* Initialize the tty_driver structure */ /* SPARC: Not all of this is exactly right for us. */ 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 = m68328_console_cbaud | CS8 | CREAD | HUPCL | CLOCAL; serial_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(serial_driver, &rs_ops); local_irq_save(flags); for(i=0;i<NR_PORTS;i++) { info = &m68k_soft[i]; tty_port_init(&info->tport); info->tport.ops = &rs_port_ops; info->magic = SERIAL_MAGIC; info->port = (int) &uart_addr[i]; info->irq = uart_irqs[i]; info->custom_divisor = 16; info->x_char = 0; info->line = i; info->is_cons = 1; /* Means shortcuts work */ printk("%s%d at 0x%08x (irq = %d)", serial_driver->name, info->line, info->port, info->irq); printk(" is a builtin MC68328 UART\n"); #ifdef CONFIG_M68VZ328 if (i > 0 ) PJSEL &= 0xCF; /* PSW enable second port output */ #endif if (request_irq(uart_irqs[i], rs_interrupt, 0, "M68328_UART", info)) panic("Unable to attach 68328 serial interrupt\n"); tty_port_link_device(&info->tport, serial_driver, i); } local_irq_restore(flags); if (tty_register_driver(serial_driver)) { put_tty_driver(serial_driver); for (i = 0; i < NR_PORTS; i++) tty_port_destroy(&m68k_soft[i].tport); printk(KERN_ERR "Couldn't register serial driver\n"); return -ENOMEM; } return 0; }
int rpmsg_neo_tty(struct rpmsg_channel *rpmsg_chnl,rpmsg_neo_remove_t *remove_func ) { int err = 0; struct rpmsgtty_port *cport = &rpmsg_tty_port; *remove_func = rpmsg_neo_tty_remove; memset(cport, 0, sizeof(rpmsg_tty_port)); cport->rpmsg_chnl = rpmsg_chnl; cport->endpt = RPMSG_TTY_ENPT; cport->ept = rpmsg_create_ept(cport->rpmsg_chnl, rpmsg_tty_cb, cport, cport->endpt); if (!cport->ept) { pr_err("ERROR: %s %s %d Failed to create proxy service endpoint.\n", __FILE__, __FUNCTION__, __LINE__); err = -1; goto error0; } rpmsgtty_driver = tty_alloc_driver(1, TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_UNNUMBERED_NODE); if (IS_ERR(rpmsgtty_driver)) { pr_err("ERROR:%s %d Failed to alloc tty\n", __FUNCTION__, __LINE__); rpmsg_destroy_ept(cport->ept); return PTR_ERR(rpmsgtty_driver); } spin_lock_init(&cport->rx_lock); cport->port.low_latency = cport->port.flags | ASYNC_LOW_LATENCY; tty_port_init(&cport->port); cport->port.ops = &rpmsgtty_port_ops; rpmsgtty_driver->driver_name = "ttyrpmsg"; rpmsgtty_driver->name = "ttyrpmsg"; rpmsgtty_driver->major = TTYAUX_MAJOR; rpmsgtty_driver->minor_start = 4; rpmsgtty_driver->type = TTY_DRIVER_TYPE_CONSOLE; rpmsgtty_driver->init_termios = tty_std_termios; // rpmsgtty_driver->init_termios.c_oflag = OPOST | OCRNL | ONOCR | ONLRET; rpmsgtty_driver->init_termios.c_cflag |= CLOCAL; tty_set_operations(rpmsgtty_driver, &imxrpmsgtty_ops); tty_port_link_device(&cport->port, rpmsgtty_driver, 0); err = tty_register_driver(rpmsgtty_driver); if (err < 0) { pr_err("Couldn't install rpmsg tty driver: err %d\n", err); goto error; } else { pr_info("Install rpmsg tty driver!\n"); } return 0; error: put_tty_driver(rpmsgtty_driver); tty_port_destroy(&cport->port); rpmsgtty_driver = NULL; rpmsg_destroy_ept(cport->ept); error0: return err; }
static int __init lge_bypass_init(void) { int ret = 0; struct device *tty_dev = NULL; struct bypass_driver *bypass_drv = NULL; pr_info("%s\n", __func__); bypass_drv = kzalloc(sizeof(struct bypass_driver), GFP_KERNEL); if (!bypass_drv) { pr_err( "%s: memory alloc fail\n", __func__); return 0; } bypass_drv->tty_drv = alloc_tty_driver(BYPASS_MAX_DRV); if(!bypass_drv->tty_drv) { pr_err( "%s: tty alloc driver fail\n", __func__); kfree(bypass_drv); return 0; } bypass_drv->port = kzalloc(sizeof(struct tty_port), GFP_KERNEL); if(!bypass_drv->port) { pr_err( "%s: memory alloc port fail\n", __func__); kfree(bypass_drv->tty_drv); kfree(bypass_drv); return 0; } tty_port_init(bypass_drv->port); lge_bypass_drv = bypass_drv; bypass_drv->tty_drv->name = "lge_diag_bypass"; bypass_drv->tty_drv->owner = THIS_MODULE; bypass_drv->tty_drv->driver_name = "lge_diag_bypass"; bypass_drv->tty_drv->type = TTY_DRIVER_TYPE_SERIAL; bypass_drv->tty_drv->subtype = SERIAL_TYPE_NORMAL; bypass_drv->tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_RESET_TERMIOS; bypass_drv->tty_drv->init_termios = tty_std_termios; bypass_drv->tty_drv->init_termios.c_iflag = IGNBRK | IGNPAR; bypass_drv->tty_drv->init_termios.c_oflag = 0; bypass_drv->tty_drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; bypass_drv->tty_drv->init_termios.c_lflag = 0; tty_set_operations(bypass_drv->tty_drv, &lge_bypass_ops); #if defined(CONFIG_ARCH_MSM8916) || defined(CONFIG_ARCH_APQ8084) || defined(CONFIG_ARCH_ODIN) tty_port_link_device(bypass_drv->port, bypass_drv->tty_drv, 0); #endif ret = tty_register_driver(bypass_drv->tty_drv); if (ret) { pr_err("%s: fail to tty_register_driver\n", __func__); put_tty_driver(bypass_drv->tty_drv); #if defined(CONFIG_ARCH_MSM8916) || defined(CONFIG_ARCH_APQ8084) || defined(CONFIG_ARCH_ODIN) tty_port_destroy(bypass_drv->port); #endif bypass_drv->tty_drv = NULL; kfree(bypass_drv->port); kfree(bypass_drv); return 0; } tty_dev = tty_register_device(bypass_drv->tty_drv, 0, NULL); if (IS_ERR(tty_dev)) { pr_err("%s: fail to tty_register_device\n", __func__); tty_unregister_driver(bypass_drv->tty_drv); put_tty_driver(bypass_drv->tty_drv); #if defined(CONFIG_ARCH_MSM8916) || defined(CONFIG_ARCH_APQ8084) || defined(CONFIG_ARCH_ODIN) tty_port_destroy(bypass_drv->port); #endif kfree(bypass_drv->port); kfree(bypass_drv); return 0; } bypass_drv->enable = 0; pr_info( "%s: success\n", __func__); return 0; }
static int __init lge_dm_tty_init(void) { int ret = 0; struct device *tty_dev; struct dm_tty *lge_dm_tty_drv; #ifdef CONFIG_TTY_PORT tty_port_init(&dm_tty_port); #endif /* CONFIG_TTY_PORT */ pr_info(DM_TTY_MODULE_NAME ": %s\n", __func__); if(lge_dm_tty != NULL) { lge_dm_tty_drv = lge_dm_tty; } else { lge_dm_tty_drv = kzalloc(sizeof(struct dm_tty), GFP_KERNEL); if (lge_dm_tty_drv == NULL) { pr_info(DM_TTY_MODULE_NAME "%s:" "failed to allocate lge_dm_tty", __func__); return 0; } lge_dm_tty = lge_dm_tty_drv; } lge_dm_tty_drv->tty_drv = alloc_tty_driver(MAX_DM_TTY_DRV); if (!lge_dm_tty_drv->tty_drv) { pr_info(DM_TTY_MODULE_NAME ": %s - tty_drv is NULL", __func__); kfree(lge_dm_tty_drv); return 0; } lge_dm_tty_drv->tty_drv->name = "lge_dm_tty"; lge_dm_tty_drv->tty_drv->owner = THIS_MODULE; lge_dm_tty_drv->tty_drv->driver_name = "lge_dm_tty"; /* uses dynamically assigned dev_t values */ lge_dm_tty_drv->tty_drv->type = TTY_DRIVER_TYPE_SERIAL; lge_dm_tty_drv->tty_drv->subtype = SERIAL_TYPE_NORMAL; lge_dm_tty_drv->tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_RESET_TERMIOS; /* initializing the tty driver */ lge_dm_tty_drv->tty_drv->init_termios = tty_std_termios; lge_dm_tty_drv->tty_drv->init_termios.c_iflag = IGNBRK | IGNPAR; lge_dm_tty_drv->tty_drv->init_termios.c_oflag = 0; lge_dm_tty_drv->tty_drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; lge_dm_tty_drv->tty_drv->init_termios.c_lflag = 0; tty_set_operations(lge_dm_tty_drv->tty_drv, &lge_dm_tty_ops); #ifdef CONFIG_TTY_PORT tty_port_link_device(&dm_tty_port, lge_dm_tty_drv->tty_drv, 0); #endif /* CONFIG_TTY_PORT */ ret = tty_register_driver(lge_dm_tty_drv->tty_drv); if (ret) { put_tty_driver(lge_dm_tty_drv->tty_drv); #ifdef CONFIG_TTY_PORT tty_port_destroy(&dm_tty_port); #endif /* CONFIG_TTY_PORT */ pr_info(DM_TTY_MODULE_NAME ": %s:" "tty_register_driver() ""failed\n", __func__); lge_dm_tty_drv->tty_drv = NULL; kfree(lge_dm_tty_drv); return 0; } tty_dev = tty_register_device(lge_dm_tty_drv->tty_drv, 0, NULL); if (IS_ERR(tty_dev)) { pr_info(DM_TTY_MODULE_NAME ": %s:" "tty_register_device() " "failed\n", __func__); tty_unregister_driver(lge_dm_tty_drv->tty_drv); put_tty_driver(lge_dm_tty_drv->tty_drv); #ifdef CONFIG_TTY_PORT tty_port_destroy(&dm_tty_port); #endif /* CONFIG_TTY_PORT */ kfree(lge_dm_tty_drv); return 0; } init_waitqueue_head(&lge_dm_tty_drv->waitq); lge_dm_tty_drv->tty_state = DM_TTY_REGISTERED; /* data initialization */ dm_modem_response = kzalloc(DM_TTY_TX_MAX_PACKET_SIZE, GFP_KERNEL); if (dm_modem_response == NULL) pr_info(DM_TTY_MODULE_NAME ": %s: dm_modem_response ""failed\n", __func__); dm_modem_request = kzalloc(DM_TTY_RX_MAX_PACKET_SIZE, GFP_KERNEL); if (dm_modem_request == NULL) pr_info(DM_TTY_MODULE_NAME ": %s: dm_modem_request ""failed\n", __func__); dm_modem_response_header_length = sizeof(struct dm_router_header); dm_modem_response_header = kzalloc(dm_modem_response_header_length, GFP_KERNEL); if (dm_modem_response_header == NULL) pr_info(DM_TTY_MODULE_NAME ": %s: dm_modem_response_header " "failed\n", __func__); dm_modem_request_header_length = sizeof(struct dm_router_header); dm_modem_request_header = kzalloc(dm_modem_request_header_length, GFP_KERNEL); if (dm_modem_request_header == NULL) pr_info(DM_TTY_MODULE_NAME ": %s: dm_modem_request_header " "failed\n", __func__); dm_modem_response_body_length = sizeof(struct dm_router_modem_response_body); dm_modem_response_body = kzalloc(dm_modem_response_body_length, GFP_KERNEL); if (dm_modem_response_body == NULL) pr_info(DM_TTY_MODULE_NAME ": %s: dm_modem_response_body " "failed\n", __func__); return 0; }