tty_port_link_device(&srmcons_singleton.port, driver, 0);
                err = tty_register_driver(driver);
                if (err) {
-                       put_tty_driver(driver);
+                       tty_driver_kref_put(driver);
                        tty_port_destroy(&srmcons_singleton.port);
                        return err;
                }
 
        res = tty_register_driver(driver);
        if (res) {
                pr_err("failed to register nfcon tty driver\n");
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                tty_port_destroy(&nfcon_tty_port);
                return res;
        }
 {
        unregister_console(&nf_console);
        tty_unregister_driver(nfcon_tty_driver);
-       put_tty_driver(nfcon_tty_driver);
+       tty_driver_kref_put(nfcon_tty_driver);
        tty_port_destroy(&nfcon_tty_port);
 }
 
 
        if (err) {
                printk(KERN_ERR "register_lines : can't register %s driver\n",
                       line_driver->name);
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                for (i = 0; i < nlines; i++)
                        tty_port_destroy(&lines[i].port);
                return err;
 
 static __exit void rs_exit(void)
 {
        tty_unregister_driver(serial_driver);
-       put_tty_driver(serial_driver);
+       tty_driver_kref_put(serial_driver);
        tty_port_destroy(&serial_port);
 }
 
 
 err_unreg_tty:
        tty_unregister_driver(serial_driver);
 err_put_tty:
-       put_tty_driver(serial_driver);
+       tty_driver_kref_put(serial_driver);
 err:
        return rc;
 }
 {
        pcmcia_unregister_driver(&mgslpc_driver);
        tty_unregister_driver(serial_driver);
-       put_tty_driver(serial_driver);
+       tty_driver_kref_put(serial_driver);
 }
 
 module_init(synclink_cs_init);
 
        return 0;
 
 error:
-       put_tty_driver(ttyprintk_driver);
+       tty_driver_kref_put(ttyprintk_driver);
        tty_port_destroy(&tpk_port.port);
        return ret;
 }
 static void __exit ttyprintk_exit(void)
 {
        tty_unregister_driver(ttyprintk_driver);
-       put_tty_driver(ttyprintk_driver);
+       tty_driver_kref_put(ttyprintk_driver);
        tty_port_destroy(&tpk_port.port);
 }
 
 
        res = tty_register_driver(tty);
        if (res) {
                dev_err(&ipoctal->dev->dev, "Can't register tty driver.\n");
-               put_tty_driver(tty);
+               tty_driver_kref_put(tty);
                return res;
        }
 
        }
 
        tty_unregister_driver(ipoctal->tty_drv);
-       put_tty_driver(ipoctal->tty_drv);
+       tty_driver_kref_put(ipoctal->tty_drv);
        kfree(ipoctal);
 }
 
 
 
        err = tty_register_driver(drv);
        if (err) {
-               put_tty_driver(drv);
+               tty_driver_kref_put(drv);
                kfree(capiminors);
                printk(KERN_ERR "Couldn't register capi_nc driver\n");
                return err;
 static void __exit capinc_tty_exit(void)
 {
        tty_unregister_driver(capinc_tty_driver);
-       put_tty_driver(capinc_tty_driver);
+       tty_driver_kref_put(capinc_tty_driver);
        kfree(capiminors);
 }
 
 
        tty_drv->name = kstrdup(name, GFP_KERNEL);
        if (!tty_drv->name) {
                err = -ENOMEM;
-               goto err_put_tty_driver;
+               goto err_tty_driver_kref_put;
        }
        tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
        tty_drv->subtype = SERIAL_TYPE_NORMAL;
        kfree(tty_drv->name);
        tty_drv->name = NULL;
 
-err_put_tty_driver:
-       put_tty_driver(tty_drv);
+err_tty_driver_kref_put:
+       tty_driver_kref_put(tty_drv);
 
        return err;
 }
        kfree(vk->tty_drv->name);
        vk->tty_drv->name = NULL;
 
-       put_tty_driver(vk->tty_drv);
+       tty_driver_kref_put(vk->tty_drv);
 }
 
 void bcm_vk_tty_terminate_tty_user(struct bcm_vk *vk)
 
 err2:
        tty_unregister_driver(tty_drv);
 err1:
-       put_tty_driver(tty_drv);
+       tty_driver_kref_put(tty_drv);
        return ret;
 }
 
 {
        sdio_unregister_driver(&sdio_uart_driver);
        tty_unregister_driver(sdio_uart_tty_driver);
-       put_tty_driver(sdio_uart_tty_driver);
+       tty_driver_kref_put(sdio_uart_tty_driver);
 }
 
 module_init(sdio_uart_init);
 
 err_unreg_tty:
        tty_unregister_driver(tty_drv);
 err_free_tty:
-       put_tty_driver(tty_drv);
+       tty_driver_kref_put(tty_drv);
        return result;
 }
 
        tty_unregister_driver(tty_drv);
        /* deregister the usb driver */
        usb_deregister(&hso_driver);
-       put_tty_driver(tty_drv);
+       tty_driver_kref_put(tty_drv);
 }
 
 /* Module definitions */
 
 
        ret = ccw_driver_register(&raw3215_ccw_driver);
        if (ret) {
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                return ret;
        }
        /*
        tty_set_operations(driver, &tty3215_ops);
        ret = tty_register_driver(driver);
        if (ret) {
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                return ret;
        }
        tty3215_driver = driver;
 
 
        rc = sclp_rw_init();
        if (rc) {
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                return rc;
        }
        /* Allocate pages for output buffering */
        for (i = 0; i < MAX_KMEM_PAGES; i++) {
                page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
                if (page == NULL) {
-                       put_tty_driver(driver);
+                       tty_driver_kref_put(driver);
                        return -ENOMEM;
                }
                list_add_tail((struct list_head *) page, &sclp_tty_pages);
 
        rc = sclp_register(&sclp_input_event);
        if (rc) {
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                return rc;
        }
 
        tty_port_link_device(&sclp_port, driver, 0);
        rc = tty_register_driver(driver);
        if (rc) {
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                tty_port_destroy(&sclp_port);
                return rc;
        }
 
 out_init:
        __sclp_vt220_cleanup();
 out_driver:
-       put_tty_driver(driver);
+       tty_driver_kref_put(driver);
        return rc;
 }
 __initcall(sclp_vt220_tty_init);
 
        tty_set_operations(driver, &tty3270_ops);
        ret = tty_register_driver(driver);
        if (ret) {
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                return ret;
        }
        tty3270_driver = driver;
        driver = tty3270_driver;
        tty3270_driver = NULL;
        tty_unregister_driver(driver);
-       put_tty_driver(driver);
+       tty_driver_kref_put(driver);
        tty3270_del_views();
 }
 
 
                tty_unregister_driver(fwloop_driver);
 put_loop:
        if (create_loop_dev)
-               put_tty_driver(fwloop_driver);
+               tty_driver_kref_put(fwloop_driver);
 unregister_driver:
        tty_unregister_driver(fwtty_driver);
 put_tty:
-       put_tty_driver(fwtty_driver);
+       tty_driver_kref_put(fwtty_driver);
 remove_debugfs:
        debugfs_remove_recursive(fwserial_debugfs);
 
        kmem_cache_destroy(fwtty_txn_cache);
        if (create_loop_dev) {
                tty_unregister_driver(fwloop_driver);
-               put_tty_driver(fwloop_driver);
+               tty_driver_kref_put(fwloop_driver);
        }
        tty_unregister_driver(fwtty_driver);
-       put_tty_driver(fwtty_driver);
+       tty_driver_kref_put(fwtty_driver);
        debugfs_remove_recursive(fwserial_debugfs);
 }
 
 
 
                ret = tty_register_driver(tty_driver);
                if (ret) {
-                       put_tty_driver(tty_driver);
+                       tty_driver_kref_put(tty_driver);
                        return ret;
                }
 
                tty_driver = gdm_driver[i];
                if (tty_driver) {
                        tty_unregister_driver(tty_driver);
-                       put_tty_driver(tty_driver);
+                       tty_driver_kref_put(tty_driver);
                }
        }
 }
 
        return 0;
 
 fail_put_gb_tty:
-       put_tty_driver(gb_tty_driver);
+       tty_driver_kref_put(gb_tty_driver);
 fail_unregister_dev:
        return retval;
 }
 static void gb_tty_exit(void)
 {
        tty_unregister_driver(gb_tty_driver);
-       put_tty_driver(gb_tty_driver);
+       tty_driver_kref_put(gb_tty_driver);
        idr_destroy(&tty_minors);
 }
 
 
 
        error = tty_register_driver(driver);
        if (error)
-               goto fail_put_tty_driver;
+               goto fail_tty_driver_kref_put;
 
        printk(KERN_INFO "ttyS0 is the amiga builtin serial port\n");
 
        free_irq(IRQ_AMIGA_TBE, state);
 fail_unregister:
        tty_unregister_driver(driver);
-fail_put_tty_driver:
+fail_tty_driver_kref_put:
        tty_port_destroy(&state->tport);
-       put_tty_driver(driver);
+       tty_driver_kref_put(driver);
        return error;
 }
 
        struct serial_state *state = platform_get_drvdata(pdev);
 
        tty_unregister_driver(serial_driver);
-       put_tty_driver(serial_driver);
+       tty_driver_kref_put(serial_driver);
        tty_port_destroy(&state->tport);
 
        free_irq(IRQ_AMIGA_TBE, state);
 
        ret = tty_register_driver(driver);
        if (ret) {
                pr_err("ehv-bc: could not register tty driver (ret=%i)\n", ret);
-               goto err_put_tty_driver;
+               goto err_tty_driver_kref_put;
        }
 
        ehv_bc_driver = driver;
 err_deregister_tty_driver:
        ehv_bc_driver = NULL;
        tty_unregister_driver(driver);
-err_put_tty_driver:
-       put_tty_driver(driver);
+err_tty_driver_kref_put:
+       tty_driver_kref_put(driver);
 err_free_bcs:
        kfree(bcs);
 
 
        return 0;
 
 err_tty_register_driver_failed:
-       put_tty_driver(tty);
+       tty_driver_kref_put(tty);
 err_tty_alloc_driver_failed:
        kfree(goldfish_ttys);
        goldfish_ttys = NULL;
 static void goldfish_tty_delete_driver(void)
 {
        tty_unregister_driver(goldfish_tty_driver);
-       put_tty_driver(goldfish_tty_driver);
+       tty_driver_kref_put(goldfish_tty_driver);
        goldfish_tty_driver = NULL;
        kfree(goldfish_ttys);
        goldfish_ttys = NULL;
 
        kthread_stop(hvc_task);
        hvc_task = NULL;
 put_tty:
-       put_tty_driver(drv);
+       tty_driver_kref_put(drv);
 out:
        return err;
 }
 
 register_fail:
        hvcs_free_index_list();
 index_fail:
-       put_tty_driver(hvcs_tty_driver);
+       tty_driver_kref_put(hvcs_tty_driver);
        hvcs_tty_driver = NULL;
        mutex_unlock(&hvcs_init_mutex);
        return rc;
 
        hvcs_free_index_list();
 
-       put_tty_driver(hvcs_tty_driver);
+       tty_driver_kref_put(hvcs_tty_driver);
 
        printk(KERN_INFO "HVCS: driver module removed.\n");
 }
 
        if (result) {
                printk(KERN_ERR IPWIRELESS_PCCARD_NAME
                       ": failed to register tty driver\n");
-               put_tty_driver(ipw_tty_driver);
+               tty_driver_kref_put(ipw_tty_driver);
                return result;
        }
 
 void ipwireless_tty_release(void)
 {
        tty_unregister_driver(ipw_tty_driver);
-       put_tty_driver(ipw_tty_driver);
+       tty_driver_kref_put(ipw_tty_driver);
 }
 
 int ipwireless_tty_is_modem(struct ipw_tty *tty)
 
                dport = &priv->ports[nport];
                tty_port_destroy(&dport->port);
        }
-       put_tty_driver(priv->driver);
+       tty_driver_kref_put(priv->driver);
        return ret;
 }
 
 
 
        if (tty_register_driver(moxaDriver)) {
                printk(KERN_ERR "can't register MOXA Smartio tty driver!\n");
-               put_tty_driver(moxaDriver);
+               tty_driver_kref_put(moxaDriver);
                return -1;
        }
 
        del_timer_sync(&moxaTimer);
 
        tty_unregister_driver(moxaDriver);
-       put_tty_driver(moxaDriver);
+       tty_driver_kref_put(moxaDriver);
 }
 
 module_init(moxa_init);
 
 err_unr:
        tty_unregister_driver(mxvar_sdriver);
 err_put:
-       put_tty_driver(mxvar_sdriver);
+       tty_driver_kref_put(mxvar_sdriver);
        return retval;
 }
 
 {
        pci_unregister_driver(&mxser_driver);
        tty_unregister_driver(mxvar_sdriver);
-       put_tty_driver(mxvar_sdriver);
+       tty_driver_kref_put(mxvar_sdriver);
 }
 
 module_init(mxser_module_init);
 
                        gsm_tty_driver->major, gsm_tty_driver->minor_start);
        return 0;
 err_put_driver:
-       put_tty_driver(gsm_tty_driver);
+       tty_driver_kref_put(gsm_tty_driver);
 err_unreg_ldisc:
        tty_unregister_ldisc(&tty_ldisc_packet);
        return status;
 {
        tty_unregister_ldisc(&tty_ldisc_packet);
        tty_unregister_driver(gsm_tty_driver);
-       put_tty_driver(gsm_tty_driver);
+       tty_driver_kref_put(gsm_tty_driver);
 }
 
 module_init(gsm_init);
 
 unr_tty:
        tty_unregister_driver(ntty_driver);
 free_tty:
-       put_tty_driver(ntty_driver);
+       tty_driver_kref_put(ntty_driver);
        return ret;
 }
 
 {
        pci_unregister_driver(&nozomi_driver);
        tty_unregister_driver(ntty_driver);
-       put_tty_driver(ntty_driver);
+       tty_driver_kref_put(ntty_driver);
 }
 
 module_init(nozomi_init);
 
 
        return 0;
 err_drv_reg:
-       put_tty_driver(kgdb_nmi_tty_driver);
+       tty_driver_kref_put(kgdb_nmi_tty_driver);
        return ret;
 }
 EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);
                return ret;
 
        tty_unregister_driver(kgdb_nmi_tty_driver);
-       put_tty_driver(kgdb_nmi_tty_driver);
+       tty_driver_kref_put(kgdb_nmi_tty_driver);
 
        return 0;
 }
 
 
        for (i = 0; i < drv->nr; i++)
                tty_port_destroy(&drv->state[i].port);
-       put_tty_driver(normal);
+       tty_driver_kref_put(normal);
 out_kfree:
        kfree(drv->state);
 out:
        unsigned int i;
 
        tty_unregister_driver(p);
-       put_tty_driver(p);
+       tty_driver_kref_put(p);
        for (i = 0; i < drv->nr; i++)
                tty_port_destroy(&drv->state[i].port);
        kfree(drv->state);
 
                for (info=slgt_device_list ; info != NULL ; info=info->next_device)
                        tty_unregister_device(serial_driver, info->line);
                tty_unregister_driver(serial_driver);
-               put_tty_driver(serial_driver);
+               tty_driver_kref_put(serial_driver);
        }
 
        /* reset devices */
        tty_set_operations(serial_driver, &ops);
        if ((rc = tty_register_driver(serial_driver)) < 0) {
                DBGERR(("%s can't register serial driver\n", driver_name));
-               put_tty_driver(serial_driver);
+               tty_driver_kref_put(serial_driver);
                serial_driver = NULL;
                goto error;
        }
 
 }
 EXPORT_SYMBOL(tty_driver_kref_put);
 
-void put_tty_driver(struct tty_driver *d)
-{
-       tty_driver_kref_put(d);
-}
-EXPORT_SYMBOL(put_tty_driver);
-
 /*
  * Called by a tty driver to register itself.
  */
 
 
        ret = tty_register_driver(driver);
        if (ret < 0) {
-               put_tty_driver(driver);
+               tty_driver_kref_put(driver);
                tty_port_destroy(&ttynull_port);
                return ret;
        }
 {
        unregister_console(&ttynull_console);
        tty_unregister_driver(ttynull_driver);
-       put_tty_driver(ttynull_driver);
+       tty_driver_kref_put(ttynull_driver);
        tty_port_destroy(&ttynull_port);
 }
 
 
        rv = tty_register_driver(vcc_tty_driver);
        if (rv) {
                pr_err("VCC: TTY driver registration failed\n");
-               put_tty_driver(vcc_tty_driver);
+               tty_driver_kref_put(vcc_tty_driver);
                vcc_tty_driver = NULL;
                return rv;
        }
 static void vcc_tty_exit(void)
 {
        tty_unregister_driver(vcc_tty_driver);
-       put_tty_driver(vcc_tty_driver);
+       tty_driver_kref_put(vcc_tty_driver);
        vccdbg("VCC: TTY driver unregistered\n");
 
        vcc_tty_driver = NULL;
 
 
        retval = tty_register_driver(acm_tty_driver);
        if (retval) {
-               put_tty_driver(acm_tty_driver);
+               tty_driver_kref_put(acm_tty_driver);
                return retval;
        }
 
        retval = usb_register(&acm_driver);
        if (retval) {
                tty_unregister_driver(acm_tty_driver);
-               put_tty_driver(acm_tty_driver);
+               tty_driver_kref_put(acm_tty_driver);
                return retval;
        }
 
 {
        usb_deregister(&acm_driver);
        tty_unregister_driver(acm_tty_driver);
-       put_tty_driver(acm_tty_driver);
+       tty_driver_kref_put(acm_tty_driver);
        idr_destroy(&acm_minors);
 }
 
 
 
        return status;
 fail:
-       put_tty_driver(driver);
+       tty_driver_kref_put(driver);
        return status;
 }
 module_init(userial_init);
 static void userial_cleanup(void)
 {
        tty_unregister_driver(gs_tty_driver);
-       put_tty_driver(gs_tty_driver);
+       tty_driver_kref_put(gs_tty_driver);
        gs_tty_driver = NULL;
 }
 module_exit(userial_cleanup);
 
        ret = tty_register_driver(dbc_tty_driver);
        if (ret) {
                pr_err("Can't register dbc tty driver\n");
-               put_tty_driver(dbc_tty_driver);
+               tty_driver_kref_put(dbc_tty_driver);
        }
        return ret;
 }
 {
        if (dbc_tty_driver) {
                tty_unregister_driver(dbc_tty_driver);
-               put_tty_driver(dbc_tty_driver);
+               tty_driver_kref_put(dbc_tty_driver);
                dbc_tty_driver = NULL;
        }
 }
 
 
 exit_bus:
        pr_err("%s - returning with error %d\n", __func__, result);
-       put_tty_driver(usb_serial_tty_driver);
+       tty_driver_kref_put(usb_serial_tty_driver);
        return result;
 }
 
        usb_serial_generic_deregister();
 
        tty_unregister_driver(usb_serial_tty_driver);
-       put_tty_driver(usb_serial_tty_driver);
+       tty_driver_kref_put(usb_serial_tty_driver);
        bus_unregister(&usb_serial_bus_type);
        idr_destroy(&serial_minors);
 }
 
 
 extern struct tty_driver *__tty_alloc_driver(unsigned int lines,
                struct module *owner, unsigned long flags);
-extern void put_tty_driver(struct tty_driver *driver);
 extern struct tty_driver *tty_find_polling_driver(char *name, int *line);
 
 extern void tty_driver_kref_put(struct tty_driver *driver);
 
        error = tty_register_driver(rfcomm_tty_driver);
        if (error) {
                BT_ERR("Can't register RFCOMM TTY driver");
-               put_tty_driver(rfcomm_tty_driver);
+               tty_driver_kref_put(rfcomm_tty_driver);
                return error;
        }
 
 void rfcomm_cleanup_ttys(void)
 {
        tty_unregister_driver(rfcomm_tty_driver);
-       put_tty_driver(rfcomm_tty_driver);
+       tty_driver_kref_put(rfcomm_tty_driver);
 }