static int __init rin_init(void)
{
int status;
if (rin_maxdev < 4)
rin_maxdev = 4; /* Sanity */
rin_devs = kzalloc(sizeof(struct net_device *)*rin_maxdev,
GFP_KERNEL);
if (!rin_devs) {
if(DEBUG) printk(KERN_ERR "RIN: Can't allocate slip devices array.\n");
return -ENOMEM;
}
/* Fill in our line protocol discipline, and register it */
status = tty_register_ldisc(N_RIN, &rin_ldisc);
if (status != 0) {
if(DEBUG) printk(KERN_ERR "RIN: can't register line discipline (err = %d)\n", status);
kfree(rin_devs);
}
if (status == 0) {
rin_tx_wq = create_singlethread_workqueue("rintx");
if (!rin_tx_wq) {
if(DEBUG) printk(KERN_ERR "RIN: failed to allocate workqueue");
tty_unregister_ldisc(N_RIN);
kfree(rin_devs);
status = -ENOMEM;
}
}
return status;
}
static int __init pps_tty_init(void)
{
int err;
/* Inherit the N_TTY's ops */
n_tty_inherit_ops(&pps_ldisc_ops);
/* Save N_TTY's open()/close() methods */
alias_n_tty_open = pps_ldisc_ops.open;
alias_n_tty_close = pps_ldisc_ops.close;
/* Init PPS_TTY data */
pps_ldisc_ops.owner = THIS_MODULE;
pps_ldisc_ops.magic = PPS_TTY_MAGIC;
pps_ldisc_ops.name = "pps_tty";
pps_ldisc_ops.dcd_change = pps_tty_dcd_change;
pps_ldisc_ops.open = pps_tty_open;
pps_ldisc_ops.close = pps_tty_close;
err = tty_register_ldisc(N_PPS, &pps_ldisc_ops);
if (err)
pr_err("can't register PPS line discipline\n");
else
pr_info("PPS line discipline registered\n");
return err;
}
static int bcmbt_tty_init(void)
{
int err;
pr_debug("%s: BLUETOOTH:\n", __func__);
/* Inherit the N_TTY's ops */
n_tty_inherit_ops(&bcmbt_ldisc_ops);
bcmbt_ldisc_ops.owner = THIS_MODULE;
bcmbt_ldisc_ops.name = "bcmbt_tty";
bcmbt_ldisc_ops.ioctl = bcmbt_tty_ioctl;
bcmbt_ldisc_saved.open = bcmbt_ldisc_ops.open;
bcmbt_ldisc_saved.close = bcmbt_ldisc_ops.close;
bcmbt_ldisc_ops.open = bcmbt_tty_open;
bcmbt_ldisc_ops.close = bcmbt_tty_close;
err = tty_register_ldisc(N_BRCM_HCI, &bcmbt_ldisc_ops);
if (err)
pr_err("can't register N_BRCM_HCI line discipline\n");
else
pr_info("N_BRCM_HCI line discipline registered\n");
pr_debug("%s BLUETOOTH:Exiting.\n", __func__);
return err;
}
int __init irtty_init(void)
{
int status;
irtty = hashbin_new( HB_LOCAL);
if ( irtty == NULL) {
printk( KERN_WARNING "IrDA: Can't allocate irtty hashbin!\n");
return -ENOMEM;
}
/* Fill in our line protocol discipline, and register it */
memset(&irda_ldisc, 0, sizeof( irda_ldisc));
irda_ldisc.magic = TTY_LDISC_MAGIC;
irda_ldisc.name = "irda";
irda_ldisc.flags = 0;
irda_ldisc.open = irtty_open;
irda_ldisc.close = irtty_close;
irda_ldisc.read = NULL;
irda_ldisc.write = NULL;
irda_ldisc.ioctl = (int (*)(struct tty_struct *, struct file *,
unsigned int, unsigned long)) irtty_ioctl;
irda_ldisc.poll = NULL;
irda_ldisc.receive_buf = irtty_receive_buf;
irda_ldisc.receive_room = irtty_receive_room;
irda_ldisc.write_wakeup = irtty_write_wakeup;
if ((status = tty_register_ldisc(N_IRDA, &irda_ldisc)) != 0) {
ERROR("IrDA: can't register line discipline (err = %d)\n",
status);
}
return status;
}
static int __init slcan_init(void)
{
int status;
if (maxdev < 4)
maxdev = 4; /* Sanity */
printk(banner);
printk(KERN_INFO "slcan: %d dynamic interface channels.\n", maxdev);
slcan_devs = kmalloc(sizeof(struct net_device *)*maxdev, GFP_KERNEL);
if (!slcan_devs) {
printk(KERN_ERR "slcan: can't allocate slcan device array!\n");
return -ENOMEM;
}
/* Clear the pointer array, we allocate devices when we need them */
memset(slcan_devs, 0, sizeof(struct net_device *)*maxdev);
/* Fill in our line protocol discipline, and register it */
status = tty_register_ldisc(N_SLCAN, &slc_ldisc);
if (status != 0) {
printk(KERN_ERR "slcan: can't register line discipline\n");
kfree(slcan_devs);
}
return status;
}
int __init n_hci_init(void)
{
static struct tty_ldisc n_hci_ldisc;
int err;
INF("BlueZ HCI UART driver ver %s Copyright (C) 2000,2001 Qualcomm Inc",
VERSION);
INF("Written 2000,2001 by Maxim Krasnyansky <*****@*****.**>");
/* Register the tty discipline */
memset(&n_hci_ldisc, 0, sizeof (n_hci_ldisc));
n_hci_ldisc.magic = TTY_LDISC_MAGIC;
n_hci_ldisc.name = "n_hci";
n_hci_ldisc.open = n_hci_tty_open;
n_hci_ldisc.close = n_hci_tty_close;
n_hci_ldisc.read = n_hci_tty_read;
n_hci_ldisc.write = n_hci_tty_write;
n_hci_ldisc.ioctl = n_hci_tty_ioctl;
n_hci_ldisc.poll = n_hci_tty_poll;
n_hci_ldisc.receive_room= n_hci_tty_room;
n_hci_ldisc.receive_buf = n_hci_tty_receive;
n_hci_ldisc.write_wakeup= n_hci_tty_wakeup;
if ((err = tty_register_ldisc(N_HCI, &n_hci_ldisc))) {
ERR("Can't register HCI line discipline (%d)", err);
return err;
}
return 0;
}
void
cleanup_module(void)
{
int i;
if (x25_asy_ctrls != NULL)
{
for (i = 0; i < x25_asy_maxdev; i++)
{
if (x25_asy_ctrls[i])
{
/*
* VSV = if dev->start==0, then device
* unregistered while close proc.
*/
if (netif_running(&(x25_asy_ctrls[i]->dev)))
unregister_netdev(&(x25_asy_ctrls[i]->dev));
kfree(x25_asy_ctrls[i]);
x25_asy_ctrls[i] = NULL;
}
}
kfree(x25_asy_ctrls);
x25_asy_ctrls = NULL;
}
if ((i = tty_register_ldisc(N_X25, NULL)))
{
printk("X.25 async: can't unregister line discipline (err = %d)\n", i);
}
}
static int __init r3964_init(void)
{
int status;
printk ("r3964: Philips r3964 Driver $Revision: 1.1.1.1 $\n");
/*
* Register the tty line discipline
*/
status = tty_register_ldisc (N_R3964, &tty_ldisc_N_R3964);
if (status == 0)
{
TRACE_L("line discipline %d registered", N_R3964);
TRACE_L("flags=%x num=%x", tty_ldisc_N_R3964.flags,
tty_ldisc_N_R3964.num);
TRACE_L("open=%x", (int)tty_ldisc_N_R3964.open);
TRACE_L("tty_ldisc_N_R3964 = %x", (int)&tty_ldisc_N_R3964);
}
else
{
printk (KERN_ERR "r3964: error registering line discipline: %d\n", status);
}
return status;
}
static void __exit exit_x25_asy(void)
{
struct net_device *dev;
int i;
for (i = 0; i < x25_asy_maxdev; i++) {
dev = x25_asy_devs[i];
if (dev) {
struct x25_asy *sl = dev->priv;
spin_lock_bh(&sl->lock);
if (sl->tty)
tty_hangup(sl->tty);
spin_unlock_bh(&sl->lock);
/*
* VSV = if dev->start==0, then device
* unregistered while close proc.
*/
unregister_netdev(dev);
free_netdev(dev);
}
}
kfree(x25_asy_devs);
tty_register_ldisc(N_X25, NULL);
}
/* module init/exit functions */
static int __init ttyhub_init(void)
{
int status;
if (max_subsys < 2)
max_subsys = 2;
if (probe_buf_size < 16)
probe_buf_size = 16;
printk(KERN_INFO "ttyhub: version %s, max. subsystems = %d, probe "
"bufsize = %d"
#ifdef DEBUG
" (debug build)"
#endif
"\n", TTYHUB_VERSION, max_subsys, probe_buf_size);
/* allocate space for pointers to subsystems and init lock */
ttyhub_subsystems = kzalloc(
sizeof(struct ttyhub_subsystem *) * max_subsys,
GFP_KERNEL);
if (ttyhub_subsystems == NULL)
return -ENOMEM;
spin_lock_init(&ttyhub_subsystems_lock);
/* register line discipline */
status = tty_register_ldisc(N_TTYHUB, &ttyhub_ldisc); // TODO dynamic LDISC nr
if (status != 0) {
kfree(ttyhub_subsystems);
printk(KERN_ERR "ttyhub: can't register line discipline "
"(err = %d)\n", status);
}
return status;
}
static int __init ld_phonet_init(void)
{
int retval;
retval = tty_register_ldisc(N_PHONET, &ld_phonet_ldisc);
return retval;
}
static int __init hci_uart_init(void)
{
static struct tty_ldisc_ops hci_uart_ldisc;
int err;
BT_INFO("HCI UART driver ver %s", VERSION);
/* Register the tty discipline */
memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
hci_uart_ldisc.name = "n_hci";
hci_uart_ldisc.open = hci_uart_tty_open;
hci_uart_ldisc.close = hci_uart_tty_close;
hci_uart_ldisc.read = hci_uart_tty_read;
hci_uart_ldisc.write = hci_uart_tty_write;
hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
hci_uart_ldisc.poll = hci_uart_tty_poll;
hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;
hci_uart_ldisc.owner = THIS_MODULE;
if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
BT_ERR("HCI line discipline registration failed. (%d)", err);
return err;
}
#ifdef CONFIG_BT_HCIUART_H4
h4_init();
#endif
#ifdef CONFIG_BT_HCIUART_BCSP
bcsp_init();
#endif
/* < DTS2012020604357 zhangyun 20120206 begin */
#if defined(CONFIG_BT_HCIUART_LL) && defined(HUAWEI_BT_BTLA_VER30)
ll_init();
#endif
/*default without Huawei modification*/
#if defined(CONFIG_BT_HCIUART_LL) && (!defined(CONFIG_HUAWEI_KERNEL))
ll_init();
#endif
/* DTS2012020604357 zhangyun 20120206 end > */
#ifdef CONFIG_BT_HCIUART_ATH3K
ath_init();
#endif
/* < DTS2012020604357 zhangyun 20120206 begin */
#if defined(CONFIG_BT_HCIUART_IBS) && defined(HUAWEI_BT_BLUEZ_VER30)
ibs_init();
#endif
/*default without Huawei modification*/
#if defined(CONFIG_BT_HCIUART_IBS) && (!defined(CONFIG_HUAWEI_KERNEL))
ibs_init();
#endif
/* DTS2012020604357 zhangyun 20120206 end > */
return 0;
}
void n_hci_cleanup(void)
{
int err;
/* Release tty registration of line discipline */
if ((err = tty_register_ldisc(N_HCI, NULL)))
ERR("Can't unregister HCI line discipline (%d)", err);
}
static int __init hci_uart_init(void)
{
static struct tty_ldisc_ops hci_uart_ldisc;
int err;
BT_INFO("HCI UART driver ver %s", VERSION);
/* Register the tty discipline */
memset(&hci_uart_ldisc, 0, sizeof(hci_uart_ldisc));
hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
hci_uart_ldisc.name = "n_hci";
hci_uart_ldisc.open = hci_uart_tty_open;
hci_uart_ldisc.close = hci_uart_tty_close;
hci_uart_ldisc.read = hci_uart_tty_read;
hci_uart_ldisc.write = hci_uart_tty_write;
hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
hci_uart_ldisc.poll = hci_uart_tty_poll;
hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;
hci_uart_ldisc.owner = THIS_MODULE;
err = tty_register_ldisc(N_HCI, &hci_uart_ldisc);
if (err) {
BT_ERR("HCI line discipline registration failed. (%d)", err);
return err;
}
#ifdef CONFIG_BT_HCIUART_H4
h4_init();
#endif
#ifdef CONFIG_BT_HCIUART_BCSP
bcsp_init();
#endif
#ifdef CONFIG_BT_HCIUART_LL
ll_init();
#endif
#ifdef CONFIG_BT_HCIUART_ATH3K
ath_init();
#endif
#ifdef CONFIG_BT_HCIUART_3WIRE
h5_init();
#endif
#ifdef CONFIG_BT_HCIUART_INTEL
intel_init();
#endif
#ifdef CONFIG_BT_HCIUART_BCM
bcm_init();
#endif
#ifdef CONFIG_BT_HCIUART_QCA
qca_init();
#endif
#ifdef CONFIG_BT_HCIUART_AG6XX
ag6xx_init();
#endif
return 0;
}
static void __exit n_hdlc_exit(void)
{
int status;
/* Release tty registration of line discipline */
if ((status = tty_register_ldisc(N_HDLC, NULL)))
printk("N_HDLC: can't unregister line discipline (err = %d)\n", status);
else
printk("N_HDLC: line discipline unregistered\n");
}
int __init serport_init(void)
{
if (tty_register_ldisc(N_MOUSE, &serport_ldisc)) {
printk(KERN_ERR "serport.c: Error registering line discipline.\n");
return -ENODEV;
}
return 0;
}
static int __init serport_init(void)
{
int retval;
retval = tty_register_ldisc(N_MOUSE, &serport_ldisc);
if (retval)
printk(KERN_ERR "serport.c: Error registering line discipline.\n");
return retval;
}
static int __init hci_uart_init(void)
{
static struct tty_ldisc_ops hci_uart_ldisc;
int err;
BT_INFO("HCI UART driver ver %s", VERSION);
/* Register the tty discipline */
memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
hci_uart_ldisc.name = "n_hci";
hci_uart_ldisc.open = hci_uart_tty_open;
hci_uart_ldisc.close = hci_uart_tty_close;
hci_uart_ldisc.read = hci_uart_tty_read;
hci_uart_ldisc.write = hci_uart_tty_write;
hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
hci_uart_ldisc.poll = hci_uart_tty_poll;
hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;
hci_uart_ldisc.owner = THIS_MODULE;
if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
BT_ERR("HCI line discipline registration failed. (%d)", err);
return err;
}
#ifdef CONFIG_BT_HCIUART_H4
h4_init();
#endif
/*
#ifdef CONFIG_BT_HCIUART_BCSP
bcsp_init();
#endif
#ifdef CONFIG_BT_HCIUART_LL
ll_init();
#endif
#ifdef CONFIG_BT_HCIUART_ATH3K
ath_init();
#endif
*/
//Realtek_add_start
//add realtek h5 support
//#ifdef CONFIG_BT_HCIUART_RTKH5
h5_init();
//#endif
//Realtek_add_end
#ifdef BTCOEX
rtk_uart_coex_init();
#endif
return 0;
}
static int ams_delta_cx20442_init(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_dai *codec_dai = rtd->codec_dai;
struct snd_soc_card *card = rtd->card;
struct snd_soc_dapm_context *dapm = &card->dapm;
int ret;
/* Codec is ready, now add/activate board specific controls */
/* Store a pointer to the codec structure for tty ldisc use */
cx20442_codec = rtd->codec;
/* Set up digital mute if not provided by the codec */
if (!codec_dai->driver->ops) {
codec_dai->driver->ops = &ams_delta_dai_ops;
} else {
ams_delta_ops.startup = ams_delta_startup;
ams_delta_ops.shutdown = ams_delta_shutdown;
}
/* Add hook switch - can be used to control the codec from userspace
* even if line discipline fails */
ret = snd_soc_jack_new(rtd->codec, "hook_switch",
SND_JACK_HEADSET, &ams_delta_hook_switch);
if (ret)
dev_warn(card->dev,
"Failed to allocate resources for hook switch, "
"will continue without one.\n");
else {
ret = snd_soc_jack_add_gpios(&ams_delta_hook_switch,
ARRAY_SIZE(ams_delta_hook_switch_gpios),
ams_delta_hook_switch_gpios);
if (ret)
dev_warn(card->dev,
"Failed to set up hook switch GPIO line, "
"will continue with hook switch inactive.\n");
}
/* Register optional line discipline for over the modem control */
ret = tty_register_ldisc(N_V253, &cx81801_ops);
if (ret) {
dev_warn(card->dev,
"Failed to register line discipline, "
"will continue without any controls.\n");
return 0;
}
/* Set up initial pin constellation */
snd_soc_dapm_disable_pin(dapm, "Mouthpiece");
snd_soc_dapm_disable_pin(dapm, "Speaker");
snd_soc_dapm_disable_pin(dapm, "AGCIN");
snd_soc_dapm_disable_pin(dapm, "AGCOUT");
return 0;
}
int lunix_ldisc_init(void)
{
int ret;
//debug("initializing lunix ldisc\n");
atomic_set(&lunix_disc_available, 1);
ret = tty_register_ldisc(N_LUNIX_LDISC, &lunix_ldisc_ops);
if (ret)
printk(KERN_ERR "%s: Error registering line discipline, ret = %d.\n", __FILE__, ret);
//debug("leaving with ret = %d\n", ret);
return ret;
}
static int __init port_relay_init(void)
{
int retval;
retval = tty_register_ldisc(N_MOUSE, &port_ldisc);
if (retval)
printk(KERN_ERR "port_relay.c: Error registering line discipline.\n");
#ifdef CONFIG_PROC_FS
proc_create("tty/ttyUSB", 0, NULL, &tty_usb_proc_fops);
#endif
gs_tty_driver = NULL;
return retval;
}
int st_core_init(struct st_data_s **core_data)
{
struct st_data_s *st_gdata;
long err;
err = tty_register_ldisc(N_TI_WL, &st_ldisc_ops);
if (err) {
pr_err("error registering %d line discipline %ld",
N_TI_WL, err);
return err;
}
pr_debug("registered n_shared line discipline");
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);
if (err)
pr_err("unable to un-register ldisc %ld", err);
err = -ENOMEM;
return err;
}
/* Initialize ST TxQ and Tx waitQ queue head. All BT/FM/GPS module skb's
* will be pushed in this queue for actual transmission.
*/
skb_queue_head_init(&st_gdata->txq);
skb_queue_head_init(&st_gdata->tx_waitq);
/* Locking used in st_int_enqueue() to avoid multiple execution */
spin_lock_init(&st_gdata->lock);
spin_lock_init(&st_gdata->pm_lock);
/* Power Management protection mechanism w.r.t. RX queue activity */
wake_lock_init(&st_gdata->wake_lock, WAKE_LOCK_SUSPEND,
ST_PM_PROTECT_WAKE_LOCK_NAME);
err = st_ll_init(st_gdata);
if (err) {
pr_err("error during st_ll initialization(%ld)", err);
wake_lock_destroy(&st_gdata->wake_lock);
kfree(st_gdata);
err = tty_unregister_ldisc(N_TI_WL);
if (err)
pr_err("unable to un-register ldisc");
return err;
}
*core_data = st_gdata;
return 0;
}
static int __init brickpi_init(void)
{
int err;
err = tty_register_ldisc(N_BRICKPI, &brickpi_ldisc);
if (err) {
pr_err("Could not register BrickPi line discipline. (%d)\n",
err);
return err;
}
pr_info("Registered BrickPi line discipline. (%d)\n", N_BRICKPI);
return 0;
}
void hci_uart_cleanup(void)
{
int err;
#ifdef CONFIG_BLUEZ_HCIUART_H4
h4_deinit();
#endif
#ifdef CONFIG_BLUEZ_HCIUART_BCSP
bcsp_deinit();
#endif
/* Release tty registration of line discipline */
if ((err = tty_register_ldisc(N_HCI, NULL)))
BT_ERR("Can't unregister HCI line discipline (%d)", err);
}
static int __init init_x25_asy(void)
{
if (x25_asy_maxdev < 4)
x25_asy_maxdev = 4; /* Sanity */
pr_info("X.25 async: version 0.00 ALPHA (dynamic channels, max=%d)\n",
x25_asy_maxdev);
x25_asy_devs = kcalloc(x25_asy_maxdev, sizeof(struct net_device *),
GFP_KERNEL);
if (!x25_asy_devs)
return -ENOMEM;
return tty_register_ldisc(N_X25, &x25_ldisc);
}
static int __init ev3_uart_init(void)
{
int err;
err = tty_register_ldisc(N_LEGOEV3, &ev3_uart_ldisc);
if (err) {
pr_err("Could not register EV3 UART sensor line discipline. (%d)\n",
err);
return err;
}
pr_info("Registered EV3 UART sensor line discipline. (%d)\n", N_LEGOEV3);
return 0;
}
int st_core_init(struct st_data_s **core_data)
{
struct st_data_s *st_gdata;
long err;
err = tty_register_ldisc(N_TI_WL, &st_ldisc_ops);
if (err) {
pr_err("error registering %d line discipline %ld",
N_TI_WL, err);
return err;
}
pr_debug("registered n_shared line discipline");
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);
if (err)
pr_err("unable to un-register ldisc %ld", err);
err = -ENOMEM;
return err;
}
/* Initialize ST TxQ and Tx waitQ queue head. All BT/FM/GPS module skb's
* will be pushed in this queue for actual transmission.
*/
skb_queue_head_init(&st_gdata->txq);
skb_queue_head_init(&st_gdata->tx_waitq);
/* Locking used in st_int_enqueue() to avoid multiple execution */
spin_lock_init(&st_gdata->lock);
err = st_ll_init(st_gdata);
if (err) {
pr_err("error during st_ll initialization(%ld)", err);
kfree(st_gdata);
err = tty_unregister_ldisc(N_TI_WL);
if (err)
pr_err("unable to un-register ldisc");
return err;
}
INIT_WORK(&st_gdata->work_write_wakeup, work_fn_write_wakeup);
*core_data = st_gdata;
return 0;
}
static int __init init_x25_asy(void)
{
if (x25_asy_maxdev < 4)
x25_asy_maxdev = 4; /* Sanity */
pr_info("X.25 async: version 0.00 ALPHA (dynamic channels, max=%d)\n",
x25_asy_maxdev);
x25_asy_devs = kcalloc(x25_asy_maxdev, sizeof(struct net_device *),
GFP_KERNEL);
if (!x25_asy_devs) {
pr_warn("Can't allocate x25_asy_ctrls[] array! Uaargh! (-> No X.25 available)\n");
return -ENOMEM;
}
return tty_register_ldisc(N_X25, &x25_ldisc);
}
static void irtty_cleanup(void)
{
int ret;
/* Unregister tty line-discipline */
if ((ret = tty_register_ldisc(N_IRDA, NULL))) {
ERROR("%s(), can't unregister line discipline (err = %d)\n",
__FUNCTION__, ret);
}
/*
* The TTY should care of deallocating the instances by using the
* callback to irtty_close(), therefore we do give any deallocation
* function to hashbin_destroy().
*/
hashbin_delete(irtty, NULL);
}
/**
* n_tracerouter_init - module initialisation
*
* Registers this module as a line discipline driver.
*
* Return:
* 0 for success, any other value error.
*/
static int __init n_tracerouter_init(void)
{
int retval;
tr_data = kzalloc(sizeof(struct tracerouter_data), GFP_KERNEL);
if (tr_data == NULL)
return -ENOMEM;
/* Note N_TRACEROUTER is defined in linux/tty.h */
retval = tty_register_ldisc(N_TRACEROUTER, &tty_ptirouter_ldisc);
if (retval < 0) {
pr_err("%s: Registration failed: %d\n", __func__, retval);
kfree(tr_data);
}
return retval;
}