static int __init tegra_uart_init(void)
{
int ret;
ret = uart_register_driver(&tegra_uart_driver);
if (ret < 0) {
pr_err("Could not register %s driver\n",
tegra_uart_driver.driver_name);
return ret;
}
ret = platform_driver_register(&tegra_uart_platform_driver);
if (ret < 0) {
pr_err("Uart platform driver register failed, e = %d\n", ret);
uart_unregister_driver(&tegra_uart_driver);
return ret;
}
return 0;
}
static int __init tctuart_init(void)
{
int ret;
printk("tct_uart: Tct UART driver\n");
/* configure from hardware setup structures */
tctuart_driver.nr = 1;
tx_cts = 1;
ret = uart_register_driver(&tctuart_driver);
if( ret < 0 )
return ret;
ret = platform_driver_register(&tctuart_serial_driver);
if( ret < 0 )
uart_unregister_driver(&tctuart_driver);
return ret;
}
static int __init msm_serial_init(void)
{
int ret;
//SW2-5-1-MP-DbgCfgTool-00+[
#ifdef CONFIG_FIH_REMOVE_SERIAL_DYNAMICALLY
struct clk *uart2_clk;
if(!fih_read_uart_switch_from_smem()) {
printk(KERN_INFO "msm_serial: Disable UART clock\n");
gpio_tlmm_config(GPIO_CFG(51, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
gpio_tlmm_config(GPIO_CFG(52, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE);
uart2_clk = clk_get(&msm_device_uart2.dev, "uart_clk");
if(!IS_ERR(uart2_clk)){
clk_enable(uart2_clk); //If clk_enable is not called, calling clk_disable will enter ram dump.
clk_disable(uart2_clk);
}
#ifndef CONFIG_FIH_MODEM_REMOVE_UART2_CLK
/* Disable console suspend to guarantee there's no buffer copy delay after resume */
console_suspend_enabled = 0; //SW2-5-2-MP-DbgCfgTool-08+
#endif /* CONFIG_FIH_MODEM_REMOVE_UART2_CLK */
return 0;
}
#ifndef CONFIG_FIH_MODEM_REMOVE_UART2_CLK
/* Enable suspend console when UART clock is enable, it will buffer the kernel log, and emit it after resume
* This can make sure DUT can enter suspend mode without interrupt */
console_suspend_enabled = 1; //SW2-5-2-MP-DbgCfgTool-08+
#endif /* CONFIG_FIH_MODEM_REMOVE_UART2_CLK */
#endif
//SW2-5-1-MP-DbgCftTool-00+]
ret = uart_register_driver(&msm_uart_driver);
if (unlikely(ret))
return ret;
ret = platform_driver_probe(&msm_platform_driver, msm_serial_probe);
if (unlikely(ret))
uart_unregister_driver(&msm_uart_driver);
printk(KERN_INFO "msm_serial: driver initialized\n");
return ret;
}
static int __init pnx8xxx_serial_init(void)
{
int ret;
#ifdef CONFIG_DEBUG_PRINTK
printk(KERN_INFO "Serial: PNX8XXX driver\n");
#else
;
#endif
pnx8xxx_init_ports();
ret = uart_register_driver(&pnx8xxx_reg);
if (ret == 0) {
ret = platform_driver_register(&pnx8xxx_serial_driver);
if (ret)
uart_unregister_driver(&pnx8xxx_reg);
}
return ret;
}
static int __init msm_serial_hsl_init(void)
{
int ret;
if (!enable)
msm_hsl_uart_driver.cons = NULL;
ret = uart_register_driver(&msm_hsl_uart_driver);
if (unlikely(ret))
return ret;
ret = platform_driver_probe(&msm_hsl_platform_driver,
msm_serial_hsl_probe);
if (unlikely(ret))
uart_unregister_driver(&msm_hsl_uart_driver);
printk(KERN_INFO "msm_serial_hsl: driver initialized\n");
return ret;
}
static int __init bfin_serial_init(void)
{
int ret;
pr_info("Blackfin serial driver\n");
ret = uart_register_driver(&bfin_serial_reg);
if (ret) {
pr_err("failed to register %s:%d\n",
bfin_serial_reg.driver_name, ret);
}
ret = platform_driver_register(&bfin_serial_driver);
if (ret) {
pr_err("fail to register bfin uart\n");
uart_unregister_driver(&bfin_serial_reg);
}
return ret;
}
static int msm_serial_hsl_init(void)
{
int ret;
ret = uart_register_driver(&msm_hsl_uart_driver);
if (unlikely(ret))
return ret;
debug_base = debugfs_create_dir("msm_serial_hsl", NULL);
if (IS_ERR_OR_NULL(debug_base))
pr_err("%s():Cannot create debugfs dir\n", __func__);
ret = platform_driver_register(&msm_hsl_platform_driver);
if (unlikely(ret))
uart_unregister_driver(&msm_hsl_uart_driver);
printk(KERN_INFO "msm_serial_hsl: driver initialized\n");
return ret;
}
static int __init tegra_uart_init(void)
{
int ret;
ret = uart_register_driver(&tegra_uart_driver);
if (unlikely(ret)) {
pr_err("Could not register %s driver\n",
tegra_uart_driver.driver_name);
return ret;
}
ret = platform_driver_register(&tegra_uart_platform_driver);
if (unlikely(ret)) {
pr_err("Could not register the UART platfrom driver\n");
uart_unregister_driver(&tegra_uart_driver);
return ret;
}
pr_info("Initialized tegra uart driver\n");
return 0;
}
static int __init nlm_pcix_console_init(void)
{
int result;
if(xlr_get_pci_mode() == XLR_PCI_HOST_MODE){
Message("Xlr Is configured in Host Mode - unloading console_over_pci_dev\n");
return -EIO;
}
if(nlm_common_get_shared_mem_base_dev() == 0){
ErrorMsg("Get Shared Mem Base Iz Zero");
return -ENODEV;
}
Message ("Tiny serial driver");
result = uart_register_driver(&nlm_pcix_console_reg);
if (result){
ErrorMsg("Cant Register Driver");
return result;
}
result = uart_add_one_port(&nlm_pcix_console_reg, &nlm_pcix_console_port);
if (result){
ErrorMsg("Cant Add Port");
uart_unregister_driver(&nlm_pcix_console_reg);
}
Message("Returning From init_module [%d]",result);
Message("\nnlm_common_user_cmd @ %#x\n",(u32)nlm_common_user_cmd);
Message("nlm_common_user_result @ %#x\n",(u32)nlm_common_user_result);
Message("User_Cmd_Producer [%#x]\n",(u32)nlm_common_user_cmd_producer);
Message("User_Cmd_Consumer [%#x]\n",(u32)nlm_common_user_cmd_consumer);
Message("User_Result_Consumer [%#x]\n",(u32)nlm_common_user_result_consumer);
Message("User_Result_Producer [%#x]\n",(u32)nlm_common_user_result_producer);
init_waitqueue_head(&user_result_buffer);
printk("\nConsole Over Pci Driver - Registered\n");
return result;
}
static int __init ulite_init(void)
{
int ret;
pr_debug("uartlite: calling uart_register_driver()\n");
ret = uart_register_driver(&ulite_uart_driver);
if (ret)
goto err_uart;
pr_debug("uartlite: calling platform_driver_register()\n");
ret = platform_driver_register(&ulite_platform_driver);
if (ret)
goto err_plat;
return 0;
err_plat:
uart_unregister_driver(&ulite_uart_driver);
err_uart:
pr_err("registering uartlite driver failed: err=%i", ret);
return ret;
}
static int max310x_remove(struct device *dev)
{
struct max310x_port *s = dev_get_drvdata(dev);
int i;
#ifdef CONFIG_GPIOLIB
gpiochip_remove(&s->gpio);
#endif
for (i = 0; i < s->uart.nr; i++) {
cancel_work_sync(&s->p[i].tx_work);
cancel_work_sync(&s->p[i].md_work);
uart_remove_one_port(&s->uart, &s->p[i].port);
s->devtype->power(&s->p[i].port, 0);
}
mutex_destroy(&s->mutex);
uart_unregister_driver(&s->uart);
clk_disable_unprepare(s->clk);
return 0;
}
static int __init uart00_init(void)
{
int result;
printk(KERN_INFO "Serial: UART00 driver $Revision: 1.35 $\n");
printk(KERN_WARNING "serial_uart00:Using temporary major/minor pairs"
" - these WILL change in the future\n");
result = uart_register_driver(&uart00_reg);
if (result)
return result;
#ifdef CONFIG_ARCH_CAMELOT
result = uart_add_one_port(&uart00_reg,&epxa10db_port);
#endif
if (result)
uart_unregister_driver(&uart00_reg);
#ifdef CONFIG_PLD_HOTSWAP
pldhs_register_driver(&uart00_pldhs_ops);
#endif
return result;
}
/*
* Register the driver, console driver and ports with the serial
* core
*/
static int __init pmz_register(void)
{
int i, rc;
pmz_uart_reg.nr = pmz_ports_count;
pmz_uart_reg.cons = PMACZILOG_CONSOLE;
pmz_uart_reg.minor = 64;
/*
* Register this driver with the serial core
*/
rc = uart_register_driver(&pmz_uart_reg);
if (rc)
return rc;
/*
* Register each port with the serial core
*/
for (i = 0; i < pmz_ports_count; i++) {
struct uart_pmac_port *uport = &pmz_ports[i];
/* NULL node may happen on wallstreet */
if (uport->node != NULL)
rc = uart_add_one_port(&pmz_uart_reg, &uport->port);
if (rc)
goto err_out;
}
return 0;
err_out:
while (i-- > 0) {
struct uart_pmac_port *uport = &pmz_ports[i];
uart_remove_one_port(&pmz_uart_reg, &uport->port);
}
uart_unregister_driver(&pmz_uart_reg);
return rc;
}
static int __init msm_serial_hsl_init(void)
{
int ret;
/* Switch uartdebug by kernelflag */
if (get_kernel_flag() & BIT1)
msm_serial_hsl_enable = 1;
if (!msm_serial_hsl_enable)
msm_hsl_uart_driver.cons = NULL;
ret = uart_register_driver(&msm_hsl_uart_driver);
if (unlikely(ret))
return ret;
ret = platform_driver_probe(&msm_hsl_platform_driver,
msm_serial_hsl_probe);
if (unlikely(ret))
uart_unregister_driver(&msm_hsl_uart_driver);
printk(KERN_INFO "msm_serial_hsl: driver initialized\n");
return ret;
}
static void __exit cpm_uart_exit(void)
{
of_unregister_platform_driver(&cpm_uart_driver);
uart_unregister_driver(&cpm_reg);
}
static void __exit serial_omap_exit(void)
{
platform_driver_unregister(&serial_omap_driver);
uart_unregister_driver(&serial_omap_reg);
}
static void __exit mcf_exit(void)
{
platform_driver_unregister(&mcf_platform_driver);
uart_unregister_driver(&mcf_driver);
}
static void __exit etraxfs_uart_exit(void)
{
platform_driver_unregister(&etraxfs_uart_platform_driver);
uart_unregister_driver(&etraxfs_uart_driver);
}
static void __exit sa1100_serial_exit(void)
{
platform_driver_unregister(&sa11x0_serial_driver);
uart_unregister_driver(&sa1100_reg);
}
static void __exit stmp_appuart_exit()
{
platform_driver_unregister(&stmp_appuart_driver);
uart_unregister_driver(&stmp_appuart_uart);
}
static void __exit plser_exit(void)
{
uart_unregister_driver(&plser_reg);
}
static void __exit mxs_auart_exit(void)
{
platform_driver_unregister(&mxs_auart_driver);
uart_unregister_driver(&auart_driver);
}
static void __exit cpm_uart_exit(void)
{
driver_unregister(&cpm_scc_uart_driver);
driver_unregister(&cpm_smc_uart_driver);
uart_unregister_driver(&cpm_reg);
}
static void __exit tegra_uart_exit(void)
{
pr_info("Unloading tegra uart driver\n");
platform_driver_unregister(&tegra_uart_platform_driver);
uart_unregister_driver(&tegra_uart_driver);
}
static void __exit ulite_exit(void)
{
platform_driver_unregister(&ulite_platform_driver);
uart_unregister_driver(&ulite_uart_driver);
}
static void __exit s3c24xx_serial_modexit(void)
{
uart_unregister_driver(&s3c24xx_uart_drv);
}
static void __exit pl010_exit(void)
{
amba_driver_unregister(&pl010_driver);
uart_unregister_driver(&amba_reg);
}
static void __exit asc_exit(void)
{
platform_driver_unregister(&asc_serial_driver);
uart_unregister_driver(&asc_uart_driver);
}
static void __exit jsm_exit_module(void)
{
pci_unregister_driver(&jsm_driver);
uart_unregister_driver(&jsm_uart_driver);
}
static int timbuart_probe(struct platform_device *dev)
{
int err, irq;
struct timbuart_port *uart;
struct resource *iomem;
dev_dbg(&dev->dev, "%s\n", __func__);
uart = kzalloc(sizeof(*uart), GFP_KERNEL);
if (!uart) {
err = -EINVAL;
goto err_mem;
}
uart->usedma = 0;
uart->port.uartclk = 3250000 * 16;
uart->port.fifosize = TIMBUART_FIFO_SIZE;
uart->port.regshift = 2;
uart->port.iotype = UPIO_MEM;
uart->port.ops = &timbuart_ops;
uart->port.irq = 0;
uart->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP;
uart->port.line = 0;
uart->port.dev = &dev->dev;
iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
if (!iomem) {
err = -ENOMEM;
goto err_register;
}
uart->port.mapbase = iomem->start;
uart->port.membase = NULL;
irq = platform_get_irq(dev, 0);
if (irq < 0) {
err = -EINVAL;
goto err_register;
}
uart->port.irq = irq;
tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart);
err = uart_register_driver(&timbuart_driver);
if (err)
goto err_register;
err = uart_add_one_port(&timbuart_driver, &uart->port);
if (err)
goto err_add_port;
platform_set_drvdata(dev, uart);
return 0;
err_add_port:
uart_unregister_driver(&timbuart_driver);
err_register:
kfree(uart);
err_mem:
printk(KERN_ERR "timberdale: Failed to register Timberdale UART: %d\n",
err);
return err;
}
