[deliverable/linux.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 _show_id(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 ssize_t _show_nrbchan(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 ssize_t _show_d_protocols(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 ssize_t _show_b_protocols(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 ssize_t _show_protocol(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 ssize_t _show_name(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	strcpy(buf, dev_name(dev));
	return strlen(buf);
}

#if 0 /* hangs */
static ssize_t _set_name(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;
}
#endif

static ssize_t _show_channelmap(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 struct device_attribute mISDN_dev_attrs[] = {
	__ATTR(id,          S_IRUGO,         _show_id,          NULL),
	__ATTR(d_protocols, S_IRUGO,         _show_d_protocols, NULL),
	__ATTR(b_protocols, S_IRUGO,         _show_b_protocols, NULL),
	__ATTR(protocol,    S_IRUGO,         _show_protocol,    NULL),
	__ATTR(channelmap,  S_IRUGO,         _show_channelmap,  NULL),
	__ATTR(nrbchan,     S_IRUGO,         _show_nrbchan,     NULL),
	__ATTR(name,        S_IRUGO,         _show_name,        NULL),
/*	__ATTR(name,        S_IRUGO | S_IWUSR, _show_name,      _set_name), */
	{}
};

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