void spk_ttyio_unregister_ldisc(void)
 {
-       if (tty_unregister_ldisc(N_SPEAKUP))
+       if (tty_unregister_ldisc(&spk_ttyio_ldisc_ops))
                pr_warn("speakup: Couldn't unregister ldisc\n");
 }
 
 
 #endif
 
        /* Release tty registration of line discipline */
-       err = tty_unregister_ldisc(N_HCI);
+       err = tty_unregister_ldisc(&hci_uart_ldisc);
        if (err)
                BT_ERR("Can't unregister HCI line discipline (%d)", err);
 }
 
 
 static void __exit serport_exit(void)
 {
-       tty_unregister_ldisc(N_MOUSE);
+       tty_unregister_ldisc(&serport_ldisc);
 }
 
 module_init(serport_init);
 
        st_gdata = kzalloc(sizeof(struct st_data_s), GFP_KERNEL);
        if (!st_gdata) {
                pr_err("memory allocation failed");
-               err = tty_unregister_ldisc(N_TI_WL);
+               err = tty_unregister_ldisc(&st_ldisc_ops);
                if (err)
                        pr_err("unable to un-register ldisc %ld", err);
                err = -ENOMEM;
        if (err) {
                pr_err("error during st_ll initialization(%ld)", err);
                kfree(st_gdata);
-               err = tty_unregister_ldisc(N_TI_WL);
+               err = tty_unregister_ldisc(&st_ldisc_ops);
                if (err)
                        pr_err("unable to un-register ldisc");
                return err;
                kfree_skb(st_gdata->rx_skb);
                kfree_skb(st_gdata->tx_skb);
                /* TTY ldisc cleanup */
-               err = tty_unregister_ldisc(N_TI_WL);
+               err = tty_unregister_ldisc(&st_ldisc_ops);
                if (err)
                        pr_err("unable to un-register ldisc %ld", err);
                /* free the global data pointer */
 
        spin_unlock(&ser_lock);
        ser_release(NULL);
        cancel_work_sync(&ser_release_work);
-       tty_unregister_ldisc(N_CAIF);
+       tty_unregister_ldisc(&caif_ldisc);
        debugfs_remove_recursive(debugfsdir);
 }
 
 
        kfree(slcan_devs);
        slcan_devs = NULL;
 
-       i = tty_unregister_ldisc(N_SLCAN);
+       i = tty_unregister_ldisc(&slc_ldisc);
        if (i)
                printk(KERN_ERR "slcan: can't unregister ldisc (err %d)\n", i);
 }
 
 {
        int ret;
 
-       if ((ret = tty_unregister_ldisc(N_6PACK)))
+       if ((ret = tty_unregister_ldisc(&sp_ldisc)))
                printk(msg_unregfail, ret);
 }
 
 
 {
        int ret;
 
-       if ((ret = tty_unregister_ldisc(N_AX25)))
+       if ((ret = tty_unregister_ldisc(&ax_ldisc)))
                printk(msg_unregfail, ret);
 }
 
 
 
 static void __exit ppp_async_cleanup(void)
 {
-       if (tty_unregister_ldisc(N_PPP) != 0)
+       if (tty_unregister_ldisc(&ppp_ldisc) != 0)
                printk(KERN_ERR "failed to unregister PPP line discipline\n");
 }
 
 
 static void __exit
 ppp_sync_cleanup(void)
 {
-       if (tty_unregister_ldisc(N_SYNC_PPP) != 0)
+       if (tty_unregister_ldisc(&ppp_sync_ldisc) != 0)
                printk(KERN_ERR "failed to unregister Sync PPP line discipline\n");
 }
 
 
        kfree(slip_devs);
        slip_devs = NULL;
 
-       i = tty_unregister_ldisc(N_SLIP);
+       i = tty_unregister_ldisc(&sl_ldisc);
        if (i != 0)
                printk(KERN_ERR "SLIP: can't unregister line discipline (err = %d)\n", i);
 }
 
 {
        int err;
 
-       err = tty_unregister_ldisc(N_PPS);
+       err = tty_unregister_ldisc(&pps_ldisc_ops);
        if (err)
                pr_err("can't unregister PPS line discipline\n");
        else
 
 err_put_driver:
        put_tty_driver(gsm_tty_driver);
 err_unreg_ldisc:
-       tty_unregister_ldisc(N_GSM0710);
+       tty_unregister_ldisc(&tty_ldisc_packet);
        return status;
 }
 
 static void __exit gsm_exit(void)
 {
-       int status = tty_unregister_ldisc(N_GSM0710);
+       int status = tty_unregister_ldisc(&tty_ldisc_packet);
        if (status != 0)
                pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
                                                                status);
 
 
 static void __exit n_hdlc_exit(void)
 {
-       /* Release tty registration of line discipline */
-       int status = tty_unregister_ldisc(N_HDLC);
+       int status = tty_unregister_ldisc(&n_hdlc_ldisc);
 
        if (status)
                pr_err("N_HDLC: can't unregister line discipline (err = %d)\n",
 
 
 static void __exit n_null_exit(void)
 {
-       tty_unregister_ldisc(N_NULL);
+       tty_unregister_ldisc(&null_ldisc);
 }
 
 module_init(n_null_init);
 
  *             takes tty_ldiscs_lock to guard against ldisc races
  */
 
-int tty_unregister_ldisc(int disc)
+int tty_unregister_ldisc(struct tty_ldisc_ops *ldisc)
 {
        unsigned long flags;
        int ret = 0;
 
-       if (disc < N_TTY || disc >= NR_LDISCS)
-               return -EINVAL;
-
        raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
-       if (tty_ldiscs[disc]->refcount)
+       if (tty_ldiscs[ldisc->num]->refcount)
                ret = -EBUSY;
        else
-               tty_ldiscs[disc] = NULL;
+               tty_ldiscs[ldisc->num] = NULL;
        raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
 
        return ret;
 
 }
 
 extern int tty_register_ldisc(struct tty_ldisc_ops *new_ldisc);
-extern int tty_unregister_ldisc(int disc);
+extern int tty_unregister_ldisc(struct tty_ldisc_ops *ldisc);
 extern int tty_set_ldisc(struct tty_struct *tty, int disc);
 extern int tty_ldisc_receive_buf(struct tty_ldisc *ld, const unsigned char *p,
                                 const char *f, int count);
 
 
 static void __exit nci_uart_exit(void)
 {
-       tty_unregister_ldisc(N_NCI);
+       tty_unregister_ldisc(&nci_uart_ldisc);
 }
 
 module_init(nci_uart_init);
 
 {
        struct snd_soc_card *card = platform_get_drvdata(pdev);
 
-       if (tty_unregister_ldisc(N_V253) != 0)
+       if (tty_unregister_ldisc(&cx81801_ops) != 0)
                dev_warn(&pdev->dev,
                        "failed to unregister V253 line discipline\n");