Esempio n. 1
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;
}
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;
}
Esempio n. 3
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;
}
Esempio n. 4
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;
}
Esempio n. 5
0
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;
}
Esempio n. 6
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);
}
Esempio n. 7
0
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);
}
Esempio n. 8
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;
}
Esempio n. 9
0
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;
}
Esempio n. 10
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;
}
Esempio n. 11
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;
}
Esempio n. 13
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;
}
Esempio n. 14
0
/*
 * 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;
}
Esempio n. 17
0
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;
}
Esempio n. 18
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;
}
Esempio n. 20
0
/*
 * 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;
}
Esempio n. 21
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;
}
Esempio n. 23
0
/*
 * 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;
}
Esempio n. 25
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;
}
Esempio n. 26
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;
}
Esempio n. 27
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;
}
Esempio n. 28
0
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);
}
Esempio n. 29
0
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;
}
Esempio n. 30
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;
}