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, void *id) 172 { 173 struct mISDNdevice *mdev = dev_to_mISDN(dev); 174 175 if (!mdev) 176 return 0; 177 if (mdev->id != *(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); 421