void spk_ttyio_unregister_ldisc(void)
 {
-       if (tty_unregister_ldisc(&spk_ttyio_ldisc_ops))
-               pr_warn("speakup: Couldn't unregister ldisc\n");
+       tty_unregister_ldisc(&spk_ttyio_ldisc_ops);
 }
 
 static int spk_ttyio_out(struct spk_synth *in_synth, const char ch)
 
 
 static void __exit hci_uart_exit(void)
 {
-       int err;
-
 #ifdef CONFIG_BT_HCIUART_H4
        h4_deinit();
 #endif
        mrvl_deinit();
 #endif
 
-       /* Release tty registration of line discipline */
-       err = tty_unregister_ldisc(&hci_uart_ldisc);
-       if (err)
-               BT_ERR("Can't unregister HCI line discipline (%d)", err);
+       tty_unregister_ldisc(&hci_uart_ldisc);
 }
 
 module_init(hci_uart_init);
 
        st_gdata = kzalloc(sizeof(struct st_data_s), GFP_KERNEL);
        if (!st_gdata) {
                pr_err("memory allocation failed");
-               err = tty_unregister_ldisc(&st_ldisc_ops);
-               if (err)
-                       pr_err("unable to un-register ldisc %ld", err);
+               tty_unregister_ldisc(&st_ldisc_ops);
                err = -ENOMEM;
                return err;
        }
        if (err) {
                pr_err("error during st_ll initialization(%ld)", err);
                kfree(st_gdata);
-               err = tty_unregister_ldisc(&st_ldisc_ops);
-               if (err)
-                       pr_err("unable to un-register ldisc");
+               tty_unregister_ldisc(&st_ldisc_ops);
                return err;
        }
 
                kfree_skb(st_gdata->rx_skb);
                kfree_skb(st_gdata->tx_skb);
                /* TTY ldisc cleanup */
-               err = tty_unregister_ldisc(&st_ldisc_ops);
-               if (err)
-                       pr_err("unable to un-register ldisc %ld", err);
+               tty_unregister_ldisc(&st_ldisc_ops);
                /* free the global data pointer */
                kfree(st_gdata);
        }
 
        kfree(slcan_devs);
        slcan_devs = NULL;
 
-       i = tty_unregister_ldisc(&slc_ldisc);
-       if (i)
-               printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
+       tty_unregister_ldisc(&slc_ldisc);
 }
 
 module_init(slcan_init);
 
        return status;
 }
 
-static const char msg_unregfail[] = KERN_ERR \
-       "6pack: can't unregister line discipline (err = %d)\n";
-
 static void __exit sixpack_exit_driver(void)
 {
-       int ret;
-
-       if ((ret = tty_unregister_ldisc(&sp_ldisc)))
-               printk(msg_unregfail, ret);
+       tty_unregister_ldisc(&sp_ldisc);
 }
 
 /* encode an AX.25 packet into 6pack */
 
        return status;
 }
 
-static const char msg_unregfail[] = KERN_ERR \
-       "mkiss: can't unregister line discipline (err = %d)\n";
-
 static void __exit mkiss_exit_driver(void)
 {
-       int ret;
-
-       if ((ret = tty_unregister_ldisc(&ax_ldisc)))
-               printk(msg_unregfail, ret);
+       tty_unregister_ldisc(&ax_ldisc);
 }
 
 MODULE_AUTHOR("Ralf Baechle DL5RB <ralf@linux-mips.org>");
 
 
 static void __exit ppp_async_cleanup(void)
 {
-       if (tty_unregister_ldisc(&ppp_ldisc) != 0)
-               printk(KERN_ERR "failed to unregister PPP line discipline\n");
+       tty_unregister_ldisc(&ppp_ldisc);
 }
 
 module_init(ppp_async_init);
 
 static void __exit
 ppp_sync_cleanup(void)
 {
-       if (tty_unregister_ldisc(&ppp_sync_ldisc) != 0)
-               printk(KERN_ERR "failed to unregister Sync PPP line discipline\n");
+       tty_unregister_ldisc(&ppp_sync_ldisc);
 }
 
 module_init(ppp_sync_init);
 
        kfree(slip_devs);
        slip_devs = NULL;
 
-       i = tty_unregister_ldisc(&sl_ldisc);
-       if (i != 0)
-               printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
+       tty_unregister_ldisc(&sl_ldisc);
 }
 
 module_init(slip_init);
 
 
 static void __exit pps_tty_cleanup(void)
 {
-       int err;
-
-       err = tty_unregister_ldisc(&pps_ldisc_ops);
-       if (err)
-               pr_err("can't unregister PPS line discipline\n");
-       else
-               pr_info("PPS line discipline removed\n");
+       tty_unregister_ldisc(&pps_ldisc_ops);
 }
 
 module_init(pps_tty_init);
 
 
 static void __exit gsm_exit(void)
 {
-       int status = tty_unregister_ldisc(&tty_ldisc_packet);
-       if (status != 0)
-               pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
-                                                               status);
+       tty_unregister_ldisc(&tty_ldisc_packet);
        tty_unregister_driver(gsm_tty_driver);
        put_tty_driver(gsm_tty_driver);
 }
 
 
 static void __exit n_hdlc_exit(void)
 {
-       int status = tty_unregister_ldisc(&n_hdlc_ldisc);
-
-       if (status)
-               pr_err("N_HDLC: can't unregister line discipline (err = %d)\n",
-                               status);
-       else
-               pr_info("N_HDLC: line discipline unregistered\n");
+       tty_unregister_ldisc(&n_hdlc_ldisc);
 }
 
 module_init(n_hdlc_init);
 
 {
        struct snd_soc_card *card = platform_get_drvdata(pdev);
 
-       if (tty_unregister_ldisc(&cx81801_ops) != 0)
-               dev_warn(&pdev->dev,
-                       "failed to unregister V253 line discipline\n");
+       tty_unregister_ldisc(&cx81801_ops);
 
        snd_soc_unregister_card(card);
        card->dev = NULL;