drivers/isdn/mISDN/core.c

   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
  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
  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
  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
  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
  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
  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
  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
 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
 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
 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
 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
 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
 189 _get_mdevice_count(struct device *dev, void *cnt)
 190 {
 191         *(int *)cnt += 1;
 192         return 0;
 193 }
 194
 195 int
 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
 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
 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                 goto error1;
 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         err = create_stack(dev);
 237         if (err)
 238                 goto error1;
 239
 240         dev->dev.class = &mISDN_class;
 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;
 248         return 0;
 249
 250 error3:
 251         delete_stack(dev);
 252         return err;
 253 error1:
 254         return err;
 255
 256 }
 257 EXPORT_SYMBOL(mISDN_register_device);
 258
 259 void
 260 mISDN_unregister_device(struct mISDNdevice *dev) {
 261         if (debug & DEBUG_CORE)
 262                 printk(KERN_DEBUG "mISDN_unregister %s %d\n",
 263                        dev_name(&dev->dev), dev->id);
 264         /* sysfs_remove_link(&dev->dev.kobj, "device"); */
 265         device_del(&dev->dev);
 266         dev_set_drvdata(&dev->dev, NULL);
 267
 268         test_and_clear_bit(dev->id, (u_long *)&device_ids);
 269         delete_stack(dev);
 270         put_device(&dev->dev);
 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",
 309                        __func__, id);
 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__,
 324                        bp->name, bp->Bprotocols);
 325         old = get_Bprotocol4mask(bp->Bprotocols);
 326         if (old) {
 327                 printk(KERN_WARNING
 328                        "register duplicate protocol old %s/%x new %s/%x\n",
 329                        old->name, old->Bprotocols, bp->name, bp->Bprotocols);
 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,
 346                        bp->Bprotocols);
 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
 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
 369 static int
 370 mISDNInit(void)
 371 {
 372         int     err;
 373
 374         printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n",
 375                MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE);
 376         mISDN_init_clock(&debug);
 377         mISDN_initstack(&debug);
 378         err = class_register(&mISDN_class);
 379         if (err)
 380                 goto error1;
 381         err = mISDN_inittimer(&debug);
 382         if (err)
 383                 goto error2;
 384         err = l1_init(&debug);
 385         if (err)
 386                 goto error3;
 387         err = Isdnl2_Init(&debug);
 388         if (err)
 389                 goto error4;
 390         err = misdn_sock_init(&debug);
 391         if (err)
 392                 goto error5;
 393         return 0;
 394
 395 error5:
 396         Isdnl2_cleanup();
 397 error4:
 398         l1_cleanup();
 399 error3:
 400         mISDN_timer_cleanup();
 401 error2:
 402         class_unregister(&mISDN_class);
 403 error1:
 404         return err;
 405 }
 406
 407 static void mISDN_cleanup(void)
 408 {
 409         misdn_sock_cleanup();
 410         Isdnl2_cleanup();
 411         l1_cleanup();
 412         mISDN_timer_cleanup();
 413         class_unregister(&mISDN_class);
 414
 415         printk(KERN_DEBUG "mISDNcore unloaded\n");
 416 }
 417
 418 module_init(mISDNInit);
 419 module_exit(mISDN_cleanup);