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
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
20 static u64 device_ids;
21 #define MAX_DEVICE_ID 63
22
23 static LIST_HEAD(Bprotocols);
24 static DEFINE_RWLOCK(bp_lock);
25
mISDN_dev_release(struct device * dev)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
id_show(struct device * dev,struct device_attribute * attr,char * buf)31 static 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 }
40 static DEVICE_ATTR_RO(id);
41
nrbchan_show(struct device * dev,struct device_attribute * attr,char * buf)42 static 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 }
51 static DEVICE_ATTR_RO(nrbchan);
52
d_protocols_show(struct device * dev,struct device_attribute * attr,char * buf)53 static 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 }
62 static DEVICE_ATTR_RO(d_protocols);
63
b_protocols_show(struct device * dev,struct device_attribute * attr,char * buf)64 static 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 }
73 static DEVICE_ATTR_RO(b_protocols);
74
protocol_show(struct device * dev,struct device_attribute * attr,char * buf)75 static 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 }
84 static DEVICE_ATTR_RO(protocol);
85
name_show(struct device * dev,struct device_attribute * attr,char * buf)86 static 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 }
92 static DEVICE_ATTR_RO(name);
93
94 #if 0 /* hangs */
95 static 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 }
113 static DEVICE_ATTR_RW(name);
114 #endif
115
channelmap_show(struct device * dev,struct device_attribute * attr,char * buf)116 static 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 }
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,
139 };
140 ATTRIBUTE_GROUPS(mISDN);
141
mISDN_uevent(struct device * dev,struct kobj_uevent_env * env)142 static 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
mISDN_class_release(struct class * cls)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",
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
169 static int
_get_mdevice(struct device * dev,const void * id)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
181 struct mISDNdevice
get_mdevice(u_int id)182 *get_mdevice(u_int id)
183 {
184 return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id,
185 _get_mdevice));
186 }
187
188 static int
_get_mdevice_count(struct device * dev,void * cnt)189 _get_mdevice_count(struct device *dev, void *cnt)
190 {
191 *(int *)cnt += 1;
192 return 0;
193 }
194
195 int
get_mdevice_count(void)196 get_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
204 static int
get_free_devid(void)205 get_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
217 int
mISDN_register_device(struct mISDNdevice * dev,struct device * parent,char * name)218 mISDN_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
251 error3:
252 delete_stack(dev);
253 error1:
254 put_device(&dev->dev);
255 return err;
256
257 }
258 EXPORT_SYMBOL(mISDN_register_device);
259
260 void
mISDN_unregister_device(struct mISDNdevice * dev)261 mISDN_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 }
273 EXPORT_SYMBOL(mISDN_unregister_device);
274
275 u_int
get_all_Bprotocols(void)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 *
get_Bprotocol4mask(u_int m)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 *
get_Bprotocol4id(u_int id)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",
310 __func__, id);
311 return NULL;
312 }
313 m = 1 << (id & ISDN_P_B_MASK);
314 return get_Bprotocol4mask(m);
315 }
316
317 int
mISDN_register_Bprotocol(struct Bprotocol * bp)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__,
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 }
338 EXPORT_SYMBOL(mISDN_register_Bprotocol);
339
340 void
mISDN_unregister_Bprotocol(struct Bprotocol * bp)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,
347 bp->Bprotocols);
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
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
mISDNDevName4ch(struct mISDNchannel * ch)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
370 static int
mISDNInit(void)371 mISDNInit(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
396 error5:
397 Isdnl2_cleanup();
398 error4:
399 Isdnl1_cleanup();
400 error3:
401 mISDN_timer_cleanup();
402 error2:
403 class_unregister(&mISDN_class);
404 error1:
405 return err;
406 }
407
mISDN_cleanup(void)408 static 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
419 module_init(mISDNInit);
420 module_exit(mISDN_cleanup);
421