[mirror_ubuntu-bionic-kernel.git] / drivers / isdn / mISDN / core.c

/*
 * Copyright 2008  by Karsten Keil <kkeil@novell.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/slab.h>
#include <linux/types.h>
#include <linux/stddef.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/mISDNif.h>
#include "core.h"

static u_int debug;

MODULE_AUTHOR("Karsten Keil");
MODULE_LICENSE("GPL");
module_param(debug, uint, S_IRUGO | S_IWUSR);

static u64		device_ids;
#define MAX_DEVICE_ID	63

static LIST_HEAD(Bprotocols);
static DEFINE_RWLOCK(bp_lock);

static void mISDN_dev_release(struct device *dev)
{
	/* nothing to do: the device is part of its parent's data structure */
}

static ssize_t id_show(struct device *dev,
		       struct device_attribute *attr, char *buf)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);

	if (!mdev)
		return -ENODEV;
	return sprintf(buf, "%d\n", mdev->id);
}
static DEVICE_ATTR_RO(id);

static ssize_t nrbchan_show(struct device *dev,
			    struct device_attribute *attr, char *buf)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);

	if (!mdev)
		return -ENODEV;
	return sprintf(buf, "%d\n", mdev->nrbchan);
}
static DEVICE_ATTR_RO(nrbchan);

static ssize_t d_protocols_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);

	if (!mdev)
		return -ENODEV;
	return sprintf(buf, "%d\n", mdev->Dprotocols);
}
static DEVICE_ATTR_RO(d_protocols);

static ssize_t b_protocols_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);

	if (!mdev)
		return -ENODEV;
	return sprintf(buf, "%d\n", mdev->Bprotocols | get_all_Bprotocols());
}
static DEVICE_ATTR_RO(b_protocols);

static ssize_t protocol_show(struct device *dev,
			     struct device_attribute *attr, char *buf)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);

	if (!mdev)
		return -ENODEV;
	return sprintf(buf, "%d\n", mdev->D.protocol);
}
static DEVICE_ATTR_RO(protocol);

static ssize_t name_show(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	strcpy(buf, dev_name(dev));
	return strlen(buf);
}
static DEVICE_ATTR_RO(name);

#if 0 /* hangs */
static ssize_t name_set(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
{
	int err = 0;
	char *out = kmalloc(count + 1, GFP_KERNEL);

	if (!out)
		return -ENOMEM;

	memcpy(out, buf, count);
	if (count && out[count - 1] == '\n')
		out[--count] = 0;
	if (count)
		err = device_rename(dev, out);
	kfree(out);

	return (err < 0) ? err : count;
}
static DEVICE_ATTR_RW(name);
#endif

static ssize_t channelmap_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	char *bp = buf;
	int i;

	for (i = 0; i <= mdev->nrbchan; i++)
		*bp++ = test_channelmap(i, mdev->channelmap) ? '1' : '0';

	return bp - buf;
}
static DEVICE_ATTR_RO(channelmap);

static struct attribute *mISDN_attrs[] = {
	&dev_attr_id.attr,
	&dev_attr_d_protocols.attr,
	&dev_attr_b_protocols.attr,
	&dev_attr_protocol.attr,
	&dev_attr_channelmap.attr,
	&dev_attr_nrbchan.attr,
	&dev_attr_name.attr,
	NULL,
};
ATTRIBUTE_GROUPS(mISDN);

static int mISDN_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);

	if (!mdev)
		return 0;

	if (add_uevent_var(env, "nchans=%d", mdev->nrbchan))
		return -ENOMEM;

	return 0;
}

static void mISDN_class_release(struct class *cls)
{
	/* do nothing, it's static */
}

static struct class mISDN_class = {
	.name = "mISDN",
	.owner = THIS_MODULE,
	.dev_uevent = mISDN_uevent,
	.dev_groups = mISDN_groups,
	.dev_release = mISDN_dev_release,
	.class_release = mISDN_class_release,
};

static int
_get_mdevice(struct device *dev, const void *id)
{
	struct mISDNdevice *mdev = dev_to_mISDN(dev);

	if (!mdev)
		return 0;
	if (mdev->id != *(const u_int *)id)
		return 0;
	return 1;
}

struct mISDNdevice
*get_mdevice(u_int id)
{
	return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id,
					      _get_mdevice));
}

static int
_get_mdevice_count(struct device *dev, void *cnt)
{
	*(int *)cnt += 1;
	return 0;
}

int
get_mdevice_count(void)
{
	int cnt = 0;

	class_for_each_device(&mISDN_class, NULL, &cnt, _get_mdevice_count);
	return cnt;
}

static int
get_free_devid(void)
{
	u_int	i;

	for (i = 0; i <= MAX_DEVICE_ID; i++)
		if (!test_and_set_bit(i, (u_long *)&device_ids))
			break;
	if (i > MAX_DEVICE_ID)
		return -EBUSY;
	return i;
}

int
mISDN_register_device(struct mISDNdevice *dev,
		      struct device *parent, char *name)
{
	int	err;

	err = get_free_devid();
	if (err < 0)
		goto error1;
	dev->id = err;

	device_initialize(&dev->dev);
	if (name && name[0])
		dev_set_name(&dev->dev, "%s", name);
	else
		dev_set_name(&dev->dev, "mISDN%d", dev->id);
	if (debug & DEBUG_CORE)
		printk(KERN_DEBUG "mISDN_register %s %d\n",
		       dev_name(&dev->dev), dev->id);
	err = create_stack(dev);
	if (err)
		goto error1;

	dev->dev.class = &mISDN_class;
	dev->dev.platform_data = dev;
	dev->dev.parent = parent;
	dev_set_drvdata(&dev->dev, dev);

	err = device_add(&dev->dev);
	if (err)
		goto error3;
	return 0;

error3:
	delete_stack(dev);
	return err;
error1:
	return err;

}
EXPORT_SYMBOL(mISDN_register_device);

void
mISDN_unregister_device(struct mISDNdevice *dev) {
	if (debug & DEBUG_CORE)
		printk(KERN_DEBUG "mISDN_unregister %s %d\n",
		       dev_name(&dev->dev), dev->id);
	/* sysfs_remove_link(&dev->dev.kobj, "device"); */
	device_del(&dev->dev);
	dev_set_drvdata(&dev->dev, NULL);

	test_and_clear_bit(dev->id, (u_long *)&device_ids);
	delete_stack(dev);
	put_device(&dev->dev);
}
EXPORT_SYMBOL(mISDN_unregister_device);

u_int
get_all_Bprotocols(void)
{
	struct Bprotocol	*bp;
	u_int	m = 0;

	read_lock(&bp_lock);
	list_for_each_entry(bp, &Bprotocols, list)
		m |= bp->Bprotocols;
	read_unlock(&bp_lock);
	return m;
}

struct Bprotocol *
get_Bprotocol4mask(u_int m)
{
	struct Bprotocol	*bp;

	read_lock(&bp_lock);
	list_for_each_entry(bp, &Bprotocols, list)
		if (bp->Bprotocols & m) {
			read_unlock(&bp_lock);
			return bp;
		}
	read_unlock(&bp_lock);
	return NULL;
}

struct Bprotocol *
get_Bprotocol4id(u_int id)
{
	u_int	m;

	if (id < ISDN_P_B_START || id > 63) {
		printk(KERN_WARNING "%s id not in range  %d\n",
		       __func__, id);
		return NULL;
	}
	m = 1 << (id & ISDN_P_B_MASK);
	return get_Bprotocol4mask(m);
}

int
mISDN_register_Bprotocol(struct Bprotocol *bp)
{
	u_long			flags;
	struct Bprotocol	*old;

	if (debug & DEBUG_CORE)
		printk(KERN_DEBUG "%s: %s/%x\n", __func__,
		       bp->name, bp->Bprotocols);
	old = get_Bprotocol4mask(bp->Bprotocols);
	if (old) {
		printk(KERN_WARNING
		       "register duplicate protocol old %s/%x new %s/%x\n",
		       old->name, old->Bprotocols, bp->name, bp->Bprotocols);
		return -EBUSY;
	}
	write_lock_irqsave(&bp_lock, flags);
	list_add_tail(&bp->list, &Bprotocols);
	write_unlock_irqrestore(&bp_lock, flags);
	return 0;
}
EXPORT_SYMBOL(mISDN_register_Bprotocol);

void
mISDN_unregister_Bprotocol(struct Bprotocol *bp)
{
	u_long	flags;

	if (debug & DEBUG_CORE)
		printk(KERN_DEBUG "%s: %s/%x\n", __func__, bp->name,
		       bp->Bprotocols);
	write_lock_irqsave(&bp_lock, flags);
	list_del(&bp->list);
	write_unlock_irqrestore(&bp_lock, flags);
}
EXPORT_SYMBOL(mISDN_unregister_Bprotocol);

static const char *msg_no_channel = "<no channel>";
static const char *msg_no_stack = "<no stack>";
static const char *msg_no_stackdev = "<no stack device>";

const char *mISDNDevName4ch(struct mISDNchannel *ch)
{
	if (!ch)
		return msg_no_channel;
	if (!ch->st)
		return msg_no_stack;
	if (!ch->st->dev)
		return msg_no_stackdev;
	return dev_name(&ch->st->dev->dev);
};
EXPORT_SYMBOL(mISDNDevName4ch);

static int
mISDNInit(void)
{
	int	err;

	printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n",
	       MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE);
	mISDN_init_clock(&debug);
	mISDN_initstack(&debug);
	err = class_register(&mISDN_class);
	if (err)
		goto error1;
	err = mISDN_inittimer(&debug);
	if (err)
		goto error2;
	err = l1_init(&debug);
	if (err)
		goto error3;
	err = Isdnl2_Init(&debug);
	if (err)
		goto error4;
	err = misdn_sock_init(&debug);
	if (err)
		goto error5;
	return 0;

error5:
	Isdnl2_cleanup();
error4:
	l1_cleanup();
error3:
	mISDN_timer_cleanup();
error2:
	class_unregister(&mISDN_class);
error1:
	return err;
}

static void mISDN_cleanup(void)
{
	misdn_sock_cleanup();
	Isdnl2_cleanup();
	l1_cleanup();
	mISDN_timer_cleanup();
	class_unregister(&mISDN_class);

	printk(KERN_DEBUG "mISDNcore unloaded\n");
}

module_init(mISDNInit);
module_exit(mISDN_cleanup);
Commit	Line	Data
1b2b03f8 KK	1	/*
	2	* Copyright 2008 by Karsten Keil <kkeil@novell.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	*/
	14
5a0e3ad6	15	#include <linux/slab.h>
1b2b03f8 KK	16	#include <linux/types.h>
	17	#include <linux/stddef.h>
	18	#include <linux/module.h>
	19	#include <linux/spinlock.h>
	20	#include <linux/mISDNif.h>
	21	#include "core.h"
	22
	23	static u_int debug;
	24
	25	MODULE_AUTHOR("Karsten Keil");
	26	MODULE_LICENSE("GPL");
	27	module_param(debug, uint, S_IRUGO \| S_IWUSR);
	28
1b2b03f8 KK	29	static u64 device_ids;
	30	#define MAX_DEVICE_ID 63
	31
	32	static LIST_HEAD(Bprotocols);
5b834354	33	static DEFINE_RWLOCK(bp_lock);
1b2b03f8	34
b36b654a MU	35	static void mISDN_dev_release(struct device *dev)
	36	{
	37	/* nothing to do: the device is part of its parent's data structure */
	38	}
	39
d98259cb GKH	40	static ssize_t id_show(struct device *dev,
d98259cb GKH	41	struct device_attribute attr, char buf)
b36b654a MU	42	{
	43	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	44
	45	if (!mdev)
	46	return -ENODEV;
	47	return sprintf(buf, "%d\n", mdev->id);
	48	}
d98259cb	49	static DEVICE_ATTR_RO(id);
b36b654a	50
d98259cb GKH	51	static ssize_t nrbchan_show(struct device *dev,
d98259cb GKH	52	struct device_attribute attr, char buf)
b36b654a MU	53	{
	54	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	55
	56	if (!mdev)
	57	return -ENODEV;
	58	return sprintf(buf, "%d\n", mdev->nrbchan);
	59	}
d98259cb	60	static DEVICE_ATTR_RO(nrbchan);
b36b654a	61
d98259cb GKH	62	static ssize_t d_protocols_show(struct device *dev,
d98259cb GKH	63	struct device_attribute attr, char buf)
b36b654a MU	64	{
	65	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	66
	67	if (!mdev)
	68	return -ENODEV;
	69	return sprintf(buf, "%d\n", mdev->Dprotocols);
	70	}
d98259cb	71	static DEVICE_ATTR_RO(d_protocols);
b36b654a	72
d98259cb GKH	73	static ssize_t b_protocols_show(struct device *dev,
d98259cb GKH	74	struct device_attribute attr, char buf)
b36b654a MU	75	{
	76	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	77
	78	if (!mdev)
	79	return -ENODEV;
	80	return sprintf(buf, "%d\n", mdev->Bprotocols \| get_all_Bprotocols());
	81	}
d98259cb	82	static DEVICE_ATTR_RO(b_protocols);
b36b654a	83
d98259cb GKH	84	static ssize_t protocol_show(struct device *dev,
d98259cb GKH	85	struct device_attribute attr, char buf)
b36b654a MU	86	{
	87	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	88
	89	if (!mdev)
	90	return -ENODEV;
	91	return sprintf(buf, "%d\n", mdev->D.protocol);
	92	}
d98259cb	93	static DEVICE_ATTR_RO(protocol);
b36b654a	94
d98259cb GKH	95	static ssize_t name_show(struct device *dev,
d98259cb GKH	96	struct device_attribute attr, char buf)
b36b654a MU	97	{
	98	strcpy(buf, dev_name(dev));
	99	return strlen(buf);
	100	}
d98259cb	101	static DEVICE_ATTR_RO(name);
b36b654a MU	102
b36b654a MU	103	#if 0 /* hangs */
d98259cb GKH	104	static ssize_t name_set(struct device dev, struct device_attribute attr,
d98259cb GKH	105	const char *buf, size_t count)
b36b654a MU	106	{
	107	int err = 0;
	108	char *out = kmalloc(count + 1, GFP_KERNEL);
	109
	110	if (!out)
	111	return -ENOMEM;
	112
	113	memcpy(out, buf, count);
	114	if (count && out[count - 1] == '\n')
	115	out[--count] = 0;
	116	if (count)
	117	err = device_rename(dev, out);
	118	kfree(out);
	119
	120	return (err < 0) ? err : count;
	121	}
d98259cb	122	static DEVICE_ATTR_RW(name);
b36b654a MU	123	#endif
b36b654a MU	124
d98259cb GKH	125	static ssize_t channelmap_show(struct device *dev,
d98259cb GKH	126	struct device_attribute attr, char buf)
b36b654a MU	127	{
	128	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	129	char *bp = buf;
	130	int i;
	131
	132	for (i = 0; i <= mdev->nrbchan; i++)
	133	*bp++ = test_channelmap(i, mdev->channelmap) ? '1' : '0';
	134
	135	return bp - buf;
	136	}
d98259cb GKH	137	static DEVICE_ATTR_RO(channelmap);
	138
	139	static struct attribute *mISDN_attrs[] = {
	140	&dev_attr_id.attr,
	141	&dev_attr_d_protocols.attr,
	142	&dev_attr_b_protocols.attr,
	143	&dev_attr_protocol.attr,
	144	&dev_attr_channelmap.attr,
	145	&dev_attr_nrbchan.attr,
	146	&dev_attr_name.attr,
	147	NULL,
b36b654a	148	};
d98259cb	149	ATTRIBUTE_GROUPS(mISDN);
b36b654a	150
b36b654a MU	151	static int mISDN_uevent(struct device dev, struct kobj_uevent_env env)
	152	{
	153	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	154
	155	if (!mdev)
	156	return 0;
	157
	158	if (add_uevent_var(env, "nchans=%d", mdev->nrbchan))
	159	return -ENOMEM;
	160
	161	return 0;
	162	}
b36b654a MU	163
	164	static void mISDN_class_release(struct class *cls)
	165	{
	166	/* do nothing, it's static */
	167	}
	168
	169	static struct class mISDN_class = {
	170	.name = "mISDN",
	171	.owner = THIS_MODULE,
b36b654a	172	.dev_uevent = mISDN_uevent,
d98259cb	173	.dev_groups = mISDN_groups,
b36b654a MU	174	.dev_release = mISDN_dev_release,
	175	.class_release = mISDN_class_release,
	176	};
	177
	178	static int
9f3b795a	179	_get_mdevice(struct device dev, const void id)
b36b654a MU	180	{
	181	struct mISDNdevice *mdev = dev_to_mISDN(dev);
	182
	183	if (!mdev)
	184	return 0;
9f3b795a	185	if (mdev->id != (const u_int )id)
b36b654a MU	186	return 0;
	187	return 1;
	188	}
	189
1b2b03f8 KK	190	struct mISDNdevice
	191	*get_mdevice(u_int id)
	192	{
b36b654a	193	return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id,
475be4d8	194	_get_mdevice));
b36b654a	195	}
1b2b03f8	196
b36b654a MU	197	static int
	198	_get_mdevice_count(struct device dev, void cnt)
	199	{
	200	(int )cnt += 1;
	201	return 0;
1b2b03f8 KK	202	}
	203
	204	int
	205	get_mdevice_count(void)
	206	{
b36b654a	207	int cnt = 0;
1b2b03f8	208
b36b654a	209	class_for_each_device(&mISDN_class, NULL, &cnt, _get_mdevice_count);
1b2b03f8 KK	210	return cnt;
	211	}
	212
	213	static int
	214	get_free_devid(void)
	215	{
	216	u_int i;
	217
	218	for (i = 0; i <= MAX_DEVICE_ID; i++)
	219	if (!test_and_set_bit(i, (u_long *)&device_ids))
b36b654a MU	220	break;
b36b654a MU	221	if (i > MAX_DEVICE_ID)
ddacd14e	222	return -EBUSY;
b36b654a	223	return i;
1b2b03f8 KK	224	}
	225
	226	int
b36b654a	227	mISDN_register_device(struct mISDNdevice *dev,
475be4d8	228	struct device parent, char name)
1b2b03f8	229	{
1b2b03f8 KK	230	int err;
1b2b03f8 KK	231
ddacd14e RK	232	err = get_free_devid();
ddacd14e RK	233	if (err < 0)
b36b654a	234	goto error1;
ddacd14e	235	dev->id = err;
b36b654a MU	236
b36b654a MU	237	device_initialize(&dev->dev);
1b2b03f8	238	if (name && name[0])
837468d1	239	dev_set_name(&dev->dev, "%s", name);
1b2b03f8	240	else
837468d1	241	dev_set_name(&dev->dev, "mISDN%d", dev->id);
1b2b03f8 KK	242	if (debug & DEBUG_CORE)
1b2b03f8 KK	243	printk(KERN_DEBUG "mISDN_register %s %d\n",
475be4d8	244	dev_name(&dev->dev), dev->id);
1b2b03f8 KK	245	err = create_stack(dev);
1b2b03f8 KK	246	if (err)
b36b654a MU	247	goto error1;
	248
	249	dev->dev.class = &mISDN_class;
	250	dev->dev.platform_data = dev;
	251	dev->dev.parent = parent;
	252	dev_set_drvdata(&dev->dev, dev);
	253
	254	err = device_add(&dev->dev);
	255	if (err)
	256	goto error3;
1b2b03f8	257	return 0;
b36b654a MU	258
	259	error3:
	260	delete_stack(dev);
	261	return err;
	262	error1:
	263	return err;
	264
1b2b03f8 KK	265	}
	266	EXPORT_SYMBOL(mISDN_register_device);
	267
	268	void
	269	mISDN_unregister_device(struct mISDNdevice *dev) {
1b2b03f8 KK	270	if (debug & DEBUG_CORE)
1b2b03f8 KK	271	printk(KERN_DEBUG "mISDN_unregister %s %d\n",
475be4d8	272	dev_name(&dev->dev), dev->id);
b36b654a MU	273	/* sysfs_remove_link(&dev->dev.kobj, "device"); */
	274	device_del(&dev->dev);
	275	dev_set_drvdata(&dev->dev, NULL);
	276
1b2b03f8 KK	277	test_and_clear_bit(dev->id, (u_long *)&device_ids);
1b2b03f8 KK	278	delete_stack(dev);
b36b654a	279	put_device(&dev->dev);
1b2b03f8 KK	280	}
	281	EXPORT_SYMBOL(mISDN_unregister_device);
	282
	283	u_int
	284	get_all_Bprotocols(void)
	285	{
	286	struct Bprotocol *bp;
	287	u_int m = 0;
	288
	289	read_lock(&bp_lock);
	290	list_for_each_entry(bp, &Bprotocols, list)
	291	m \|= bp->Bprotocols;
	292	read_unlock(&bp_lock);
	293	return m;
	294	}
	295
	296	struct Bprotocol *
	297	get_Bprotocol4mask(u_int m)
	298	{
	299	struct Bprotocol *bp;
	300
	301	read_lock(&bp_lock);
	302	list_for_each_entry(bp, &Bprotocols, list)
	303	if (bp->Bprotocols & m) {
	304	read_unlock(&bp_lock);
	305	return bp;
	306	}
	307	read_unlock(&bp_lock);
	308	return NULL;
	309	}
	310
	311	struct Bprotocol *
	312	get_Bprotocol4id(u_int id)
	313	{
	314	u_int m;
	315
	316	if (id < ISDN_P_B_START \|\| id > 63) {
	317	printk(KERN_WARNING "%s id not in range %d\n",
475be4d8	318	__func__, id);
1b2b03f8 KK	319	return NULL;
	320	}
	321	m = 1 << (id & ISDN_P_B_MASK);
	322	return get_Bprotocol4mask(m);
	323	}
	324
	325	int
	326	mISDN_register_Bprotocol(struct Bprotocol *bp)
	327	{
	328	u_long flags;
	329	struct Bprotocol *old;
	330
	331	if (debug & DEBUG_CORE)
	332	printk(KERN_DEBUG "%s: %s/%x\n", __func__,
475be4d8	333	bp->name, bp->Bprotocols);
1b2b03f8 KK	334	old = get_Bprotocol4mask(bp->Bprotocols);
	335	if (old) {
	336	printk(KERN_WARNING
475be4d8 JP	337	"register duplicate protocol old %s/%x new %s/%x\n",
475be4d8 JP	338	old->name, old->Bprotocols, bp->name, bp->Bprotocols);
1b2b03f8 KK	339	return -EBUSY;
	340	}
	341	write_lock_irqsave(&bp_lock, flags);
	342	list_add_tail(&bp->list, &Bprotocols);
	343	write_unlock_irqrestore(&bp_lock, flags);
	344	return 0;
	345	}
	346	EXPORT_SYMBOL(mISDN_register_Bprotocol);
	347
	348	void
	349	mISDN_unregister_Bprotocol(struct Bprotocol *bp)
	350	{
	351	u_long flags;
	352
	353	if (debug & DEBUG_CORE)
	354	printk(KERN_DEBUG "%s: %s/%x\n", __func__, bp->name,
475be4d8	355	bp->Bprotocols);
1b2b03f8 KK	356	write_lock_irqsave(&bp_lock, flags);
	357	list_del(&bp->list);
	358	write_unlock_irqrestore(&bp_lock, flags);
	359	}
	360	EXPORT_SYMBOL(mISDN_unregister_Bprotocol);
	361
f45ebf3a KK	362	static const char *msg_no_channel = "<no channel>";
	363	static const char *msg_no_stack = "<no stack>";
	364	static const char *msg_no_stackdev = "<no stack device>";
	365
	366	const char mISDNDevName4ch(struct mISDNchannel ch)
	367	{
	368	if (!ch)
	369	return msg_no_channel;
	370	if (!ch->st)
	371	return msg_no_stack;
	372	if (!ch->st->dev)
	373	return msg_no_stackdev;
	374	return dev_name(&ch->st->dev->dev);
	375	};
	376	EXPORT_SYMBOL(mISDNDevName4ch);
	377
5b834354	378	static int
1b2b03f8 KK	379	mISDNInit(void)
	380	{
	381	int err;
	382
	383	printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n",
475be4d8	384	MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE);
3bd69ad1	385	mISDN_init_clock(&debug);
1b2b03f8	386	mISDN_initstack(&debug);
b36b654a MU	387	err = class_register(&mISDN_class);
	388	if (err)
	389	goto error1;
1b2b03f8 KK	390	err = mISDN_inittimer(&debug);
1b2b03f8 KK	391	if (err)
b36b654a	392	goto error2;
1b2b03f8	393	err = l1_init(&debug);
b36b654a MU	394	if (err)
b36b654a MU	395	goto error3;
1b2b03f8	396	err = Isdnl2_Init(&debug);
b36b654a MU	397	if (err)
b36b654a MU	398	goto error4;
1b2b03f8	399	err = misdn_sock_init(&debug);
b36b654a MU	400	if (err)
	401	goto error5;
	402	return 0;
	403
	404	error5:
	405	Isdnl2_cleanup();
	406	error4:
	407	l1_cleanup();
	408	error3:
	409	mISDN_timer_cleanup();
	410	error2:
	411	class_unregister(&mISDN_class);
	412	error1:
1b2b03f8 KK	413	return err;
	414	}
	415
5b834354	416	static void mISDN_cleanup(void)
1b2b03f8 KK	417	{
1b2b03f8 KK	418	misdn_sock_cleanup();
1b2b03f8	419	Isdnl2_cleanup();
b36b654a MU	420	l1_cleanup();
	421	mISDN_timer_cleanup();
	422	class_unregister(&mISDN_class);
1b2b03f8	423
1b2b03f8 KK	424	printk(KERN_DEBUG "mISDNcore unloaded\n");
	425	}
	426
	427	module_init(mISDNInit);
	428	module_exit(mISDN_cleanup);