1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright 2008  by Karsten Keil <kkeil@novell.com>
4 */
5
6#include <linux/slab.h>
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
14static u_int debug;
15
16MODULE_AUTHOR("Karsten Keil");
17MODULE_LICENSE("GPL");
18module_param(debug, uint, S_IRUGO | S_IWUSR);
19
20static u64		device_ids;
21#define MAX_DEVICE_ID	63
22
23static LIST_HEAD(Bprotocols);
24static DEFINE_RWLOCK(bp_lock);
25
26static void mISDN_dev_release(struct device *dev)
27{
28	/* nothing to do: the device is part of its parent's data structure */
29}
30
31static ssize_t id_show(struct device *dev,
32		       struct device_attribute *attr, char *buf)
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}
40static DEVICE_ATTR_RO(id);
41
42static ssize_t nrbchan_show(struct device *dev,
43			    struct device_attribute *attr, char *buf)
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}
51static DEVICE_ATTR_RO(nrbchan);
52
53static ssize_t d_protocols_show(struct device *dev,
54				struct device_attribute *attr, char *buf)
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}
62static DEVICE_ATTR_RO(d_protocols);
63
64static ssize_t b_protocols_show(struct device *dev,
65				struct device_attribute *attr, char *buf)
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}
73static DEVICE_ATTR_RO(b_protocols);
74
75static ssize_t protocol_show(struct device *dev,
76			     struct device_attribute *attr, char *buf)
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}
84static DEVICE_ATTR_RO(protocol);
85
86static ssize_t name_show(struct device *dev,
87			 struct device_attribute *attr, char *buf)
88{
89	strcpy(buf, dev_name(dev));
90	return strlen(buf);
91}
92static DEVICE_ATTR_RO(name);
93
94#if 0 /* hangs */
95static ssize_t name_set(struct device *dev, struct device_attribute *attr,
96			const char *buf, size_t count)
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}
113static DEVICE_ATTR_RW(name);
114#endif
115
116static ssize_t channelmap_show(struct device *dev,
117			       struct device_attribute *attr, char *buf)
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}
128static DEVICE_ATTR_RO(channelmap);
129
130static 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,
139};
140ATTRIBUTE_GROUPS(mISDN);
141
142static int mISDN_uevent(struct device *dev, struct kobj_uevent_env *env)
143{
144	struct mISDNdevice *mdev = dev_to_mISDN(dev);
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}
154
155static void mISDN_class_release(struct class *cls)
156{
157	/* do nothing, it's static */
158}
159
160static struct class mISDN_class = {
161	.name = "mISDN",
162	.owner = THIS_MODULE,
163	.dev_uevent = mISDN_uevent,
164	.dev_groups = mISDN_groups,
165	.dev_release = mISDN_dev_release,
166	.class_release = mISDN_class_release,
167};
168
169static int
170_get_mdevice(struct device *dev, const void *id)
171{
172	struct mISDNdevice *mdev = dev_to_mISDN(dev);
173
174	if (!mdev)
175		return 0;
176	if (mdev->id != *(const u_int *)id)
177		return 0;
178	return 1;
179}
180
181struct mISDNdevice
182*get_mdevice(u_int id)
183{
184	return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id,
185					      _get_mdevice));
186}
187
188static int
189_get_mdevice_count(struct device *dev, void *cnt)
190{
191	*(int *)cnt += 1;
192	return 0;
193}
194
195int
196get_mdevice_count(void)
197{
198	int cnt = 0;
199
200	class_for_each_device(&mISDN_class, NULL, &cnt, _get_mdevice_count);
201	return cnt;
202}
203
204static int
205get_free_devid(void)
206{
207	u_int	i;
208
209	for (i = 0; i <= MAX_DEVICE_ID; i++)
210		if (!test_and_set_bit(i, (u_long *)&device_ids))
211			break;
212	if (i > MAX_DEVICE_ID)
213		return -EBUSY;
214	return i;
215}
216
217int
218mISDN_register_device(struct mISDNdevice *dev,
219		      struct device *parent, char *name)
220{
221	int	err;
222
223	err = get_free_devid();
224	if (err < 0)
225		return err;
226	dev->id = err;
227
228	device_initialize(&dev->dev);
229	if (name && name[0])
230		dev_set_name(&dev->dev, "%s", name);
231	else
232		dev_set_name(&dev->dev, "mISDN%d", dev->id);
233	if (debug & DEBUG_CORE)
234		printk(KERN_DEBUG "mISDN_register %s %d\n",
235		       dev_name(&dev->dev), dev->id);
236	dev->dev.class = &mISDN_class;
237
238	err = create_stack(dev);
239	if (err)
240		goto error1;
241
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;
249	return 0;
250
251error3:
252	delete_stack(dev);
253error1:
254	put_device(&dev->dev);
255	return err;
256
257}
258EXPORT_SYMBOL(mISDN_register_device);
259
260void
261mISDN_unregister_device(struct mISDNdevice *dev) {
262	if (debug & DEBUG_CORE)
263		printk(KERN_DEBUG "mISDN_unregister %s %d\n",
264		       dev_name(&dev->dev), dev->id);
265	/* sysfs_remove_link(&dev->dev.kobj, "device"); */
266	device_del(&dev->dev);
267	dev_set_drvdata(&dev->dev, NULL);
268
269	test_and_clear_bit(dev->id, (u_long *)&device_ids);
270	delete_stack(dev);
271	put_device(&dev->dev);
272}
273EXPORT_SYMBOL(mISDN_unregister_device);
274
275u_int
276get_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
288struct Bprotocol *
289get_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
303struct Bprotocol *
304get_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",
310		       __func__, id);
311		return NULL;
312	}
313	m = 1 << (id & ISDN_P_B_MASK);
314	return get_Bprotocol4mask(m);
315}
316
317int
318mISDN_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__,
325		       bp->name, bp->Bprotocols);
326	old = get_Bprotocol4mask(bp->Bprotocols);
327	if (old) {
328		printk(KERN_WARNING
329		       "register duplicate protocol old %s/%x new %s/%x\n",
330		       old->name, old->Bprotocols, bp->name, bp->Bprotocols);
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}
338EXPORT_SYMBOL(mISDN_register_Bprotocol);
339
340void
341mISDN_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,
347		       bp->Bprotocols);
348	write_lock_irqsave(&bp_lock, flags);
349	list_del(&bp->list);
350	write_unlock_irqrestore(&bp_lock, flags);
351}
352EXPORT_SYMBOL(mISDN_unregister_Bprotocol);
353
354static const char *msg_no_channel = "<no channel>";
355static const char *msg_no_stack = "<no stack>";
356static const char *msg_no_stackdev = "<no stack device>";
357
358const 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};
368EXPORT_SYMBOL(mISDNDevName4ch);
369
370static int
371mISDNInit(void)
372{
373	int	err;
374
375	printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n",
376	       MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE);
377	mISDN_init_clock(&debug);
378	mISDN_initstack(&debug);
379	err = class_register(&mISDN_class);
380	if (err)
381		goto error1;
382	err = mISDN_inittimer(&debug);
383	if (err)
384		goto error2;
385	err = Isdnl1_Init(&debug);
386	if (err)
387		goto error3;
388	err = Isdnl2_Init(&debug);
389	if (err)
390		goto error4;
391	err = misdn_sock_init(&debug);
392	if (err)
393		goto error5;
394	return 0;
395
396error5:
397	Isdnl2_cleanup();
398error4:
399	Isdnl1_cleanup();
400error3:
401	mISDN_timer_cleanup();
402error2:
403	class_unregister(&mISDN_class);
404error1:
405	return err;
406}
407
408static void mISDN_cleanup(void)
409{
410	misdn_sock_cleanup();
411	Isdnl2_cleanup();
412	Isdnl1_cleanup();
413	mISDN_timer_cleanup();
414	class_unregister(&mISDN_class);
415
416	printk(KERN_DEBUG "mISDNcore unloaded\n");
417}
418
419module_init(mISDNInit);
420module_exit(mISDN_cleanup);
421