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;
}
