[GitHub/mt8127/android_kernel_alcatel_ttab.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), */
	{}
};

#ifdef CONFIG_HOTPLUG
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;
}
#endif

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

static struct class mISDN_class = {
	.name = "mISDN",
	.owner = THIS_MODULE,
#ifdef CONFIG_HOTPLUG
	.dev_uevent = mISDN_uevent,
#endif
	.dev_attrs = mISDN_dev_attrs,
	.dev_release = mISDN_dev_release,
	.class_release = mISDN_class_release,
};

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

	if (!mdev)
		return 0;
	if (mdev->id != *(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 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,
	41	struct device_attribute attr, char buf)
	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,
	51	struct device_attribute attr, char buf)
	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,
	61	struct device_attribute attr, char buf)
	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,
	71	struct device_attribute attr, char buf)
	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,
	81	struct device_attribute attr, char buf)
	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,
	91	struct device_attribute attr, char buf)
	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,
99	const char *buf, size_t count)
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),
139	/* __ATTR(name, S_IRUGO\|S_IWUSR, _show_name, _set_name), */
140	{}
141	};
142
143	#ifdef CONFIG_HOTPLUG
144	static int mISDN_uevent(struct device dev, struct kobj_uevent_env env)
145	{
146	struct mISDNdevice *mdev = dev_to_mISDN(dev);
147
148	if (!mdev)
149	return 0;
150
151	if (add_uevent_var(env, "nchans=%d", mdev->nrbchan))
152	return -ENOMEM;
153
154	return 0;
155	}
156	#endif
157
158	static void mISDN_class_release(struct class *cls)
159	{
160	/* do nothing, it's static */
161	}
162
163	static struct class mISDN_class = {
164	.name = "mISDN",
165	.owner = THIS_MODULE,
166	#ifdef CONFIG_HOTPLUG
167	.dev_uevent = mISDN_uevent,
168	#endif
169	.dev_attrs = mISDN_dev_attrs,
170	.dev_release = mISDN_dev_release,
171	.class_release = mISDN_class_release,
172	};
173
174	static int
175	_get_mdevice(struct device dev, void id)
176	{
177	struct mISDNdevice *mdev = dev_to_mISDN(dev);
178
179	if (!mdev)
180	return 0;
181	if (mdev->id != (u_int )id)
182	return 0;
183	return 1;
184	}
185
1b2b03f8 KK	186	struct mISDNdevice
	187	*get_mdevice(u_int id)
	188	{
b36b654a MU	189	return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id,
	190	_get_mdevice));
	191	}
1b2b03f8	192
b36b654a MU	193	static int
	194	_get_mdevice_count(struct device dev, void cnt)
	195	{
	196	(int )cnt += 1;
	197	return 0;
1b2b03f8 KK	198	}
	199
	200	int
	201	get_mdevice_count(void)
	202	{
b36b654a	203	int cnt = 0;
1b2b03f8	204
b36b654a	205	class_for_each_device(&mISDN_class, NULL, &cnt, _get_mdevice_count);
1b2b03f8 KK	206	return cnt;
	207	}
	208
	209	static int
	210	get_free_devid(void)
	211	{
	212	u_int i;
	213
	214	for (i = 0; i <= MAX_DEVICE_ID; i++)
	215	if (!test_and_set_bit(i, (u_long *)&device_ids))
b36b654a MU	216	break;
b36b654a MU	217	if (i > MAX_DEVICE_ID)
ddacd14e	218	return -EBUSY;
b36b654a	219	return i;
1b2b03f8 KK	220	}
	221
	222	int
b36b654a MU	223	mISDN_register_device(struct mISDNdevice *dev,
b36b654a MU	224	struct device parent, char name)
1b2b03f8	225	{
1b2b03f8 KK	226	int err;
1b2b03f8 KK	227
ddacd14e RK	228	err = get_free_devid();
ddacd14e RK	229	if (err < 0)
b36b654a	230	goto error1;
ddacd14e	231	dev->id = err;
b36b654a MU	232
b36b654a MU	233	device_initialize(&dev->dev);
1b2b03f8	234	if (name && name[0])
837468d1	235	dev_set_name(&dev->dev, "%s", name);
1b2b03f8	236	else
837468d1	237	dev_set_name(&dev->dev, "mISDN%d", dev->id);
1b2b03f8 KK	238	if (debug & DEBUG_CORE)
1b2b03f8 KK	239	printk(KERN_DEBUG "mISDN_register %s %d\n",
837468d1	240	dev_name(&dev->dev), dev->id);
1b2b03f8 KK	241	err = create_stack(dev);
1b2b03f8 KK	242	if (err)
b36b654a MU	243	goto error1;
	244
	245	dev->dev.class = &mISDN_class;
	246	dev->dev.platform_data = dev;
	247	dev->dev.parent = parent;
	248	dev_set_drvdata(&dev->dev, dev);
	249
	250	err = device_add(&dev->dev);
	251	if (err)
	252	goto error3;
1b2b03f8	253	return 0;
b36b654a MU	254
	255	error3:
	256	delete_stack(dev);
	257	return err;
	258	error1:
	259	return err;
	260
1b2b03f8 KK	261	}
	262	EXPORT_SYMBOL(mISDN_register_device);
	263
	264	void
	265	mISDN_unregister_device(struct mISDNdevice *dev) {
1b2b03f8 KK	266	if (debug & DEBUG_CORE)
1b2b03f8 KK	267	printk(KERN_DEBUG "mISDN_unregister %s %d\n",
837468d1	268	dev_name(&dev->dev), dev->id);
b36b654a MU	269	/* sysfs_remove_link(&dev->dev.kobj, "device"); */
	270	device_del(&dev->dev);
	271	dev_set_drvdata(&dev->dev, NULL);
	272
1b2b03f8 KK	273	test_and_clear_bit(dev->id, (u_long *)&device_ids);
1b2b03f8 KK	274	delete_stack(dev);
b36b654a	275	put_device(&dev->dev);
1b2b03f8 KK	276	}
	277	EXPORT_SYMBOL(mISDN_unregister_device);
	278
	279	u_int
	280	get_all_Bprotocols(void)
	281	{
	282	struct Bprotocol *bp;
	283	u_int m = 0;
	284
	285	read_lock(&bp_lock);
	286	list_for_each_entry(bp, &Bprotocols, list)
	287	m \|= bp->Bprotocols;
	288	read_unlock(&bp_lock);
	289	return m;
	290	}
	291
	292	struct Bprotocol *
	293	get_Bprotocol4mask(u_int m)
	294	{
	295	struct Bprotocol *bp;
	296
	297	read_lock(&bp_lock);
	298	list_for_each_entry(bp, &Bprotocols, list)
	299	if (bp->Bprotocols & m) {
	300	read_unlock(&bp_lock);
	301	return bp;
	302	}
	303	read_unlock(&bp_lock);
	304	return NULL;
	305	}
	306
	307	struct Bprotocol *
	308	get_Bprotocol4id(u_int id)
	309	{
	310	u_int m;
	311
	312	if (id < ISDN_P_B_START \|\| id > 63) {
	313	printk(KERN_WARNING "%s id not in range %d\n",
	314	__func__, id);
	315	return NULL;
	316	}
	317	m = 1 << (id & ISDN_P_B_MASK);
	318	return get_Bprotocol4mask(m);
	319	}
	320
	321	int
	322	mISDN_register_Bprotocol(struct Bprotocol *bp)
	323	{
	324	u_long flags;
	325	struct Bprotocol *old;
	326
	327	if (debug & DEBUG_CORE)
	328	printk(KERN_DEBUG "%s: %s/%x\n", __func__,
	329	bp->name, bp->Bprotocols);
	330	old = get_Bprotocol4mask(bp->Bprotocols);
	331	if (old) {
	332	printk(KERN_WARNING
	333	"register duplicate protocol old %s/%x new %s/%x\n",
	334	old->name, old->Bprotocols, bp->name, bp->Bprotocols);
	335	return -EBUSY;
	336	}
	337	write_lock_irqsave(&bp_lock, flags);
	338	list_add_tail(&bp->list, &Bprotocols);
	339	write_unlock_irqrestore(&bp_lock, flags);
340	return 0;
341	}
342	EXPORT_SYMBOL(mISDN_register_Bprotocol);
343
344	void
345	mISDN_unregister_Bprotocol(struct Bprotocol *bp)
346	{
347	u_long flags;
348
349	if (debug & DEBUG_CORE)
350	printk(KERN_DEBUG "%s: %s/%x\n", __func__, bp->name,
351	bp->Bprotocols);
352	write_lock_irqsave(&bp_lock, flags);
353	list_del(&bp->list);
354	write_unlock_irqrestore(&bp_lock, flags);
355	}
356	EXPORT_SYMBOL(mISDN_unregister_Bprotocol);
357
5b834354	358	static int
1b2b03f8 KK	359	mISDNInit(void)
	360	{
	361	int err;
	362
	363	printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n",
	364	MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE);
3bd69ad1	365	mISDN_init_clock(&debug);
1b2b03f8	366	mISDN_initstack(&debug);
b36b654a MU	367	err = class_register(&mISDN_class);
	368	if (err)
	369	goto error1;
1b2b03f8 KK	370	err = mISDN_inittimer(&debug);
1b2b03f8 KK	371	if (err)
b36b654a	372	goto error2;
1b2b03f8	373	err = l1_init(&debug);
b36b654a MU	374	if (err)
b36b654a MU	375	goto error3;
1b2b03f8	376	err = Isdnl2_Init(&debug);
b36b654a MU	377	if (err)
b36b654a MU	378	goto error4;
1b2b03f8	379	err = misdn_sock_init(&debug);
b36b654a MU	380	if (err)
	381	goto error5;
	382	return 0;
	383
	384	error5:
	385	Isdnl2_cleanup();
	386	error4:
	387	l1_cleanup();
	388	error3:
	389	mISDN_timer_cleanup();
	390	error2:
	391	class_unregister(&mISDN_class);
	392	error1:
1b2b03f8 KK	393	return err;
	394	}
	395
5b834354	396	static void mISDN_cleanup(void)
1b2b03f8 KK	397	{
1b2b03f8 KK	398	misdn_sock_cleanup();
1b2b03f8	399	Isdnl2_cleanup();
b36b654a MU	400	l1_cleanup();
	401	mISDN_timer_cleanup();
	402	class_unregister(&mISDN_class);
1b2b03f8	403
1b2b03f8 KK	404	printk(KERN_DEBUG "mISDNcore unloaded\n");
	405	}
	406
	407	module_init(mISDNInit);
	408	module_exit(mISDN_cleanup);
	409