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_DESCRIPTION("Modular ISDN core driver"); 18 MODULE_LICENSE("GPL"); 19 module_param(debug, uint, S_IRUGO | S_IWUSR); 20 21 static u64 device_ids; 22 #define MAX_DEVICE_ID 63 23 24 static LIST_HEAD(Bprotocols); 25 static DEFINE_RWLOCK(bp_lock); 26 27 static void mISDN_dev_release(struct device *dev) 28 { 29 /* nothing to do: the device is part of its parent's data structure */ 30 } 31 32 static ssize_t id_show(struct device *dev, 33 struct device_attribute *attr, char *buf) 34 { 35 struct mISDNdevice *mdev = dev_to_mISDN(dev); 36 37 if (!mdev) 38 return -ENODEV; 39 return sprintf(buf, "%d\n", mdev->id); 40 } 41 static DEVICE_ATTR_RO(id); 42 43 static ssize_t nrbchan_show(struct device *dev, 44 struct device_attribute *attr, char *buf) 45 { 46 struct mISDNdevice *mdev = dev_to_mISDN(dev); 47 48 if (!mdev) 49 return -ENODEV; 50 return sprintf(buf, "%d\n", mdev->nrbchan); 51 } 52 static DEVICE_ATTR_RO(nrbchan); 53 54 static ssize_t d_protocols_show(struct device *dev, 55 struct device_attribute *attr, char *buf) 56 { 57 struct mISDNdevice *mdev = dev_to_mISDN(dev); 58 59 if (!mdev) 60 return -ENODEV; 61 return sprintf(buf, "%d\n", mdev->Dprotocols); 62 } 63 static DEVICE_ATTR_RO(d_protocols); 64 65 static ssize_t b_protocols_show(struct device *dev, 66 struct device_attribute *attr, char *buf) 67 { 68 struct mISDNdevice *mdev = dev_to_mISDN(dev); 69 70 if (!mdev) 71 return -ENODEV; 72 return sprintf(buf, "%d\n", mdev->Bprotocols | get_all_Bprotocols()); 73 } 74 static DEVICE_ATTR_RO(b_protocols); 75 76 static ssize_t protocol_show(struct device *dev, 77 struct device_attribute *attr, char *buf) 78 { 79 struct mISDNdevice *mdev = dev_to_mISDN(dev); 80 81 if (!mdev) 82 return -ENODEV; 83 return sprintf(buf, "%d\n", mdev->D.protocol); 84 } 85 static DEVICE_ATTR_RO(protocol); 86 87 static ssize_t name_show(struct device *dev, 88 struct device_attribute *attr, char *buf) 89 { 90 strcpy(buf, dev_name(dev)); 91 return strlen(buf); 92 } 93 static DEVICE_ATTR_RO(name); 94 95 #if 0 /* hangs */ 96 static ssize_t name_set(struct device *dev, struct device_attribute *attr, 97 const char *buf, size_t count) 98 { 99 int err = 0; 100 char *out = kmalloc(count + 1, GFP_KERNEL); 101 102 if (!out) 103 return -ENOMEM; 104 105 memcpy(out, buf, count); 106 if (count && out[count - 1] == '\n') 107 out[--count] = 0; 108 if (count) 109 err = device_rename(dev, out); 110 kfree(out); 111 112 return (err < 0) ? err : count; 113 } 114 static DEVICE_ATTR_RW(name); 115 #endif 116 117 static ssize_t channelmap_show(struct device *dev, 118 struct device_attribute *attr, char *buf) 119 { 120 struct mISDNdevice *mdev = dev_to_mISDN(dev); 121 char *bp = buf; 122 int i; 123 124 for (i = 0; i <= mdev->nrbchan; i++) 125 *bp++ = test_channelmap(i, mdev->channelmap) ? '1' : '0'; 126 127 return bp - buf; 128 } 129 static DEVICE_ATTR_RO(channelmap); 130 131 static struct attribute *mISDN_attrs[] = { 132 &dev_attr_id.attr, 133 &dev_attr_d_protocols.attr, 134 &dev_attr_b_protocols.attr, 135 &dev_attr_protocol.attr, 136 &dev_attr_channelmap.attr, 137 &dev_attr_nrbchan.attr, 138 &dev_attr_name.attr, 139 NULL, 140 }; 141 ATTRIBUTE_GROUPS(mISDN); 142 143 static int mISDN_uevent(const struct device *dev, struct kobj_uevent_env *env) 144 { 145 const 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 struct class mISDN_class = { 157 .name = "mISDN", 158 .dev_uevent = mISDN_uevent, 159 .dev_groups = mISDN_groups, 160 .dev_release = mISDN_dev_release, 161 }; 162 163 static int 164 _get_mdevice(struct device *dev, const void *id) 165 { 166 struct mISDNdevice *mdev = dev_to_mISDN(dev); 167 168 if (!mdev) 169 return 0; 170 if (mdev->id != *(const u_int *)id) 171 return 0; 172 return 1; 173 } 174 175 struct mISDNdevice 176 *get_mdevice(u_int id) 177 { 178 return dev_to_mISDN(class_find_device(&mISDN_class, NULL, &id, 179 _get_mdevice)); 180 } 181 182 static int 183 _get_mdevice_count(struct device *dev, void *cnt) 184 { 185 *(int *)cnt += 1; 186 return 0; 187 } 188 189 int 190 get_mdevice_count(void) 191 { 192 int cnt = 0; 193 194 class_for_each_device(&mISDN_class, NULL, &cnt, _get_mdevice_count); 195 return cnt; 196 } 197 198 static int 199 get_free_devid(void) 200 { 201 u_int i; 202 203 for (i = 0; i <= MAX_DEVICE_ID; i++) 204 if (!test_and_set_bit(i, (u_long *)&device_ids)) 205 break; 206 if (i > MAX_DEVICE_ID) 207 return -EBUSY; 208 return i; 209 } 210 211 int 212 mISDN_register_device(struct mISDNdevice *dev, 213 struct device *parent, char *name) 214 { 215 int err; 216 217 err = get_free_devid(); 218 if (err < 0) 219 return err; 220 dev->id = err; 221 222 device_initialize(&dev->dev); 223 if (name && name[0]) 224 dev_set_name(&dev->dev, "%s", name); 225 else 226 dev_set_name(&dev->dev, "mISDN%d", dev->id); 227 if (debug & DEBUG_CORE) 228 printk(KERN_DEBUG "mISDN_register %s %d\n", 229 dev_name(&dev->dev), dev->id); 230 dev->dev.class = &mISDN_class; 231 232 err = create_stack(dev); 233 if (err) 234 goto error1; 235 236 dev->dev.platform_data = dev; 237 dev->dev.parent = parent; 238 dev_set_drvdata(&dev->dev, dev); 239 240 err = device_add(&dev->dev); 241 if (err) 242 goto error3; 243 return 0; 244 245 error3: 246 delete_stack(dev); 247 error1: 248 put_device(&dev->dev); 249 return err; 250 251 } 252 EXPORT_SYMBOL(mISDN_register_device); 253 254 void 255 mISDN_unregister_device(struct mISDNdevice *dev) { 256 if (debug & DEBUG_CORE) 257 printk(KERN_DEBUG "mISDN_unregister %s %d\n", 258 dev_name(&dev->dev), dev->id); 259 /* sysfs_remove_link(&dev->dev.kobj, "device"); */ 260 device_del(&dev->dev); 261 dev_set_drvdata(&dev->dev, NULL); 262 263 test_and_clear_bit(dev->id, (u_long *)&device_ids); 264 delete_stack(dev); 265 put_device(&dev->dev); 266 } 267 EXPORT_SYMBOL(mISDN_unregister_device); 268 269 u_int 270 get_all_Bprotocols(void) 271 { 272 struct Bprotocol *bp; 273 u_int m = 0; 274 275 read_lock(&bp_lock); 276 list_for_each_entry(bp, &Bprotocols, list) 277 m |= bp->Bprotocols; 278 read_unlock(&bp_lock); 279 return m; 280 } 281 282 struct Bprotocol * 283 get_Bprotocol4mask(u_int m) 284 { 285 struct Bprotocol *bp; 286 287 read_lock(&bp_lock); 288 list_for_each_entry(bp, &Bprotocols, list) 289 if (bp->Bprotocols & m) { 290 read_unlock(&bp_lock); 291 return bp; 292 } 293 read_unlock(&bp_lock); 294 return NULL; 295 } 296 297 struct Bprotocol * 298 get_Bprotocol4id(u_int id) 299 { 300 u_int m; 301 302 if (id < ISDN_P_B_START || id > 63) { 303 printk(KERN_WARNING "%s id not in range %d\n", 304 __func__, id); 305 return NULL; 306 } 307 m = 1 << (id & ISDN_P_B_MASK); 308 return get_Bprotocol4mask(m); 309 } 310 311 int 312 mISDN_register_Bprotocol(struct Bprotocol *bp) 313 { 314 u_long flags; 315 struct Bprotocol *old; 316 317 if (debug & DEBUG_CORE) 318 printk(KERN_DEBUG "%s: %s/%x\n", __func__, 319 bp->name, bp->Bprotocols); 320 old = get_Bprotocol4mask(bp->Bprotocols); 321 if (old) { 322 printk(KERN_WARNING 323 "register duplicate protocol old %s/%x new %s/%x\n", 324 old->name, old->Bprotocols, bp->name, bp->Bprotocols); 325 return -EBUSY; 326 } 327 write_lock_irqsave(&bp_lock, flags); 328 list_add_tail(&bp->list, &Bprotocols); 329 write_unlock_irqrestore(&bp_lock, flags); 330 return 0; 331 } 332 EXPORT_SYMBOL(mISDN_register_Bprotocol); 333 334 void 335 mISDN_unregister_Bprotocol(struct Bprotocol *bp) 336 { 337 u_long flags; 338 339 if (debug & DEBUG_CORE) 340 printk(KERN_DEBUG "%s: %s/%x\n", __func__, bp->name, 341 bp->Bprotocols); 342 write_lock_irqsave(&bp_lock, flags); 343 list_del(&bp->list); 344 write_unlock_irqrestore(&bp_lock, flags); 345 } 346 EXPORT_SYMBOL(mISDN_unregister_Bprotocol); 347 348 static const char *msg_no_channel = "<no channel>"; 349 static const char *msg_no_stack = "<no stack>"; 350 static const char *msg_no_stackdev = "<no stack device>"; 351 352 const char *mISDNDevName4ch(struct mISDNchannel *ch) 353 { 354 if (!ch) 355 return msg_no_channel; 356 if (!ch->st) 357 return msg_no_stack; 358 if (!ch->st->dev) 359 return msg_no_stackdev; 360 return dev_name(&ch->st->dev->dev); 361 }; 362 EXPORT_SYMBOL(mISDNDevName4ch); 363 364 static int 365 mISDNInit(void) 366 { 367 int err; 368 369 printk(KERN_INFO "Modular ISDN core version %d.%d.%d\n", 370 MISDN_MAJOR_VERSION, MISDN_MINOR_VERSION, MISDN_RELEASE); 371 mISDN_init_clock(&debug); 372 mISDN_initstack(&debug); 373 err = class_register(&mISDN_class); 374 if (err) 375 goto error1; 376 err = mISDN_inittimer(&debug); 377 if (err) 378 goto error2; 379 err = Isdnl1_Init(&debug); 380 if (err) 381 goto error3; 382 err = Isdnl2_Init(&debug); 383 if (err) 384 goto error4; 385 err = misdn_sock_init(&debug); 386 if (err) 387 goto error5; 388 return 0; 389 390 error5: 391 Isdnl2_cleanup(); 392 error4: 393 Isdnl1_cleanup(); 394 error3: 395 mISDN_timer_cleanup(); 396 error2: 397 class_unregister(&mISDN_class); 398 error1: 399 return err; 400 } 401 402 static void mISDN_cleanup(void) 403 { 404 misdn_sock_cleanup(); 405 Isdnl2_cleanup(); 406 Isdnl1_cleanup(); 407 mISDN_timer_cleanup(); 408 class_unregister(&mISDN_class); 409 410 printk(KERN_DEBUG "mISDNcore unloaded\n"); 411 } 412 413 module_init(mISDNInit); 414 module_exit(mISDN_cleanup); 415