drivers/isdn/mISDN/core.c

   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
  15 #include <linux/slab.h>
  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
  29 static u64              device_ids;
  30 #define MAX_DEVICE_ID   63
  31
  32 static LIST_HEAD(Bprotocols);
  33 static DEFINE_RWLOCK(bp_lock);
  34
  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 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 }
 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,
 164         .dev_uevent = mISDN_uevent,
 165         .dev_attrs = mISDN_dev_attrs,
 166         .dev_release = mISDN_dev_release,
 167         .class_release = mISDN_class_release,
 168 };
 169
 170 static int
 171 _get_mdevice(struct device *dev, const void *id)
 172 {
 173         struct mISDNdevice *mdev = dev_to_mISDN(dev);
 174
 175         if (!mdev)
 176                 return 0;
 177         if (mdev->id != *(const u_int *)id)
 178                 return 0;
 179         return 1;
 180 }
 181
 182 struct mISDNdevice
 183 *get_mdevice(u_int id)
 184 {
 185         return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id,
 186                                               _get_mdevice));
 187 }
 188
 189 static int
 190 _get_mdevice_count(struct device *dev, void *cnt)
 191 {
 192         *(int *)cnt += 1;
 193         return 0;
 194 }
 195
 196 int
 197 get_mdevice_count(void)
 198 {
 199         int cnt = 0;
 200
 201         class_for_each_device(&mISDN_class, NULL, &cnt, _get_mdevice_count);
 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))
 212                         break;
 213         if (i > MAX_DEVICE_ID)
 214                 return -EBUSY;
 215         return i;
 216 }
 217
 218 int
 219 mISDN_register_device(struct mISDNdevice *dev,
 220                       struct device *parent, char *name)
 221 {
 222         int     err;
 223
 224         err = get_free_devid();
 225         if (err < 0)
 226                 goto error1;
 227         dev->id = err;
 228
 229         device_initialize(&dev->dev);
 230         if (name && name[0])
 231                 dev_set_name(&dev->dev, "%s", name);
 232         else
 233                 dev_set_name(&dev->dev, "mISDN%d", dev->id);
 234         if (debug & DEBUG_CORE)
 235                 printk(KERN_DEBUG "mISDN_register %s %d\n",
 236                        dev_name(&dev->dev), dev->id);
 237         err = create_stack(dev);
 238         if (err)
 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;
 249         return 0;
 250
 251 error3:
 252         delete_stack(dev);
 253         return err;
 254 error1:
 255         return err;
 256
 257 }
 258 EXPORT_SYMBOL(mISDN_register_device);
 259
 260 void
 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
 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",
 310                        __func__, id);
 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__,
 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
 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
 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
 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 = l1_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         l1_cleanup();
 400 error3:
 401         mISDN_timer_cleanup();
 402 error2:
 403         class_unregister(&mISDN_class);
 404 error1:
 405         return err;
 406 }
 407
 408 static void mISDN_cleanup(void)
 409 {
 410         misdn_sock_cleanup();
 411         Isdnl2_cleanup();
 412         l1_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);