[linux-2.6-block.git] / drivers / isdn / mISDN / core.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright 2008  by Karsten Keil <kkeil@novell.com>
 */

#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(const struct device *dev, struct kobj_uevent_env *env)
{
	const 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",
	.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)
		return err;
	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);
	dev->dev.class = &mISDN_class;

	err = create_stack(dev);
	if (err)
		goto error1;

	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);
error1:
	put_device(&dev->dev);
	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 = Isdnl1_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:
	Isdnl1_cleanup();
error3:
	mISDN_timer_cleanup();
error2:
	class_unregister(&mISDN_class);
error1:
	return err;
}

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

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

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