/** Module cleanup. * * Clears all master instances. */ void __exit ec_tty_cleanup_module(void) { tty_unregister_driver(tty_driver); put_tty_driver(tty_driver); printk(KERN_INFO PFX "Module unloading.\n"); }
static int __init lge_dm_tty_init(void) { int i, ret = 0; struct device *tty_dev; struct dm_tty *lge_dm_tty_drv; pr_info(DM_TTY_MODULE_NAME ": %s\n", __func__); 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); ret = tty_register_driver(lge_dm_tty_drv->tty_drv); if (ret) { put_tty_driver(lge_dm_tty_drv->tty_drv); 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); 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__); for (i = 0; i < NUM_MODEM_CHIP + 1; i++) lge_dm_tty_drv->is_modem_open[i] = FALSE; return 0; }
/** * gserial_setup - initialize TTY driver for one or more ports * @g: gadget to associate with these ports * @count: how many ports to support * Context: may sleep * * The TTY stack needs to know in advance how many devices it should * plan to manage. Use this call to set up the ports you will be * exporting through USB. Later, connect them to functions based * on what configuration is activated by the USB host; and disconnect * them as appropriate. * * An example would be a two-configuration device in which both * configurations expose port 0, but through different functions. * One configuration could even expose port 1 while the other * one doesn't. * * Returns negative errno or zero. */ int gserial_setup(struct usb_gadget *g, unsigned count) { unsigned i; struct usb_cdc_line_coding coding; int status; if (count == 0 || count > N_PORTS) return -EINVAL; gs_tty_driver = alloc_tty_driver(count); 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; coding.dwDTERate = cpu_to_le32(9600); coding.bCharFormat = 8; coding.bParityType = USB_CDC_NO_PARITY; coding.bDataBits = USB_CDC_1_STOP_BITS; tty_set_operations(gs_tty_driver, &gs_tty_ops); /* make devices be openable */ for (i = 0; i < count; i++) { mutex_init(&ports[i].lock); status = gs_port_alloc(i, &coding); if (status) { count = i; goto fail; } } n_ports = count; /* export the driver ... */ status = tty_register_driver(gs_tty_driver); if (status) { pr_err("%s: cannot register, err %d\n", __func__, status); goto fail; } /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */ for (i = 0; i < count; i++) { struct device *tty_dev; tty_dev = tty_register_device(gs_tty_driver, i, &g->dev); if (IS_ERR(tty_dev)) pr_warning("%s: no classdev for port %d, err %ld\n", __func__, i, PTR_ERR(tty_dev)); } pr_debug("%s: registered %d ttyGS* device%s\n", __func__, count, (count == 1) ? "" : "s"); return status; fail: while (count--) kfree(ports[count].port); put_tty_driver(gs_tty_driver); gs_tty_driver = NULL; return status; }
/** * ehv_bc_exit - ePAPR hypervisor byte channel driver termination * * This function is called when this driver is unloaded. */ static void __exit ehv_bc_exit(void) { tty_unregister_driver(ehv_bc_driver); put_tty_driver(ehv_bc_driver); kfree(bcs); }
static int __init smd_tty_init(void) { int ret; int n; int idx; smd_tty_driver = alloc_tty_driver(MAX_SMD_TTYS); if (smd_tty_driver == 0) return -ENOMEM; smd_tty_driver->owner = THIS_MODULE; smd_tty_driver->driver_name = "smd_tty_driver"; smd_tty_driver->name = "smd"; smd_tty_driver->major = 0; smd_tty_driver->minor_start = 0; smd_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; smd_tty_driver->subtype = SERIAL_TYPE_NORMAL; smd_tty_driver->init_termios = tty_std_termios; smd_tty_driver->init_termios.c_iflag = 0; smd_tty_driver->init_termios.c_oflag = 0; smd_tty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; smd_tty_driver->init_termios.c_lflag = 0; smd_tty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_set_operations(smd_tty_driver, &smd_tty_ops); ret = tty_register_driver(smd_tty_driver); if (ret) { put_tty_driver(smd_tty_driver); pr_err("%s: driver registration failed %d\n", __func__, ret); return ret; } for (n = 0; n < ARRAY_SIZE(smd_configs); ++n) { idx = smd_configs[n].tty_dev_index; if (smd_configs[n].dev_name == NULL) smd_configs[n].dev_name = smd_configs[n].port_name; if (idx == DS_IDX) { /* * DS port uses the kernel API starting with * 8660 Fusion. Only register the userspace * platform device for older targets. */ int legacy_ds = 0; legacy_ds |= cpu_is_msm7x01() || cpu_is_msm7x25(); legacy_ds |= cpu_is_msm7x27() || cpu_is_msm7x30(); legacy_ds |= cpu_is_qsd8x50() || cpu_is_msm8x55(); /* * use legacy mode for 8660 Standalone (subtype 0) */ legacy_ds |= cpu_is_msm8x60() && (socinfo_get_platform_subtype() == 0x1); if (!legacy_ds) continue; } tty_register_device(smd_tty_driver, idx, 0); init_completion(&smd_tty[idx].ch_allocated); /* register platform device */ smd_tty[idx].driver.probe = smd_tty_dummy_probe; smd_tty[idx].driver.driver.name = smd_configs[n].dev_name; smd_tty[idx].driver.driver.owner = THIS_MODULE; spin_lock_init(&smd_tty[idx].reset_lock); smd_tty[idx].is_open = 0; init_waitqueue_head(&smd_tty[idx].ch_opened_wait_queue); ret = platform_driver_register(&smd_tty[idx].driver); if (ret) { pr_err("%s: init failed %d (%d)\n", __func__, idx, ret); smd_tty[idx].driver.probe = NULL; goto out; } smd_tty[idx].smd = &smd_configs[n]; } INIT_DELAYED_WORK(&loopback_work, loopback_probe_worker); return 0; out: /* unregister platform devices */ for (n = 0; n < ARRAY_SIZE(smd_configs); ++n) { idx = smd_configs[n].tty_dev_index; if (smd_tty[idx].driver.probe) { platform_driver_unregister(&smd_tty[idx].driver); tty_unregister_device(smd_tty_driver, idx); } } tty_unregister_driver(smd_tty_driver); put_tty_driver(smd_tty_driver); return ret; }
int gserial_setup(struct usb_gadget *g, unsigned count) { unsigned i; struct usb_cdc_line_coding coding; int status; if (count == 0 || count > N_PORTS) return -EINVAL; gs_tty_driver = alloc_tty_driver(count); if (!gs_tty_driver) return -ENOMEM; gs_tty_driver->owner = THIS_MODULE; gs_tty_driver->driver_name = "g_serial"; gs_tty_driver->name = PREFIX; 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 | TTY_DRIVER_RESET_TERMIOS; gs_tty_driver->init_termios = tty_std_termios; 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; gs_tty_driver->init_termios.c_lflag = 0; gs_tty_driver->init_termios.c_iflag = 0; gs_tty_driver->init_termios.c_oflag = 0; coding.dwDTERate = cpu_to_le32(9600); coding.bCharFormat = 8; coding.bParityType = USB_CDC_NO_PARITY; coding.bDataBits = USB_CDC_1_STOP_BITS; tty_set_operations(gs_tty_driver, &gs_tty_ops); gserial_wq = create_singlethread_workqueue("k_gserial"); if (!gserial_wq) { status = -ENOMEM; goto fail; } for (i = 0; i < count; i++) { mutex_init(&ports[i].lock); status = gs_port_alloc(i, &coding); if (status) { count = i; goto fail; } } n_ports = count; gs_tty_driver->need_rcv_lock = 1; status = tty_register_driver(gs_tty_driver); if (status) { put_tty_driver(gs_tty_driver); pr_err("%s: cannot register, err %d\n", __func__, status); goto fail; } for (i = 0; i < count; i++) { struct device *tty_dev; tty_dev = tty_register_device(gs_tty_driver, i, &g->dev); if (IS_ERR(tty_dev)) pr_warning("%s: no classdev for port %d, err %ld\n", __func__, i, PTR_ERR(tty_dev)); } for (i = 0; i < count; i++) usb_debugfs_init(ports[i].port, i); pr_debug("%s: registered %d ttyGS* device%s\n", __func__, count, (count == 1) ? "" : "s"); return status; fail: while (count--) kfree(ports[count].port); if (gserial_wq) destroy_workqueue(gserial_wq); put_tty_driver(gs_tty_driver); gs_tty_driver = NULL; return status; }
/* rs_init inits the driver */ static int __init rs68328_init(void) { int flags, 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]; info->magic = SERIAL_MAGIC; info->port = (int) &uart_addr[i]; info->tty = NULL; info->irq = uart_irqs[i]; info->custom_divisor = 16; info->close_delay = 50; info->closing_wait = 3000; info->x_char = 0; info->event = 0; info->count = 0; info->blocked_open = 0; init_waitqueue_head(&info->open_wait); init_waitqueue_head(&info->close_wait); 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); printk(KERN_ERR "Couldn't register serial driver\n"); return -ENOMEM; } return 0; }
static int __init smd_tty_init(void) { int ret; int n; int idx; smd_tty_driver = alloc_tty_driver(MAX_SMD_TTYS); if (smd_tty_driver == 0) return -ENOMEM; smd_tty_driver->owner = THIS_MODULE; smd_tty_driver->driver_name = "smd_tty_driver"; smd_tty_driver->name = "smd"; smd_tty_driver->major = 0; smd_tty_driver->minor_start = 0; smd_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; smd_tty_driver->subtype = SERIAL_TYPE_NORMAL; smd_tty_driver->init_termios = tty_std_termios; smd_tty_driver->init_termios.c_iflag = 0; smd_tty_driver->init_termios.c_oflag = 0; smd_tty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; smd_tty_driver->init_termios.c_lflag = 0; smd_tty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_set_operations(smd_tty_driver, &smd_tty_ops); ret = tty_register_driver(smd_tty_driver); if (ret) { put_tty_driver(smd_tty_driver); pr_err("%s: driver registration failed %d\n", __func__, ret); return ret; } for (n = 0; n < ARRAY_SIZE(smd_configs); ++n) { idx = smd_configs[n].tty_dev_index; if (smd_configs[n].dev_name == NULL) smd_configs[n].dev_name = smd_configs[n].port_name; if (idx == DS_IDX) { int legacy_ds = 0; legacy_ds |= cpu_is_msm7x01() || cpu_is_msm7x25(); legacy_ds |= cpu_is_msm7x27() || cpu_is_msm7x30(); legacy_ds |= cpu_is_qsd8x50() || cpu_is_msm8x55(); legacy_ds |= (cpu_is_msm8960() || cpu_is_msm8930() || cpu_is_msm8930aa()); legacy_ds |= cpu_is_msm8x60() && (socinfo_get_platform_subtype() == 0x0); #ifdef CONFIG_MACH_DUMMY legacy_ds = 1; #endif if (!legacy_ds) continue; } tty_register_device(smd_tty_driver, idx, 0); init_completion(&smd_tty[idx].ch_allocated); smd_tty[idx].driver.probe = smd_tty_dummy_probe; smd_tty[idx].driver.driver.name = smd_configs[n].dev_name; smd_tty[idx].driver.driver.owner = THIS_MODULE; spin_lock_init(&smd_tty[idx].reset_lock); smd_tty[idx].is_open = 0; setup_timer(&smd_tty[idx].buf_req_timer, buf_req_retry, (unsigned long)&smd_tty[idx]); init_waitqueue_head(&smd_tty[idx].ch_opened_wait_queue); ret = platform_driver_register(&smd_tty[idx].driver); if (ret) { pr_err("%s: init failed %d (%d)\n", __func__, idx, ret); smd_tty[idx].driver.probe = NULL; goto out; } smd_tty[idx].smd = &smd_configs[n]; } INIT_DELAYED_WORK(&loopback_work, loopback_probe_worker); return 0; out: for (n = 0; n < ARRAY_SIZE(smd_configs); ++n) { idx = smd_configs[n].tty_dev_index; if (smd_tty[idx].driver.probe) { platform_driver_unregister(&smd_tty[idx].driver); tty_unregister_device(smd_tty_driver, idx); } } tty_unregister_driver(smd_tty_driver); put_tty_driver(smd_tty_driver); return ret; }
int atcmd_setup(struct usb_gadget *g) { struct device *tty_dev; int status; at_tty_driver = alloc_tty_driver(1); if (!at_tty_driver) return -ENOMEM; at_tty_driver->driver_name = "at_serial"; at_tty_driver->name = AT_PREFIX; /* uses dynamically assigned dev_t values */ at_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; at_tty_driver->subtype = SERIAL_TYPE_NORMAL; at_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_RESET_TERMIOS; at_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. */ at_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; at_tty_driver->init_termios.c_ispeed = 9600; at_tty_driver->init_termios.c_ospeed = 9600; tty_set_operations(at_tty_driver, &at_tty_ops); /* make devices be openable */ mutex_init(&gdata_ports[0].port->tty_lock); /* export the driver ... */ status = tty_register_driver(at_tty_driver); if (status) { put_tty_driver(at_tty_driver); pr_err("%s: cannot register, err %d\n", __func__, status); goto fail; } /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */ tty_dev = tty_register_device(at_tty_driver, 0, &g->dev); if (IS_ERR(tty_dev)) pr_warning("%s: no classdev, err %ld\n", __func__, PTR_ERR(tty_dev)); #ifdef ENABLE_DUMMY_HSIC_TTY status = hsic_setup(g); if (status) goto fail; #endif pr_debug("%s: registered ttyGS0 device\n", __func__); return status; fail: put_tty_driver(at_tty_driver); at_tty_driver = NULL; return status; }
static int ipoctal_install_all(void) { int i, j, t; int res = 0; struct tty_driver *tty; char name[20] = ""; ipoctal_installed = (struct ipoctal*) kzalloc(num_lun * sizeof(struct ipoctal), GFP_KERNEL); if (ipoctal_installed == NULL) { printk(KERN_ERR PFX "Unable to allocate memory for ipoctal's !\n"); res = -ENOMEM; goto out_err; } for (i=0; i<num_lun;i++) { tty = alloc_tty_driver(NR_CHANNELS); if(!tty) return -ENOMEM; tty->owner = THIS_MODULE; tty->driver_name = "ipoctal"; sprintf(name, "ipoctal.%d.", lun[i]); tty->name = name; tty->major = 0; tty->minor_start = 0; tty->type = TTY_DRIVER_TYPE_SERIAL; tty->subtype = SERIAL_TYPE_NORMAL; tty->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty->init_termios = tty_std_termios; tty->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; tty->init_termios.c_ispeed = 9600; tty->init_termios.c_ospeed = 9600; tty->init_termios.c_iflag = tty_std_termios.c_iflag | IGNBRK; tty_set_operations(tty, &ipoctalFops); res = tty_register_driver(tty); if(res) { printk(KERN_ERR PFX "Can't register tty driver.\n"); put_tty_driver(tty); goto out_uninst; } for(j = 0; j < NR_CHANNELS;j++) { tty_register_device(tty, j, NULL); ipoctal_installed[i].tty[j] = NULL; spin_lock_init(&ipoctal_installed[i].lock[j]); mutex_init(&ipoctal_installed[i].lock_write[j]); ipoctal_installed[i].pointer_read[j] = 0; ipoctal_installed[i].pointer_write[j] = 0; ipoctal_installed[i].nb_bytes[j] = 0; } ipoctal_installed[i].tty_drv = tty; ipoctal_installed[i].index = i; res = ipoctal_inst_slot(&ipoctal_installed[i], carrier_number[i], slot[i], irq[i], carrier[i]); if (res) { printk(KERN_ERR PFX "Error during IP octal install !\n"); goto out_uninst; } } return 0; out_uninst : for (j=0; j < i;j++){ for (t = 0; t < NR_CHANNELS; t++) tty_unregister_device(ipoctal_installed[j].tty_drv, t); tty_unregister_driver(ipoctal_installed[j].tty_drv); ipoctal_uninst_slot(&ipoctal_installed[j]); } kfree(ipoctal_installed); ipoctal_installed = NULL; printk(KERN_ERR PFX "Unregistered all IP octal devices\n"); out_err : return res; }
static int __init spi_tty_init(void) { int retval; struct spi_tty_s *spi_tty; SPI_IPC_INFO("%s\n", __func__); tx_size = 0L; tx_time = 0L; tx_count = 0L; write_count = 0L; spi_tty_gbl = kmalloc(sizeof(*spi_tty), GFP_KERNEL); if (spi_tty_gbl == NULL) { pr_err("%s: Cannot malloc mem!\n", __func__); return -ENOMEM; } memset(spi_tty_gbl, 0x0, sizeof(*spi_tty)); spi_tty = spi_tty_gbl; SPI_IPC_INFO("spi_tty=%p\n", spi_tty); spi_tty->write_buf = spi_tty_buf_alloc(); if (!spi_tty->write_buf) { kfree(spi_tty_gbl); pr_err("failed to malloc spi_tty write buf!\n"); return -ENOMEM; } spi_tty->throttle = 0; spi_tty->open_count = 0; spi_tty->tx_null = 0; spin_lock_init(&spi_tty->port_lock); mutex_init(&spi_tty->work_lock); INIT_WORK(&spi_tty->write_work, spi_tty_write_worker); wake_lock_init(&spi_tty->wakelock, WAKE_LOCK_SUSPEND, "spi_tty_wakelock"); init_waitqueue_head(&spi_tty->write_wait); spi_tty->write_buf_full = 0; spi_tty->work_queue = create_singlethread_workqueue("spi_tty_wq"); if (spi_tty->work_queue == NULL) { kfree(spi_tty); kfree(spi_big_trans.tx_buf); pr_err("Failed to create work queue\n"); return -ESRCH; } spi_slave_message_init(&spi_big_msg); spi_big_trans.tx_buf = kmalloc(SPI_TRANSACTION_LEN*2, GFP_KERNEL); if (!spi_big_trans.tx_buf) { kfree(spi_tty); pr_err("%s: Cannot malloc mem!\n", __func__); return -ENOMEM; } spi_big_trans.rx_buf = spi_big_trans.tx_buf + SPI_TRANSACTION_LEN; spi_slave_message_add_tail(&spi_big_trans, &spi_big_msg); spi_tty_driver = alloc_tty_driver(SPI_TTY_MINORS); if (!spi_tty_driver) return -ENOMEM; spi_tty_driver->owner = THIS_MODULE; spi_tty_driver->driver_name = "spi_modem"; spi_tty_driver->name = "ttySPI"; spi_tty_driver->major = SPI_TTY_MAJOR; spi_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; spi_tty_driver->subtype = SERIAL_TYPE_NORMAL; spi_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; spi_tty_driver->init_termios = tty_std_termios; spi_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; tty_set_operations(spi_tty_driver, &serial_ops); retval = tty_register_driver(spi_tty_driver); if (retval) { pr_err("failed to register spi_tty tty driver"); put_tty_driver(spi_tty_driver); return retval; } tty_register_device(spi_tty_driver, 0, NULL); // Depends on module_init() call sequence, mdm6600_dev_probe may mdm6600_spi_dev.cb_context = spi_tty; //mdm6600_spi_dev.callback = spi_tty_handle_data; mdm6600_spi_dev.callback = NULL; mdm6600_spi_dev.handle_master_mrdy = spi_tty_handle_mrdy; spi_tty->spi_slave_dev = &mdm6600_spi_dev; return retval; }
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 void __exit qcnmea_exit() { tty_unregister_driver(qcnmea_tty_driver); put_tty_driver(qcnmea_tty_driver);
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 mcu_platform_probe(struct platform_device *pdev) { int ret, i; struct mcu_data *data; struct mcu *mcu; u8 *base; mcu = platform_get_drvdata(pdev); intel_mcu_tty_driver = alloc_tty_driver(INTEL_MCU_TTY_MINORS); if (!intel_mcu_tty_driver) { dev_err(&pdev->dev, "fail to alloc tty driver\n"); return -ENODEV; } intel_mcu_tty_driver->name = "ttymcu"; intel_mcu_tty_driver->major = INTEL_MCU_TTY_MAJOR; intel_mcu_tty_driver->minor_start = 0; intel_mcu_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; intel_mcu_tty_driver->subtype = SERIAL_TYPE_NORMAL; intel_mcu_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; intel_mcu_tty_driver->init_termios = tty_std_termios; intel_mcu_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; intel_mcu_tty_driver->init_termios.c_ispeed = 38400; intel_mcu_tty_driver->init_termios.c_ospeed = 38400; intel_mcu_tty_driver->init_termios.c_iflag = 0; intel_mcu_tty_driver->init_termios.c_oflag = 0; intel_mcu_tty_driver->init_termios.c_lflag = 0; tty_set_operations(intel_mcu_tty_driver, &intel_mcu_ops); ret = tty_register_driver(intel_mcu_tty_driver); if (ret) { dev_err(&pdev->dev, "fail to register tty driver\n"); goto tty_reg_fail; } base = (u8 *)mcu->ddr[1]; for (i = INTEL_MCU_TTY_MINORS - 1; i >= 0; i--) { data = kzalloc(sizeof(struct mcu_data), GFP_KERNEL); if (data == NULL) { dev_err(&pdev->dev, "fail to alloc mcu data\n"); goto data_alloc_fail; } data->index = i; tty_port_init(&data->port); data->dev = tty_port_register_device(&data->port, intel_mcu_tty_driver, i, &pdev->dev); mcu_table[i] = data; data->mcu = mcu; init_completion(&data->cmp); data->lbuf.addr = base; data->lbuf.length = BUF_IA_DDR_SIZE; lbuf_read_reset(&data->lbuf); base += BUF_IA_DDR_SIZE; } ret = sysfs_create_group(&pdev->dev.kobj, &intel_mcu_tty_attribute_group); if (ret) { pr_err("failed to create the mdbg sysfs attributes\n"); sysfs_remove_group(&pdev->dev.kobj, &intel_mcu_tty_attribute_group); goto data_alloc_fail; } intel_psh_ipc_bind(PSH_RECV_CH0, raw_data_handler, mcu_table[0]); intel_psh_ipc_bind(PSH_RECV_CH1, raw_data_handler, mcu_table[1]); intel_psh_ipc_bind(PSH_RECV_CH2, cmd_handler, mcu_table[2]); pr_info("MCU detected and ready to used!\n"); return 0; data_alloc_fail: for (i = 0; i < INTEL_MCU_TTY_MINORS; i++) kfree(mcu_table[i]); tty_reg_fail: put_tty_driver(intel_mcu_tty_driver); return ret; }
static int __init hsic_tty_init(void) { int ret; int n; unsigned port_num; pr_debug("%s\n", __func__); hsic_tty_driver = alloc_tty_driver(MAX_HSIC_TTYS); if (hsic_tty_driver == 0) return -ENOMEM; hsic_tty_driver->owner = THIS_MODULE; hsic_tty_driver->driver_name = "hsic_tty_driver"; hsic_tty_driver->name = "hsic"; hsic_tty_driver->major = 0; hsic_tty_driver->minor_start = 0; hsic_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; hsic_tty_driver->subtype = SERIAL_TYPE_NORMAL; hsic_tty_driver->init_termios = tty_std_termios; hsic_tty_driver->init_termios.c_iflag = 0; hsic_tty_driver->init_termios.c_oflag = 0; hsic_tty_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; hsic_tty_driver->init_termios.c_lflag = 0; hsic_tty_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_set_operations(hsic_tty_driver, &hsic_tty_ops); ret = tty_register_driver(hsic_tty_driver); if (ret) { put_tty_driver(hsic_tty_driver); pr_err("%s: driver registration failed %d\n", __func__, ret); return ret; } port_num = hsic_tty_data_setup(1, HSIC_TTY_SERIAL); if (port_num < 0) { pr_err("%s: hsic_tty_data_setup failed\n", __func__); goto out; } ret = hsic_tty_ctrl_setup(1, HSIC_TTY_SERIAL); if (ret < 0) { pr_err("%s: hsic_tty_ctrl_setup failed\n", __func__); goto out; } hsic_tty.client_port_num = port_num; #ifdef CONFIG_MODEM_SUPPORT spin_lock_init(&hsic_tty.lock); spin_lock_init(&hsic_tty.reset_lock); hsic_tty.connect = hsic_tty_connect; hsic_tty.get_dtr = hsic_tty_get_dtr; hsic_tty.get_rts = hsic_tty_get_rts; hsic_tty.send_carrier_detect = hsic_tty_send_carrier_detect; hsic_tty.send_ring_indicator = hsic_tty_send_ring_indicator; hsic_tty.send_modem_ctrl_bits = hsic_tty_send_modem_ctrl_bits; hsic_tty.disconnect = hsic_tty_disconnect; hsic_tty.send_break = hsic_tty_send_break;; #endif hsic_tty.tty = NULL; ret = hsic_tty_ctrl_connect(&hsic_tty, port_num); if (ret) { pr_err("%s: hsic_tty_ctrl_connect failed: err:%d\n", __func__, ret); goto out; } ret = hsic_tty_data_connect(&hsic_tty, port_num); if (ret) { pr_err("%s: hsic_tty_data_connect failed: err:%d\n", __func__, ret); hsic_tty_ctrl_disconnect(&hsic_tty, port_num); goto out; } for (n = 0; n < MAX_HSIC_TTYS; ++n) { pr_info("%s: %d\n", __func__, n); tty_register_device(hsic_tty_driver, n, 0); } return 0; out: tty_unregister_driver(hsic_tty_driver); put_tty_driver(hsic_tty_driver); return ret; }
/* * 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); error = tty_register_driver(serial_driver); if (error) goto fail_put_tty_driver; 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; 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: put_tty_driver(serial_driver); return error; }
static int lcd_probe(struct i2c_client *client, const struct i2c_device_id *i2c_id) { struct device_node *np = client->dev.of_node; struct lcd *lcd_data; struct tty_driver *lcd_tty_driver; unsigned int width = 0, height = 0, i, brightness = 0; char *buffer; int ret = -ENOMEM; of_property_read_u32(np, "height", &height); of_property_read_u32(np, "width", &width); if ((width == 0) || (height == 0)) { dev_err(&client->dev, "Need to specify lcd width/height in device tree\n"); ret = -EINVAL; goto err_devtree; } of_property_read_u32(np, "brightness", &brightness); if ((brightness < LCD_BRIGHTNESS_MIN) || (brightness > LCD_BRIGHTNESS_MAX)) { dev_info(&client->dev, "lcd brighness not set or out of range, defaulting to maximum\n"); brightness = LCD_BRIGHTNESS_MAX; } for (i = 0 ; i < MAX_LCDS ; i++) if (lcd_data_static[i].client == NULL) break; if (i >= MAX_LCDS) { ret = -ENODEV; dev_warn(&client->dev, "More than %d I2C LCD displays found. Giving up.\n", MAX_LCDS); goto err_devtree; } lcd_data = &lcd_data_static[i]; buffer = kzalloc(height * width, GFP_KERNEL); if (!buffer) goto err_devtree; i2c_set_clientdata(client, lcd_data); lcd_data->client = client; lcd_data->dev = &client->dev; lcd_data->height = height; lcd_data->width = width; lcd_data->buffer = buffer; lcd_data->brightness = brightness; dev_set_drvdata(&client->dev, lcd_data); tty_port_init(&lcd_data->port); lcd_tty_driver = alloc_tty_driver(MAX_LCDS); if (!lcd_tty_driver) goto err_driver; lcd_tty_driver->driver_name = DRV_NAME; lcd_tty_driver->name = DEV_NAME; lcd_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; lcd_tty_driver->subtype = SERIAL_TYPE_NORMAL; lcd_tty_driver->init_termios = tty_std_termios; tty_set_operations(lcd_tty_driver, &lcd_ops); ret = tty_register_driver(lcd_tty_driver); if (ret) goto err_register; lcd_data->lcd_tty_driver = lcd_tty_driver; lcd_clear_buffer(lcd_data); lcd_load_custom_fonts(lcd_data); lcd_cmd_display_on(lcd_data); lcd_cmd_backlight_brightness(lcd_data, brightness); lcd_cmd_clear_screen(lcd_data); ret = sysfs_create_group(&lcd_data->dev->kobj, &lcd_attr_group); if (ret) { dev_err(lcd_data->dev, "Can't create sysfs attrs for lcd\n"); return ret; } dev_info(&client->dev, "LCD driver initialized\n"); return 0; err_register: put_tty_driver(lcd_data->lcd_tty_driver); err_driver: kfree(buffer); err_devtree: return ret; }
/* mcfrs_init inits the driver */ static int __init mcfrs_init(void) { struct mcf_serial *info; unsigned long flags; int i; /* Setup base handler, and timer table. */ #ifdef MCFPP_DCD0 init_timer(&mcfrs_timer_struct); mcfrs_timer_struct.function = mcfrs_timer; mcfrs_timer_struct.data = 0; mcfrs_timer_struct.expires = jiffies + HZ/25; add_timer(&mcfrs_timer_struct); mcfrs_ppstatus = mcf_getppdata() & (MCFPP_DCD0 | MCFPP_DCD1); #endif mcfrs_serial_driver = alloc_tty_driver(NR_PORTS); if (!mcfrs_serial_driver) return -ENOMEM; show_serial_version(); /* Initialize the tty_driver structure */ mcfrs_serial_driver->owner = THIS_MODULE; mcfrs_serial_driver->name = "ttyS"; mcfrs_serial_driver->driver_name = "mcfserial"; mcfrs_serial_driver->major = TTY_MAJOR; mcfrs_serial_driver->minor_start = 64; mcfrs_serial_driver->type = TTY_DRIVER_TYPE_SERIAL; mcfrs_serial_driver->subtype = SERIAL_TYPE_NORMAL; mcfrs_serial_driver->init_termios = tty_std_termios; mcfrs_serial_driver->init_termios.c_cflag = mcfrs_console_cbaud | CS8 | CREAD | HUPCL | CLOCAL; mcfrs_serial_driver->flags = TTY_DRIVER_REAL_RAW; tty_set_operations(mcfrs_serial_driver, &mcfrs_ops); if (tty_register_driver(mcfrs_serial_driver)) { printk("MCFRS: Couldn't register serial driver\n"); put_tty_driver(mcfrs_serial_driver); return(-EBUSY); } local_irq_save(flags); /* * Configure all the attached serial ports. */ for (i = 0, info = mcfrs_table; (i < NR_PORTS); i++, info++) { info->magic = SERIAL_MAGIC; info->line = i; info->port.tty = NULL; info->custom_divisor = 16; info->close_delay = 50; info->closing_wait = 3000; info->x_char = 0; info->event = 0; info->count = 0; info->blocked_open = 0; INIT_WORK(&info->tqueue, mcfrs_offintr); INIT_WORK(&info->tqueue_hangup, do_serial_hangup); init_waitqueue_head(&info->open_wait); init_waitqueue_head(&info->close_wait); info->imr = 0; mcfrs_setsignals(info, 0, 0); mcfrs_irqinit(info); printk("ttyS%d at 0x%04x (irq = %d)", info->line, (unsigned int) info->addr, info->irq); printk(" is a builtin ColdFire UART\n"); } local_irq_restore(flags); return 0; }
static int mytty_probe(struct platform_device *dev) { int ret = 0; int i = 0; pmytty = alloc_tty_driver(MY_TTY_MINOR); if(!pmytty) { printk("%s: failed to alloc for mytty\n",TAGS); return -ENOMEM; } pmytty->owner = THIS_MODULE; pmytty->driver_name = "mytty"; pmytty->name = "ttyL"; pmytty->major = MY_TTY_MAJOR; pmytty->num = 4; pmytty->type = TTY_DRIVER_TYPE_SERIAL; pmytty->subtype = SERIAL_TYPE_NORMAL; pmytty->flags = TTY_DRIVER_REAL_RAW;//|TTY_DRIVER_NO_DEVFS; pmytty->init_termios = tty_std_termios; pmytty->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; tty_set_operations(pmytty,&mytty_ops); pmytty->ports = kzalloc(pmytty->num * (sizeof(struct tty_port*)), GFP_KERNEL); if(!pmytty->ports) { printk("%s: failed to malloc for pmytty->ports\n",TAGS); goto malloc_port_err; } pmytty->ports[0] = kzalloc(pmytty->num * (sizeof(struct tty_port)), GFP_KERNEL); if(!pmytty->ports[0]) { printk("%s: failed to malloc for pmytty->ports[0]\n",TAGS); goto malloc_port0_err; } for(i = 0;i < pmytty->num; i++ ) { pmytty->ports[i] = pmytty->ports[0] + i; tty_port_init(pmytty->ports[i]); } ret = tty_register_driver(pmytty); if(ret) { printk("%s: failed to register mytty driver\n",TAGS); goto tty_reg_err; } printk("%s: %s run successfully\n", TAGS, __func__ ); return 0; tty_reg_err: for(i = 0;i < pmytty->num; i++ ) { kfree(pmytty->ports[i]); } malloc_port0_err: kfree(pmytty->ports); malloc_port_err: put_tty_driver(pmytty); return ret; }
/** * ehv_bc_init - ePAPR hypervisor byte channel driver initialization * * This function is called when this module is loaded. */ static int __init ehv_bc_init(void) { struct device_node *np; unsigned int count = 0; /* Number of elements in bcs[] */ int ret; pr_info("ePAPR hypervisor byte channel driver\n"); /* Count the number of byte channels */ for_each_compatible_node(np, NULL, "epapr,hv-byte-channel") count++; if (!count) return -ENODEV; /* The array index of an element in bcs[] is the same as the tty index * for that element. If you know the address of an element in the * array, then you can use pointer math (e.g. "bc - bcs") to get its * tty index. */ bcs = kzalloc(count * sizeof(struct ehv_bc_data), GFP_KERNEL); if (!bcs) return -ENOMEM; ehv_bc_driver = alloc_tty_driver(count); if (!ehv_bc_driver) { ret = -ENOMEM; goto error; } ehv_bc_driver->driver_name = "ehv-bc"; ehv_bc_driver->name = ehv_bc_console.name; ehv_bc_driver->type = TTY_DRIVER_TYPE_CONSOLE; ehv_bc_driver->subtype = SYSTEM_TYPE_CONSOLE; ehv_bc_driver->init_termios = tty_std_termios; ehv_bc_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; tty_set_operations(ehv_bc_driver, &ehv_bc_ops); ret = tty_register_driver(ehv_bc_driver); if (ret) { pr_err("ehv-bc: could not register tty driver (ret=%i)\n", ret); goto error; } ret = platform_driver_register(&ehv_bc_tty_driver); if (ret) { pr_err("ehv-bc: could not register platform driver (ret=%i)\n", ret); goto error; } return 0; error: if (ehv_bc_driver) { tty_unregister_driver(ehv_bc_driver); put_tty_driver(ehv_bc_driver); } kfree(bcs); return ret; }
static int __init lge_dm_dev_tty_init(void) { int ret = 0; struct device *tty_dev; struct dm_dev_tty *lge_dm_dev_tty_drv; pr_info(DM_DEV_TTY_MODULE_NAME ": %s:\n",__func__); lge_dm_dev_tty_drv = kzalloc(sizeof(struct dm_dev_tty), GFP_KERNEL); if(lge_dm_dev_tty_drv == NULL) { pr_info(DM_DEV_TTY_MODULE_NAME ": %s:" "failed to allocate lge_dm_dev_tty", __func__); return 0; } lge_dm_dev_tty = lge_dm_dev_tty_drv; lge_dm_dev_tty_drv -> tty_drv = alloc_tty_driver(MAX_DM_DEV_TTY_DRV); if(!lge_dm_dev_tty->tty_drv) { pr_info(DM_DEV_TTY_MODULE_NAME ": %s:tty_drv is NULL", __func__); kfree(lge_dm_dev_tty_drv); return 0; } lge_dm_dev_tty_drv->tty_drv->name = "lge_dm_dev_tty"; lge_dm_dev_tty_drv->tty_drv->owner = THIS_MODULE; lge_dm_dev_tty_drv->tty_drv->driver_name = "lge_dm_dev_tty"; /* uses dynamically assigned dev_t values */ lge_dm_dev_tty_drv->tty_drv->type = TTY_DRIVER_TYPE_SERIAL; lge_dm_dev_tty_drv->tty_drv->subtype = SERIAL_TYPE_NORMAL; lge_dm_dev_tty_drv->tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_RESET_TERMIOS; /* initializing the tty driver */ lge_dm_dev_tty_drv->tty_drv->init_termios = tty_std_termios; lge_dm_dev_tty_drv->tty_drv->init_termios.c_iflag = IGNBRK | IGNPAR; lge_dm_dev_tty_drv->tty_drv->init_termios.c_oflag = 0; lge_dm_dev_tty_drv->tty_drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; lge_dm_dev_tty_drv->tty_drv->init_termios.c_lflag = 0; tty_set_operations(lge_dm_dev_tty_drv->tty_drv, &lge_dm_dev_tty_ops); ret = tty_register_driver(lge_dm_dev_tty_drv->tty_drv); if (ret) { put_tty_driver(lge_dm_dev_tty_drv->tty_drv); pr_info(DM_DEV_TTY_MODULE_NAME ": %s:" "tty_register_driver() ""failed\n", __func__); lge_dm_dev_tty_drv->tty_drv = NULL; kfree(lge_dm_dev_tty_drv); return 0; } tty_dev = tty_register_device(lge_dm_dev_tty_drv -> tty_drv, 0, NULL); if(IS_ERR(tty_dev)) { pr_info(DM_DEV_TTY_MODULE_NAME ": %s:" "tty_register_driver() ""failed\n", __func__); tty_unregister_driver(lge_dm_dev_tty_drv -> tty_drv); put_tty_driver(lge_dm_dev_tty_drv -> tty_drv); kfree(lge_dm_dev_tty_drv); return 0; } init_waitqueue_head(&lge_dm_dev_tty_drv->waitq); lge_dm_dev_tty_drv -> tty_state = DM_DEV_TTY_REGISTERED; return 0; }
int micvcons_create(int num_bds) { micvcons_port_t *port; bd_info_t *bd_info; int bd, ret = 0; char wq_name[14]; struct device *dev; INIT_LIST_HEAD(&timer_list_head); if (micvcons_tty) goto exit; micvcons_tty = alloc_tty_driver(num_bds); if (!micvcons_tty) { ret = -ENOMEM; goto exit; } micvcons_tty->owner = THIS_MODULE; micvcons_tty->driver_name = MICVCONS_DEVICE_NAME; micvcons_tty->name = MICVCONS_DEVICE_NAME; micvcons_tty->major = 0; #if LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0) micvcons_tty->minor_num = num_bds; #endif micvcons_tty->minor_start = 0; micvcons_tty->type = TTY_DRIVER_TYPE_SERIAL; micvcons_tty->subtype = SERIAL_TYPE_NORMAL; micvcons_tty->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; micvcons_tty->init_termios = tty_std_termios; micvcons_tty->init_termios.c_iflag = IGNCR; micvcons_tty->init_termios.c_oflag = 0; micvcons_tty->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; micvcons_tty->init_termios.c_lflag = 0; tty_set_operations(micvcons_tty, &micvcons_tty_ops); if ((ret = tty_register_driver(micvcons_tty)) != 0) { printk("Failed to register vcons tty driver\n"); put_tty_driver(micvcons_tty); micvcons_tty = NULL; goto exit; } for (bd = 0; bd < num_bds; bd++) { port = &mic_data.dd_ports[bd]; port->dp_bdinfo = mic_data.dd_bi[bd]; spin_lock_init(&port->dp_lock); mutex_init (&port->dp_mutex); bd_info = (bd_info_t *)port->dp_bdinfo; bd_info->bi_port = port; dev = tty_register_device(micvcons_tty, bd, NULL); if (IS_ERR(dev)) { printk("Failed to register vcons tty device\n"); micvcons_destroy(bd); ret = PTR_ERR(dev); goto exit; } snprintf(wq_name, sizeof(wq_name), "VCONS MIC %d", bd); port->dp_wq = create_singlethread_workqueue(wq_name); if (!port->dp_wq) { printk(KERN_ERR "%s: create_singlethread_workqueue\n", __func__); tty_unregister_device(micvcons_tty, bd); micvcons_destroy(bd); ret = -ENOMEM; goto exit; } INIT_WORK(&port->dp_wakeup_read_buf, micvcons_wakeup_readbuf); } vcons_timer.function = micvcons_timeout; vcons_timer.data = (unsigned long)(&timer_list_head); init_timer(&vcons_timer); exit: return ret; }
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 | TTY_DRIVER_RESET_TERMIOS; 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); gserial_wq = create_singlethread_workqueue("k_gserial"); if (!gserial_wq) { status = -ENOMEM; goto fail; } /* export the driver ... */ status = tty_register_driver(gs_tty_driver); if (status) { pr_err("%s: cannot register, err %d\n", __func__, status); goto fail; } for (i = 0; i < MAX_U_SERIAL_PORTS; i++) usb_debugfs_init(ports[i].port, i); 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); if (gserial_wq) destroy_workqueue(gserial_wq); gs_tty_driver = NULL; return status; }
static void __exit acm_exit(void) { usb_deregister(&acm_driver); tty_unregister_driver(acm_tty_driver); put_tty_driver(acm_tty_driver); }
static void __exit tty3215_exit(void) { tty_unregister_driver(tty3215_driver); put_tty_driver(tty3215_driver); ccw_driver_unregister(&raw3215_ccw_driver); }
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); #ifdef CONFIG_IMC_UART2DM_HANDSHAKE if (!strcmp(drv->driver_name, "msm_serial_hs_imc")) { if (get_kernel_flag() & BIT(20)){ uart2_handshaking_mask = 1; printk(KERN_DEBUG MODULE_NAME " %s enable uart2 handshaking debug msg\n", __func__); } } #endif if (retval >= 0) return retval; put_tty_driver(normal); out_kfree: kfree(drv->state); out: return -ENOMEM; }
static void userial_cleanup(void) { tty_unregister_driver(gs_tty_driver); put_tty_driver(gs_tty_driver); gs_tty_driver = NULL; }
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 xencons_init(void) { int rc; if (!is_running_on_xen()) return -ENODEV; if (xc_mode == XC_OFF) return 0; if (!is_initial_xendomain()) { rc = xencons_ring_init(); if (rc) return rc; } xencons_driver = alloc_tty_driver((xc_mode == XC_TTY) ? MAX_NR_CONSOLES : 1); if (xencons_driver == NULL) return -ENOMEM; DRV(xencons_driver)->name = "xencons"; DRV(xencons_driver)->major = TTY_MAJOR; DRV(xencons_driver)->type = TTY_DRIVER_TYPE_SERIAL; DRV(xencons_driver)->subtype = SERIAL_TYPE_NORMAL; DRV(xencons_driver)->init_termios = tty_std_termios; DRV(xencons_driver)->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_NO_DEVFS; DRV(xencons_driver)->termios = xencons_termios; DRV(xencons_driver)->termios_locked = xencons_termios_locked; switch (xc_mode) { case XC_XVC: DRV(xencons_driver)->name = "xvc"; DRV(xencons_driver)->major = XEN_XVC_MAJOR; DRV(xencons_driver)->minor_start = XEN_XVC_MINOR; DRV(xencons_driver)->name_base = xc_num; break; case XC_SERIAL: DRV(xencons_driver)->name = "ttyS"; DRV(xencons_driver)->minor_start = 64 + xc_num; DRV(xencons_driver)->name_base = xc_num; break; default: DRV(xencons_driver)->name = "tty"; DRV(xencons_driver)->minor_start = 1; DRV(xencons_driver)->name_base = 1; break; } tty_set_operations(xencons_driver, &xencons_ops); if ((rc = tty_register_driver(DRV(xencons_driver))) != 0) { printk("WARNING: Failed to register Xen virtual " "console driver as '%s%d'\n", DRV(xencons_driver)->name, DRV(xencons_driver)->name_base); put_tty_driver(xencons_driver); xencons_driver = NULL; return rc; } tty_register_device(xencons_driver, 0, NULL); if (is_initial_xendomain()) { xencons_priv_irq = bind_virq_to_irqhandler( VIRQ_CONSOLE, 0, xencons_priv_interrupt, 0, "console", NULL); BUG_ON(xencons_priv_irq < 0); } printk("Xen virtual console successfully installed as %s%d\n", DRV(xencons_driver)->name, xc_num); /* Check about framebuffer messing up the console */ if (!is_initial_xendomain() && !xenbus_exists(XBT_NIL, "device", "vfb")) { /* FIXME: this is ugly */ unregister_console(&kcons_info); kcons_info.flags |= CON_CONSDEV; register_console(&kcons_info); } return 0; }