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