1/* $Id: isdn_common.c,v 1.1.2.3 2004/02/10 01:07:13 keil Exp $ 2 * 3 * Linux ISDN subsystem, common used functions (linklevel). 4 * 5 * Copyright 1994-1999 by Fritz Elfert (fritz@isdn4linux.de) 6 * Copyright 1995,96 Thinking Objects Software GmbH Wuerzburg 7 * Copyright 1995,96 by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de) 8 * 9 * This software may be used and distributed according to the terms 10 * of the GNU General Public License, incorporated herein by reference. 11 * 12 */ 13 14#include <linux/module.h> 15#include <linux/init.h> 16#include <linux/poll.h> 17#include <linux/slab.h> 18#include <linux/vmalloc.h> 19#include <linux/isdn.h> 20#include <linux/mutex.h> 21#include "isdn_common.h" 22#include "isdn_tty.h" 23#include "isdn_net.h" 24#include "isdn_ppp.h" 25#ifdef CONFIG_ISDN_AUDIO 26#include "isdn_audio.h" 27#endif 28#ifdef CONFIG_ISDN_DIVERSION_MODULE 29#define CONFIG_ISDN_DIVERSION 30#endif 31#ifdef CONFIG_ISDN_DIVERSION 32#include <linux/isdn_divertif.h> 33#endif /* CONFIG_ISDN_DIVERSION */ 34#include "isdn_v110.h" 35 36/* Debugflags */ 37#undef ISDN_DEBUG_STATCALLB 38 39MODULE_DESCRIPTION("ISDN4Linux: link layer"); 40MODULE_AUTHOR("Fritz Elfert"); 41MODULE_LICENSE("GPL"); 42 43isdn_dev *dev; 44 45static DEFINE_MUTEX(isdn_mutex); 46static char *isdn_revision = "$Revision: 1.1.2.3 $"; 47 48extern char *isdn_net_revision; 49#ifdef CONFIG_ISDN_PPP 50extern char *isdn_ppp_revision; 51#else 52static char *isdn_ppp_revision = ": none $"; 53#endif 54#ifdef CONFIG_ISDN_AUDIO 55extern char *isdn_audio_revision; 56#else 57static char *isdn_audio_revision = ": none $"; 58#endif 59extern char *isdn_v110_revision; 60 61#ifdef CONFIG_ISDN_DIVERSION 62static isdn_divert_if *divert_if; /* = NULL */ 63#endif /* CONFIG_ISDN_DIVERSION */ 64 65 66static int isdn_writebuf_stub(int, int, const u_char __user *, int); 67static void set_global_features(void); 68static int isdn_wildmat(char *s, char *p); 69static int isdn_add_channels(isdn_driver_t *d, int drvidx, int n, int adding); 70 71static inline void 72isdn_lock_driver(isdn_driver_t *drv) 73{ 74 try_module_get(drv->interface->owner); 75 drv->locks++; 76} 77 78void 79isdn_lock_drivers(void) 80{ 81 int i; 82 83 for (i = 0; i < ISDN_MAX_DRIVERS; i++) { 84 if (!dev->drv[i]) 85 continue; 86 isdn_lock_driver(dev->drv[i]); 87 } 88} 89 90static inline void 91isdn_unlock_driver(isdn_driver_t *drv) 92{ 93 if (drv->locks > 0) { 94 drv->locks--; 95 module_put(drv->interface->owner); 96 } 97} 98 99void 100isdn_unlock_drivers(void) 101{ 102 int i; 103 104 for (i = 0; i < ISDN_MAX_DRIVERS; i++) { 105 if (!dev->drv[i]) 106 continue; 107 isdn_unlock_driver(dev->drv[i]); 108 } 109} 110 111#if defined(ISDN_DEBUG_NET_DUMP) || defined(ISDN_DEBUG_MODEM_DUMP) 112void 113isdn_dumppkt(char *s, u_char *p, int len, int dumplen) 114{ 115 int dumpc; 116 117 printk(KERN_DEBUG "%s(%d) ", s, len); 118 for (dumpc = 0; (dumpc < dumplen) && (len); len--, dumpc++) 119 printk(" %02x", *p++); 120 printk("\n"); 121} 122#endif 123 124/* 125 * I picked the pattern-matching-functions from an old GNU-tar version (1.10) 126 * It was originally written and put to PD by rs@mirror.TMC.COM (Rich Salz) 127 */ 128static int 129isdn_star(char *s, char *p) 130{ 131 while (isdn_wildmat(s, p)) { 132 if (*++s == '\0') 133 return (2); 134 } 135 return (0); 136} 137 138/* 139 * Shell-type Pattern-matching for incoming caller-Ids 140 * This function gets a string in s and checks, if it matches the pattern 141 * given in p. 142 * 143 * Return: 144 * 0 = match. 145 * 1 = no match. 146 * 2 = no match. Would eventually match, if s would be longer. 147 * 148 * Possible Patterns: 149 * 150 * '?' matches one character 151 * '*' matches zero or more characters 152 * [xyz] matches the set of characters in brackets. 153 * [^xyz] matches any single character not in the set of characters 154 */ 155 156static int 157isdn_wildmat(char *s, char *p) 158{ 159 register int last; 160 register int matched; 161 register int reverse; 162 register int nostar = 1; 163 164 if (!(*s) && !(*p)) 165 return (1); 166 for (; *p; s++, p++) 167 switch (*p) { 168 case '\\': 169 /* 170 * Literal match with following character, 171 * fall through. 172 */ 173 p++; 174 default: 175 if (*s != *p) 176 return (*s == '\0') ? 2 : 1; 177 continue; 178 case '?': 179 /* Match anything. */ 180 if (*s == '\0') 181 return (2); 182 continue; 183 case '*': 184 nostar = 0; 185 /* Trailing star matches everything. */ 186 return (*++p ? isdn_star(s, p) : 0); 187 case '[': 188 /* [^....] means inverse character class. */ 189 if ((reverse = (p[1] == '^'))) 190 p++; 191 for (last = 0, matched = 0; *++p && (*p != ']'); last = *p) 192 /* This next line requires a good C compiler. */ 193 if (*p == '-' ? *s <= *++p && *s >= last : *s == *p) 194 matched = 1; 195 if (matched == reverse) 196 return (1); 197 continue; 198 } 199 return (*s == '\0') ? 0 : nostar; 200} 201 202int isdn_msncmp(const char *msn1, const char *msn2) 203{ 204 char TmpMsn1[ISDN_MSNLEN]; 205 char TmpMsn2[ISDN_MSNLEN]; 206 char *p; 207 208 for (p = TmpMsn1; *msn1 && *msn1 != ':';) // Strip off a SPID 209 *p++ = *msn1++; 210 *p = '\0'; 211 212 for (p = TmpMsn2; *msn2 && *msn2 != ':';) // Strip off a SPID 213 *p++ = *msn2++; 214 *p = '\0'; 215 216 return isdn_wildmat(TmpMsn1, TmpMsn2); 217} 218 219int 220isdn_dc2minor(int di, int ch) 221{ 222 int i; 223 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 224 if (dev->chanmap[i] == ch && dev->drvmap[i] == di) 225 return i; 226 return -1; 227} 228 229static int isdn_timer_cnt1 = 0; 230static int isdn_timer_cnt2 = 0; 231static int isdn_timer_cnt3 = 0; 232 233static void 234isdn_timer_funct(ulong dummy) 235{ 236 int tf = dev->tflags; 237 if (tf & ISDN_TIMER_FAST) { 238 if (tf & ISDN_TIMER_MODEMREAD) 239 isdn_tty_readmodem(); 240 if (tf & ISDN_TIMER_MODEMPLUS) 241 isdn_tty_modem_escape(); 242 if (tf & ISDN_TIMER_MODEMXMIT) 243 isdn_tty_modem_xmit(); 244 } 245 if (tf & ISDN_TIMER_SLOW) { 246 if (++isdn_timer_cnt1 >= ISDN_TIMER_02SEC) { 247 isdn_timer_cnt1 = 0; 248 if (tf & ISDN_TIMER_NETDIAL) 249 isdn_net_dial(); 250 } 251 if (++isdn_timer_cnt2 >= ISDN_TIMER_1SEC) { 252 isdn_timer_cnt2 = 0; 253 if (tf & ISDN_TIMER_NETHANGUP) 254 isdn_net_autohup(); 255 if (++isdn_timer_cnt3 >= ISDN_TIMER_RINGING) { 256 isdn_timer_cnt3 = 0; 257 if (tf & ISDN_TIMER_MODEMRING) 258 isdn_tty_modem_ring(); 259 } 260 if (tf & ISDN_TIMER_CARRIER) 261 isdn_tty_carrier_timeout(); 262 } 263 } 264 if (tf) 265 mod_timer(&dev->timer, jiffies + ISDN_TIMER_RES); 266} 267 268void 269isdn_timer_ctrl(int tf, int onoff) 270{ 271 unsigned long flags; 272 int old_tflags; 273 274 spin_lock_irqsave(&dev->timerlock, flags); 275 if ((tf & ISDN_TIMER_SLOW) && (!(dev->tflags & ISDN_TIMER_SLOW))) { 276 /* If the slow-timer wasn't activated until now */ 277 isdn_timer_cnt1 = 0; 278 isdn_timer_cnt2 = 0; 279 } 280 old_tflags = dev->tflags; 281 if (onoff) 282 dev->tflags |= tf; 283 else 284 dev->tflags &= ~tf; 285 if (dev->tflags && !old_tflags) 286 mod_timer(&dev->timer, jiffies + ISDN_TIMER_RES); 287 spin_unlock_irqrestore(&dev->timerlock, flags); 288} 289 290/* 291 * Receive a packet from B-Channel. (Called from low-level-module) 292 */ 293static void 294isdn_receive_skb_callback(int di, int channel, struct sk_buff *skb) 295{ 296 int i; 297 298 if ((i = isdn_dc2minor(di, channel)) == -1) { 299 dev_kfree_skb(skb); 300 return; 301 } 302 /* Update statistics */ 303 dev->ibytes[i] += skb->len; 304 305 /* First, try to deliver data to network-device */ 306 if (isdn_net_rcv_skb(i, skb)) 307 return; 308 309 /* V.110 handling 310 * makes sense for async streams only, so it is 311 * called after possible net-device delivery. 312 */ 313 if (dev->v110[i]) { 314 atomic_inc(&dev->v110use[i]); 315 skb = isdn_v110_decode(dev->v110[i], skb); 316 atomic_dec(&dev->v110use[i]); 317 if (!skb) 318 return; 319 } 320 321 /* No network-device found, deliver to tty or raw-channel */ 322 if (skb->len) { 323 if (isdn_tty_rcv_skb(i, di, channel, skb)) 324 return; 325 wake_up_interruptible(&dev->drv[di]->rcv_waitq[channel]); 326 } else 327 dev_kfree_skb(skb); 328} 329 330/* 331 * Intercept command from Linklevel to Lowlevel. 332 * If layer 2 protocol is V.110 and this is not supported by current 333 * lowlevel-driver, use driver's transparent mode and handle V.110 in 334 * linklevel instead. 335 */ 336int 337isdn_command(isdn_ctrl *cmd) 338{ 339 if (cmd->driver == -1) { 340 printk(KERN_WARNING "isdn_command command(%x) driver -1\n", cmd->command); 341 return (1); 342 } 343 if (!dev->drv[cmd->driver]) { 344 printk(KERN_WARNING "isdn_command command(%x) dev->drv[%d] NULL\n", 345 cmd->command, cmd->driver); 346 return (1); 347 } 348 if (!dev->drv[cmd->driver]->interface) { 349 printk(KERN_WARNING "isdn_command command(%x) dev->drv[%d]->interface NULL\n", 350 cmd->command, cmd->driver); 351 return (1); 352 } 353 if (cmd->command == ISDN_CMD_SETL2) { 354 int idx = isdn_dc2minor(cmd->driver, cmd->arg & 255); 355 unsigned long l2prot = (cmd->arg >> 8) & 255; 356 unsigned long features = (dev->drv[cmd->driver]->interface->features 357 >> ISDN_FEATURE_L2_SHIFT) & 358 ISDN_FEATURE_L2_MASK; 359 unsigned long l2_feature = (1 << l2prot); 360 361 switch (l2prot) { 362 case ISDN_PROTO_L2_V11096: 363 case ISDN_PROTO_L2_V11019: 364 case ISDN_PROTO_L2_V11038: 365 /* If V.110 requested, but not supported by 366 * HL-driver, set emulator-flag and change 367 * Layer-2 to transparent 368 */ 369 if (!(features & l2_feature)) { 370 dev->v110emu[idx] = l2prot; 371 cmd->arg = (cmd->arg & 255) | 372 (ISDN_PROTO_L2_TRANS << 8); 373 } else 374 dev->v110emu[idx] = 0; 375 } 376 } 377 return dev->drv[cmd->driver]->interface->command(cmd); 378} 379 380void 381isdn_all_eaz(int di, int ch) 382{ 383 isdn_ctrl cmd; 384 385 if (di < 0) 386 return; 387 cmd.driver = di; 388 cmd.arg = ch; 389 cmd.command = ISDN_CMD_SETEAZ; 390 cmd.parm.num[0] = '\0'; 391 isdn_command(&cmd); 392} 393 394/* 395 * Begin of a CAPI like LL<->HL interface, currently used only for 396 * supplementary service (CAPI 2.0 part III) 397 */ 398#include <linux/isdn/capicmd.h> 399 400static int 401isdn_capi_rec_hl_msg(capi_msg *cm) 402{ 403 switch (cm->Command) { 404 case CAPI_FACILITY: 405 /* in the moment only handled in tty */ 406 return (isdn_tty_capi_facility(cm)); 407 default: 408 return (-1); 409 } 410} 411 412static int 413isdn_status_callback(isdn_ctrl *c) 414{ 415 int di; 416 u_long flags; 417 int i; 418 int r; 419 int retval = 0; 420 isdn_ctrl cmd; 421 isdn_net_dev *p; 422 423 di = c->driver; 424 i = isdn_dc2minor(di, c->arg); 425 switch (c->command) { 426 case ISDN_STAT_BSENT: 427 if (i < 0) 428 return -1; 429 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 430 return 0; 431 if (isdn_net_stat_callback(i, c)) 432 return 0; 433 if (isdn_v110_stat_callback(i, c)) 434 return 0; 435 if (isdn_tty_stat_callback(i, c)) 436 return 0; 437 wake_up_interruptible(&dev->drv[di]->snd_waitq[c->arg]); 438 break; 439 case ISDN_STAT_STAVAIL: 440 dev->drv[di]->stavail += c->arg; 441 wake_up_interruptible(&dev->drv[di]->st_waitq); 442 break; 443 case ISDN_STAT_RUN: 444 dev->drv[di]->flags |= DRV_FLAG_RUNNING; 445 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 446 if (dev->drvmap[i] == di) 447 isdn_all_eaz(di, dev->chanmap[i]); 448 set_global_features(); 449 break; 450 case ISDN_STAT_STOP: 451 dev->drv[di]->flags &= ~DRV_FLAG_RUNNING; 452 break; 453 case ISDN_STAT_ICALL: 454 if (i < 0) 455 return -1; 456#ifdef ISDN_DEBUG_STATCALLB 457 printk(KERN_DEBUG "ICALL (net): %d %ld %s\n", di, c->arg, c->parm.num); 458#endif 459 if (dev->global_flags & ISDN_GLOBAL_STOPPED) { 460 cmd.driver = di; 461 cmd.arg = c->arg; 462 cmd.command = ISDN_CMD_HANGUP; 463 isdn_command(&cmd); 464 return 0; 465 } 466 /* Try to find a network-interface which will accept incoming call */ 467 r = ((c->command == ISDN_STAT_ICALLW) ? 0 : isdn_net_find_icall(di, c->arg, i, &c->parm.setup)); 468 switch (r) { 469 case 0: 470 /* No network-device replies. 471 * Try ttyI's. 472 * These return 0 on no match, 1 on match and 473 * 3 on eventually match, if CID is longer. 474 */ 475 if (c->command == ISDN_STAT_ICALL) 476 if ((retval = isdn_tty_find_icall(di, c->arg, &c->parm.setup))) return (retval); 477#ifdef CONFIG_ISDN_DIVERSION 478 if (divert_if) 479 if ((retval = divert_if->stat_callback(c))) 480 return (retval); /* processed */ 481#endif /* CONFIG_ISDN_DIVERSION */ 482 if ((!retval) && (dev->drv[di]->flags & DRV_FLAG_REJBUS)) { 483 /* No tty responding */ 484 cmd.driver = di; 485 cmd.arg = c->arg; 486 cmd.command = ISDN_CMD_HANGUP; 487 isdn_command(&cmd); 488 retval = 2; 489 } 490 break; 491 case 1: 492 /* Schedule connection-setup */ 493 isdn_net_dial(); 494 cmd.driver = di; 495 cmd.arg = c->arg; 496 cmd.command = ISDN_CMD_ACCEPTD; 497 for (p = dev->netdev; p; p = p->next) 498 if (p->local->isdn_channel == cmd.arg) 499 { 500 strcpy(cmd.parm.setup.eazmsn, p->local->msn); 501 isdn_command(&cmd); 502 retval = 1; 503 break; 504 } 505 break; 506 507 case 2: /* For calling back, first reject incoming call ... */ 508 case 3: /* Interface found, but down, reject call actively */ 509 retval = 2; 510 printk(KERN_INFO "isdn: Rejecting Call\n"); 511 cmd.driver = di; 512 cmd.arg = c->arg; 513 cmd.command = ISDN_CMD_HANGUP; 514 isdn_command(&cmd); 515 if (r == 3) 516 break; 517 /* Fall through */ 518 case 4: 519 /* ... then start callback. */ 520 isdn_net_dial(); 521 break; 522 case 5: 523 /* Number would eventually match, if longer */ 524 retval = 3; 525 break; 526 } 527#ifdef ISDN_DEBUG_STATCALLB 528 printk(KERN_DEBUG "ICALL: ret=%d\n", retval); 529#endif 530 return retval; 531 break; 532 case ISDN_STAT_CINF: 533 if (i < 0) 534 return -1; 535#ifdef ISDN_DEBUG_STATCALLB 536 printk(KERN_DEBUG "CINF: %ld %s\n", c->arg, c->parm.num); 537#endif 538 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 539 return 0; 540 if (strcmp(c->parm.num, "0")) 541 isdn_net_stat_callback(i, c); 542 isdn_tty_stat_callback(i, c); 543 break; 544 case ISDN_STAT_CAUSE: 545#ifdef ISDN_DEBUG_STATCALLB 546 printk(KERN_DEBUG "CAUSE: %ld %s\n", c->arg, c->parm.num); 547#endif 548 printk(KERN_INFO "isdn: %s,ch%ld cause: %s\n", 549 dev->drvid[di], c->arg, c->parm.num); 550 isdn_tty_stat_callback(i, c); 551#ifdef CONFIG_ISDN_DIVERSION 552 if (divert_if) 553 divert_if->stat_callback(c); 554#endif /* CONFIG_ISDN_DIVERSION */ 555 break; 556 case ISDN_STAT_DISPLAY: 557#ifdef ISDN_DEBUG_STATCALLB 558 printk(KERN_DEBUG "DISPLAY: %ld %s\n", c->arg, c->parm.display); 559#endif 560 isdn_tty_stat_callback(i, c); 561#ifdef CONFIG_ISDN_DIVERSION 562 if (divert_if) 563 divert_if->stat_callback(c); 564#endif /* CONFIG_ISDN_DIVERSION */ 565 break; 566 case ISDN_STAT_DCONN: 567 if (i < 0) 568 return -1; 569#ifdef ISDN_DEBUG_STATCALLB 570 printk(KERN_DEBUG "DCONN: %ld\n", c->arg); 571#endif 572 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 573 return 0; 574 /* Find any net-device, waiting for D-channel setup */ 575 if (isdn_net_stat_callback(i, c)) 576 break; 577 isdn_v110_stat_callback(i, c); 578 /* Find any ttyI, waiting for D-channel setup */ 579 if (isdn_tty_stat_callback(i, c)) { 580 cmd.driver = di; 581 cmd.arg = c->arg; 582 cmd.command = ISDN_CMD_ACCEPTB; 583 isdn_command(&cmd); 584 break; 585 } 586 break; 587 case ISDN_STAT_DHUP: 588 if (i < 0) 589 return -1; 590#ifdef ISDN_DEBUG_STATCALLB 591 printk(KERN_DEBUG "DHUP: %ld\n", c->arg); 592#endif 593 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 594 return 0; 595 dev->drv[di]->online &= ~(1 << (c->arg)); 596 isdn_info_update(); 597 /* Signal hangup to network-devices */ 598 if (isdn_net_stat_callback(i, c)) 599 break; 600 isdn_v110_stat_callback(i, c); 601 if (isdn_tty_stat_callback(i, c)) 602 break; 603#ifdef CONFIG_ISDN_DIVERSION 604 if (divert_if) 605 divert_if->stat_callback(c); 606#endif /* CONFIG_ISDN_DIVERSION */ 607 break; 608 break; 609 case ISDN_STAT_BCONN: 610 if (i < 0) 611 return -1; 612#ifdef ISDN_DEBUG_STATCALLB 613 printk(KERN_DEBUG "BCONN: %ld\n", c->arg); 614#endif 615 /* Signal B-channel-connect to network-devices */ 616 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 617 return 0; 618 dev->drv[di]->online |= (1 << (c->arg)); 619 isdn_info_update(); 620 if (isdn_net_stat_callback(i, c)) 621 break; 622 isdn_v110_stat_callback(i, c); 623 if (isdn_tty_stat_callback(i, c)) 624 break; 625 break; 626 case ISDN_STAT_BHUP: 627 if (i < 0) 628 return -1; 629#ifdef ISDN_DEBUG_STATCALLB 630 printk(KERN_DEBUG "BHUP: %ld\n", c->arg); 631#endif 632 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 633 return 0; 634 dev->drv[di]->online &= ~(1 << (c->arg)); 635 isdn_info_update(); 636#ifdef CONFIG_ISDN_X25 637 /* Signal hangup to network-devices */ 638 if (isdn_net_stat_callback(i, c)) 639 break; 640#endif 641 isdn_v110_stat_callback(i, c); 642 if (isdn_tty_stat_callback(i, c)) 643 break; 644 break; 645 case ISDN_STAT_NODCH: 646 if (i < 0) 647 return -1; 648#ifdef ISDN_DEBUG_STATCALLB 649 printk(KERN_DEBUG "NODCH: %ld\n", c->arg); 650#endif 651 if (dev->global_flags & ISDN_GLOBAL_STOPPED) 652 return 0; 653 if (isdn_net_stat_callback(i, c)) 654 break; 655 if (isdn_tty_stat_callback(i, c)) 656 break; 657 break; 658 case ISDN_STAT_ADDCH: 659 spin_lock_irqsave(&dev->lock, flags); 660 if (isdn_add_channels(dev->drv[di], di, c->arg, 1)) { 661 spin_unlock_irqrestore(&dev->lock, flags); 662 return -1; 663 } 664 spin_unlock_irqrestore(&dev->lock, flags); 665 isdn_info_update(); 666 break; 667 case ISDN_STAT_DISCH: 668 spin_lock_irqsave(&dev->lock, flags); 669 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 670 if ((dev->drvmap[i] == di) && 671 (dev->chanmap[i] == c->arg)) { 672 if (c->parm.num[0]) 673 dev->usage[i] &= ~ISDN_USAGE_DISABLED; 674 else 675 if (USG_NONE(dev->usage[i])) { 676 dev->usage[i] |= ISDN_USAGE_DISABLED; 677 } 678 else 679 retval = -1; 680 break; 681 } 682 spin_unlock_irqrestore(&dev->lock, flags); 683 isdn_info_update(); 684 break; 685 case ISDN_STAT_UNLOAD: 686 while (dev->drv[di]->locks > 0) { 687 isdn_unlock_driver(dev->drv[di]); 688 } 689 spin_lock_irqsave(&dev->lock, flags); 690 isdn_tty_stat_callback(i, c); 691 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 692 if (dev->drvmap[i] == di) { 693 dev->drvmap[i] = -1; 694 dev->chanmap[i] = -1; 695 dev->usage[i] &= ~ISDN_USAGE_DISABLED; 696 } 697 dev->drivers--; 698 dev->channels -= dev->drv[di]->channels; 699 kfree(dev->drv[di]->rcverr); 700 kfree(dev->drv[di]->rcvcount); 701 for (i = 0; i < dev->drv[di]->channels; i++) 702 skb_queue_purge(&dev->drv[di]->rpqueue[i]); 703 kfree(dev->drv[di]->rpqueue); 704 kfree(dev->drv[di]->rcv_waitq); 705 kfree(dev->drv[di]); 706 dev->drv[di] = NULL; 707 dev->drvid[di][0] = '\0'; 708 isdn_info_update(); 709 set_global_features(); 710 spin_unlock_irqrestore(&dev->lock, flags); 711 return 0; 712 case ISDN_STAT_L1ERR: 713 break; 714 case CAPI_PUT_MESSAGE: 715 return (isdn_capi_rec_hl_msg(&c->parm.cmsg)); 716#ifdef CONFIG_ISDN_TTY_FAX 717 case ISDN_STAT_FAXIND: 718 isdn_tty_stat_callback(i, c); 719 break; 720#endif 721#ifdef CONFIG_ISDN_AUDIO 722 case ISDN_STAT_AUDIO: 723 isdn_tty_stat_callback(i, c); 724 break; 725#endif 726#ifdef CONFIG_ISDN_DIVERSION 727 case ISDN_STAT_PROT: 728 case ISDN_STAT_REDIR: 729 if (divert_if) 730 return (divert_if->stat_callback(c)); 731#endif /* CONFIG_ISDN_DIVERSION */ 732 default: 733 return -1; 734 } 735 return 0; 736} 737 738/* 739 * Get integer from char-pointer, set pointer to end of number 740 */ 741int 742isdn_getnum(char **p) 743{ 744 int v = -1; 745 746 while (*p[0] >= '0' && *p[0] <= '9') 747 v = ((v < 0) ? 0 : (v * 10)) + (int) ((*p[0]++) - '0'); 748 return v; 749} 750 751#define DLE 0x10 752 753/* 754 * isdn_readbchan() tries to get data from the read-queue. 755 * It MUST be called with interrupts off. 756 * 757 * Be aware that this is not an atomic operation when sleep != 0, even though 758 * interrupts are turned off! Well, like that we are currently only called 759 * on behalf of a read system call on raw device files (which are documented 760 * to be dangerous and for debugging purpose only). The inode semaphore 761 * takes care that this is not called for the same minor device number while 762 * we are sleeping, but access is not serialized against simultaneous read() 763 * from the corresponding ttyI device. Can other ugly events, like changes 764 * of the mapping (di,ch)<->minor, happen during the sleep? --he 765 */ 766int 767isdn_readbchan(int di, int channel, u_char *buf, u_char *fp, int len, wait_queue_head_t *sleep) 768{ 769 int count; 770 int count_pull; 771 int count_put; 772 int dflag; 773 struct sk_buff *skb; 774 u_char *cp; 775 776 if (!dev->drv[di]) 777 return 0; 778 if (skb_queue_empty(&dev->drv[di]->rpqueue[channel])) { 779 if (sleep) 780 wait_event_interruptible(*sleep, 781 !skb_queue_empty(&dev->drv[di]->rpqueue[channel])); 782 else 783 return 0; 784 } 785 if (len > dev->drv[di]->rcvcount[channel]) 786 len = dev->drv[di]->rcvcount[channel]; 787 cp = buf; 788 count = 0; 789 while (len) { 790 if (!(skb = skb_peek(&dev->drv[di]->rpqueue[channel]))) 791 break; 792#ifdef CONFIG_ISDN_AUDIO 793 if (ISDN_AUDIO_SKB_LOCK(skb)) 794 break; 795 ISDN_AUDIO_SKB_LOCK(skb) = 1; 796 if ((ISDN_AUDIO_SKB_DLECOUNT(skb)) || (dev->drv[di]->DLEflag & (1 << channel))) { 797 char *p = skb->data; 798 unsigned long DLEmask = (1 << channel); 799 800 dflag = 0; 801 count_pull = count_put = 0; 802 while ((count_pull < skb->len) && (len > 0)) { 803 len--; 804 if (dev->drv[di]->DLEflag & DLEmask) { 805 *cp++ = DLE; 806 dev->drv[di]->DLEflag &= ~DLEmask; 807 } else { 808 *cp++ = *p; 809 if (*p == DLE) { 810 dev->drv[di]->DLEflag |= DLEmask; 811 (ISDN_AUDIO_SKB_DLECOUNT(skb))--; 812 } 813 p++; 814 count_pull++; 815 } 816 count_put++; 817 } 818 if (count_pull >= skb->len) 819 dflag = 1; 820 } else { 821#endif 822 /* No DLE's in buff, so simply copy it */ 823 dflag = 1; 824 if ((count_pull = skb->len) > len) { 825 count_pull = len; 826 dflag = 0; 827 } 828 count_put = count_pull; 829 skb_copy_from_linear_data(skb, cp, count_put); 830 cp += count_put; 831 len -= count_put; 832#ifdef CONFIG_ISDN_AUDIO 833 } 834#endif 835 count += count_put; 836 if (fp) { 837 memset(fp, 0, count_put); 838 fp += count_put; 839 } 840 if (dflag) { 841 /* We got all the data in this buff. 842 * Now we can dequeue it. 843 */ 844 if (fp) 845 *(fp - 1) = 0xff; 846#ifdef CONFIG_ISDN_AUDIO 847 ISDN_AUDIO_SKB_LOCK(skb) = 0; 848#endif 849 skb = skb_dequeue(&dev->drv[di]->rpqueue[channel]); 850 dev_kfree_skb(skb); 851 } else { 852 /* Not yet emptied this buff, so it 853 * must stay in the queue, for further calls 854 * but we pull off the data we got until now. 855 */ 856 skb_pull(skb, count_pull); 857#ifdef CONFIG_ISDN_AUDIO 858 ISDN_AUDIO_SKB_LOCK(skb) = 0; 859#endif 860 } 861 dev->drv[di]->rcvcount[channel] -= count_put; 862 } 863 return count; 864} 865 866/* 867 * isdn_readbchan_tty() tries to get data from the read-queue. 868 * It MUST be called with interrupts off. 869 * 870 * Be aware that this is not an atomic operation when sleep != 0, even though 871 * interrupts are turned off! Well, like that we are currently only called 872 * on behalf of a read system call on raw device files (which are documented 873 * to be dangerous and for debugging purpose only). The inode semaphore 874 * takes care that this is not called for the same minor device number while 875 * we are sleeping, but access is not serialized against simultaneous read() 876 * from the corresponding ttyI device. Can other ugly events, like changes 877 * of the mapping (di,ch)<->minor, happen during the sleep? --he 878 */ 879int 880isdn_readbchan_tty(int di, int channel, struct tty_port *port, int cisco_hack) 881{ 882 int count; 883 int count_pull; 884 int count_put; 885 int dflag; 886 struct sk_buff *skb; 887 char last = 0; 888 int len; 889 890 if (!dev->drv[di]) 891 return 0; 892 if (skb_queue_empty(&dev->drv[di]->rpqueue[channel])) 893 return 0; 894 895 len = tty_buffer_request_room(port, dev->drv[di]->rcvcount[channel]); 896 if (len == 0) 897 return len; 898 899 count = 0; 900 while (len) { 901 if (!(skb = skb_peek(&dev->drv[di]->rpqueue[channel]))) 902 break; 903#ifdef CONFIG_ISDN_AUDIO 904 if (ISDN_AUDIO_SKB_LOCK(skb)) 905 break; 906 ISDN_AUDIO_SKB_LOCK(skb) = 1; 907 if ((ISDN_AUDIO_SKB_DLECOUNT(skb)) || (dev->drv[di]->DLEflag & (1 << channel))) { 908 char *p = skb->data; 909 unsigned long DLEmask = (1 << channel); 910 911 dflag = 0; 912 count_pull = count_put = 0; 913 while ((count_pull < skb->len) && (len > 0)) { 914 /* push every character but the last to the tty buffer directly */ 915 if (count_put) 916 tty_insert_flip_char(port, last, TTY_NORMAL); 917 len--; 918 if (dev->drv[di]->DLEflag & DLEmask) { 919 last = DLE; 920 dev->drv[di]->DLEflag &= ~DLEmask; 921 } else { 922 last = *p; 923 if (last == DLE) { 924 dev->drv[di]->DLEflag |= DLEmask; 925 (ISDN_AUDIO_SKB_DLECOUNT(skb))--; 926 } 927 p++; 928 count_pull++; 929 } 930 count_put++; 931 } 932 if (count_pull >= skb->len) 933 dflag = 1; 934 } else { 935#endif 936 /* No DLE's in buff, so simply copy it */ 937 dflag = 1; 938 if ((count_pull = skb->len) > len) { 939 count_pull = len; 940 dflag = 0; 941 } 942 count_put = count_pull; 943 if (count_put > 1) 944 tty_insert_flip_string(port, skb->data, count_put - 1); 945 last = skb->data[count_put - 1]; 946 len -= count_put; 947#ifdef CONFIG_ISDN_AUDIO 948 } 949#endif 950 count += count_put; 951 if (dflag) { 952 /* We got all the data in this buff. 953 * Now we can dequeue it. 954 */ 955 if (cisco_hack) 956 tty_insert_flip_char(port, last, 0xFF); 957 else 958 tty_insert_flip_char(port, last, TTY_NORMAL); 959#ifdef CONFIG_ISDN_AUDIO 960 ISDN_AUDIO_SKB_LOCK(skb) = 0; 961#endif 962 skb = skb_dequeue(&dev->drv[di]->rpqueue[channel]); 963 dev_kfree_skb(skb); 964 } else { 965 tty_insert_flip_char(port, last, TTY_NORMAL); 966 /* Not yet emptied this buff, so it 967 * must stay in the queue, for further calls 968 * but we pull off the data we got until now. 969 */ 970 skb_pull(skb, count_pull); 971#ifdef CONFIG_ISDN_AUDIO 972 ISDN_AUDIO_SKB_LOCK(skb) = 0; 973#endif 974 } 975 dev->drv[di]->rcvcount[channel] -= count_put; 976 } 977 return count; 978} 979 980 981static inline int 982isdn_minor2drv(int minor) 983{ 984 return (dev->drvmap[minor]); 985} 986 987static inline int 988isdn_minor2chan(int minor) 989{ 990 return (dev->chanmap[minor]); 991} 992 993static char * 994isdn_statstr(void) 995{ 996 static char istatbuf[2048]; 997 char *p; 998 int i; 999 1000 sprintf(istatbuf, "idmap:\t"); 1001 p = istatbuf + strlen(istatbuf); 1002 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1003 sprintf(p, "%s ", (dev->drvmap[i] < 0) ? "-" : dev->drvid[dev->drvmap[i]]); 1004 p = istatbuf + strlen(istatbuf); 1005 } 1006 sprintf(p, "\nchmap:\t"); 1007 p = istatbuf + strlen(istatbuf); 1008 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1009 sprintf(p, "%d ", dev->chanmap[i]); 1010 p = istatbuf + strlen(istatbuf); 1011 } 1012 sprintf(p, "\ndrmap:\t"); 1013 p = istatbuf + strlen(istatbuf); 1014 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1015 sprintf(p, "%d ", dev->drvmap[i]); 1016 p = istatbuf + strlen(istatbuf); 1017 } 1018 sprintf(p, "\nusage:\t"); 1019 p = istatbuf + strlen(istatbuf); 1020 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1021 sprintf(p, "%d ", dev->usage[i]); 1022 p = istatbuf + strlen(istatbuf); 1023 } 1024 sprintf(p, "\nflags:\t"); 1025 p = istatbuf + strlen(istatbuf); 1026 for (i = 0; i < ISDN_MAX_DRIVERS; i++) { 1027 if (dev->drv[i]) { 1028 sprintf(p, "%ld ", dev->drv[i]->online); 1029 p = istatbuf + strlen(istatbuf); 1030 } else { 1031 sprintf(p, "? "); 1032 p = istatbuf + strlen(istatbuf); 1033 } 1034 } 1035 sprintf(p, "\nphone:\t"); 1036 p = istatbuf + strlen(istatbuf); 1037 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1038 sprintf(p, "%s ", dev->num[i]); 1039 p = istatbuf + strlen(istatbuf); 1040 } 1041 sprintf(p, "\n"); 1042 return istatbuf; 1043} 1044 1045/* Module interface-code */ 1046 1047void 1048isdn_info_update(void) 1049{ 1050 infostruct *p = dev->infochain; 1051 1052 while (p) { 1053 *(p->private) = 1; 1054 p = (infostruct *) p->next; 1055 } 1056 wake_up_interruptible(&(dev->info_waitq)); 1057} 1058 1059static ssize_t 1060isdn_read(struct file *file, char __user *buf, size_t count, loff_t *off) 1061{ 1062 uint minor = iminor(file_inode(file)); 1063 int len = 0; 1064 int drvidx; 1065 int chidx; 1066 int retval; 1067 char *p; 1068 1069 mutex_lock(&isdn_mutex); 1070 if (minor == ISDN_MINOR_STATUS) { 1071 if (!file->private_data) { 1072 if (file->f_flags & O_NONBLOCK) { 1073 retval = -EAGAIN; 1074 goto out; 1075 } 1076 wait_event_interruptible(dev->info_waitq, 1077 file->private_data); 1078 } 1079 p = isdn_statstr(); 1080 file->private_data = NULL; 1081 if ((len = strlen(p)) <= count) { 1082 if (copy_to_user(buf, p, len)) { 1083 retval = -EFAULT; 1084 goto out; 1085 } 1086 *off += len; 1087 retval = len; 1088 goto out; 1089 } 1090 retval = 0; 1091 goto out; 1092 } 1093 if (!dev->drivers) { 1094 retval = -ENODEV; 1095 goto out; 1096 } 1097 if (minor <= ISDN_MINOR_BMAX) { 1098 printk(KERN_WARNING "isdn_read minor %d obsolete!\n", minor); 1099 drvidx = isdn_minor2drv(minor); 1100 if (drvidx < 0) { 1101 retval = -ENODEV; 1102 goto out; 1103 } 1104 if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING)) { 1105 retval = -ENODEV; 1106 goto out; 1107 } 1108 chidx = isdn_minor2chan(minor); 1109 if (!(p = kmalloc(count, GFP_KERNEL))) { 1110 retval = -ENOMEM; 1111 goto out; 1112 } 1113 len = isdn_readbchan(drvidx, chidx, p, NULL, count, 1114 &dev->drv[drvidx]->rcv_waitq[chidx]); 1115 *off += len; 1116 if (copy_to_user(buf, p, len)) 1117 len = -EFAULT; 1118 kfree(p); 1119 retval = len; 1120 goto out; 1121 } 1122 if (minor <= ISDN_MINOR_CTRLMAX) { 1123 drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); 1124 if (drvidx < 0) { 1125 retval = -ENODEV; 1126 goto out; 1127 } 1128 if (!dev->drv[drvidx]->stavail) { 1129 if (file->f_flags & O_NONBLOCK) { 1130 retval = -EAGAIN; 1131 goto out; 1132 } 1133 wait_event_interruptible(dev->drv[drvidx]->st_waitq, 1134 dev->drv[drvidx]->stavail); 1135 } 1136 if (dev->drv[drvidx]->interface->readstat) { 1137 if (count > dev->drv[drvidx]->stavail) 1138 count = dev->drv[drvidx]->stavail; 1139 len = dev->drv[drvidx]->interface->readstat(buf, count, 1140 drvidx, isdn_minor2chan(minor - ISDN_MINOR_CTRL)); 1141 if (len < 0) { 1142 retval = len; 1143 goto out; 1144 } 1145 } else { 1146 len = 0; 1147 } 1148 if (len) 1149 dev->drv[drvidx]->stavail -= len; 1150 else 1151 dev->drv[drvidx]->stavail = 0; 1152 *off += len; 1153 retval = len; 1154 goto out; 1155 } 1156#ifdef CONFIG_ISDN_PPP 1157 if (minor <= ISDN_MINOR_PPPMAX) { 1158 retval = isdn_ppp_read(minor - ISDN_MINOR_PPP, file, buf, count); 1159 goto out; 1160 } 1161#endif 1162 retval = -ENODEV; 1163out: 1164 mutex_unlock(&isdn_mutex); 1165 return retval; 1166} 1167 1168static ssize_t 1169isdn_write(struct file *file, const char __user *buf, size_t count, loff_t *off) 1170{ 1171 uint minor = iminor(file_inode(file)); 1172 int drvidx; 1173 int chidx; 1174 int retval; 1175 1176 if (minor == ISDN_MINOR_STATUS) 1177 return -EPERM; 1178 if (!dev->drivers) 1179 return -ENODEV; 1180 1181 mutex_lock(&isdn_mutex); 1182 if (minor <= ISDN_MINOR_BMAX) { 1183 printk(KERN_WARNING "isdn_write minor %d obsolete!\n", minor); 1184 drvidx = isdn_minor2drv(minor); 1185 if (drvidx < 0) { 1186 retval = -ENODEV; 1187 goto out; 1188 } 1189 if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING)) { 1190 retval = -ENODEV; 1191 goto out; 1192 } 1193 chidx = isdn_minor2chan(minor); 1194 wait_event_interruptible(dev->drv[drvidx]->snd_waitq[chidx], 1195 (retval = isdn_writebuf_stub(drvidx, chidx, buf, count))); 1196 goto out; 1197 } 1198 if (minor <= ISDN_MINOR_CTRLMAX) { 1199 drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); 1200 if (drvidx < 0) { 1201 retval = -ENODEV; 1202 goto out; 1203 } 1204 /* 1205 * We want to use the isdnctrl device to load the firmware 1206 * 1207 if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING)) 1208 return -ENODEV; 1209 */ 1210 if (dev->drv[drvidx]->interface->writecmd) 1211 retval = dev->drv[drvidx]->interface-> 1212 writecmd(buf, count, drvidx, 1213 isdn_minor2chan(minor - ISDN_MINOR_CTRL)); 1214 else 1215 retval = count; 1216 goto out; 1217 } 1218#ifdef CONFIG_ISDN_PPP 1219 if (minor <= ISDN_MINOR_PPPMAX) { 1220 retval = isdn_ppp_write(minor - ISDN_MINOR_PPP, file, buf, count); 1221 goto out; 1222 } 1223#endif 1224 retval = -ENODEV; 1225out: 1226 mutex_unlock(&isdn_mutex); 1227 return retval; 1228} 1229 1230static unsigned int 1231isdn_poll(struct file *file, poll_table *wait) 1232{ 1233 unsigned int mask = 0; 1234 unsigned int minor = iminor(file_inode(file)); 1235 int drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); 1236 1237 mutex_lock(&isdn_mutex); 1238 if (minor == ISDN_MINOR_STATUS) { 1239 poll_wait(file, &(dev->info_waitq), wait); 1240 /* mask = POLLOUT | POLLWRNORM; */ 1241 if (file->private_data) { 1242 mask |= POLLIN | POLLRDNORM; 1243 } 1244 goto out; 1245 } 1246 if (minor >= ISDN_MINOR_CTRL && minor <= ISDN_MINOR_CTRLMAX) { 1247 if (drvidx < 0) { 1248 /* driver deregistered while file open */ 1249 mask = POLLHUP; 1250 goto out; 1251 } 1252 poll_wait(file, &(dev->drv[drvidx]->st_waitq), wait); 1253 mask = POLLOUT | POLLWRNORM; 1254 if (dev->drv[drvidx]->stavail) { 1255 mask |= POLLIN | POLLRDNORM; 1256 } 1257 goto out; 1258 } 1259#ifdef CONFIG_ISDN_PPP 1260 if (minor <= ISDN_MINOR_PPPMAX) { 1261 mask = isdn_ppp_poll(file, wait); 1262 goto out; 1263 } 1264#endif 1265 mask = POLLERR; 1266out: 1267 mutex_unlock(&isdn_mutex); 1268 return mask; 1269} 1270 1271 1272static int 1273isdn_ioctl(struct file *file, uint cmd, ulong arg) 1274{ 1275 uint minor = iminor(file_inode(file)); 1276 isdn_ctrl c; 1277 int drvidx; 1278 int ret; 1279 int i; 1280 char __user *p; 1281 char *s; 1282 union iocpar { 1283 char name[10]; 1284 char bname[22]; 1285 isdn_ioctl_struct iocts; 1286 isdn_net_ioctl_phone phone; 1287 isdn_net_ioctl_cfg cfg; 1288 } iocpar; 1289 void __user *argp = (void __user *)arg; 1290 1291#define name iocpar.name 1292#define bname iocpar.bname 1293#define iocts iocpar.iocts 1294#define phone iocpar.phone 1295#define cfg iocpar.cfg 1296 1297 if (minor == ISDN_MINOR_STATUS) { 1298 switch (cmd) { 1299 case IIOCGETDVR: 1300 return (TTY_DV + 1301 (NET_DV << 8) + 1302 (INF_DV << 16)); 1303 case IIOCGETCPS: 1304 if (arg) { 1305 ulong __user *p = argp; 1306 int i; 1307 if (!access_ok(VERIFY_WRITE, p, 1308 sizeof(ulong) * ISDN_MAX_CHANNELS * 2)) 1309 return -EFAULT; 1310 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1311 put_user(dev->ibytes[i], p++); 1312 put_user(dev->obytes[i], p++); 1313 } 1314 return 0; 1315 } else 1316 return -EINVAL; 1317 break; 1318 case IIOCNETGPN: 1319 /* Get peer phone number of a connected 1320 * isdn network interface */ 1321 if (arg) { 1322 if (copy_from_user(&phone, argp, sizeof(phone))) 1323 return -EFAULT; 1324 return isdn_net_getpeer(&phone, argp); 1325 } else 1326 return -EINVAL; 1327 default: 1328 return -EINVAL; 1329 } 1330 } 1331 if (!dev->drivers) 1332 return -ENODEV; 1333 if (minor <= ISDN_MINOR_BMAX) { 1334 drvidx = isdn_minor2drv(minor); 1335 if (drvidx < 0) 1336 return -ENODEV; 1337 if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING)) 1338 return -ENODEV; 1339 return 0; 1340 } 1341 if (minor <= ISDN_MINOR_CTRLMAX) { 1342/* 1343 * isdn net devices manage lots of configuration variables as linked lists. 1344 * Those lists must only be manipulated from user space. Some of the ioctl's 1345 * service routines access user space and are not atomic. Therefore, ioctl's 1346 * manipulating the lists and ioctl's sleeping while accessing the lists 1347 * are serialized by means of a semaphore. 1348 */ 1349 switch (cmd) { 1350 case IIOCNETDWRSET: 1351 printk(KERN_INFO "INFO: ISDN_DW_ABC_EXTENSION not enabled\n"); 1352 return (-EINVAL); 1353 case IIOCNETLCR: 1354 printk(KERN_INFO "INFO: ISDN_ABC_LCR_SUPPORT not enabled\n"); 1355 return -ENODEV; 1356 case IIOCNETAIF: 1357 /* Add a network-interface */ 1358 if (arg) { 1359 if (copy_from_user(name, argp, sizeof(name))) 1360 return -EFAULT; 1361 s = name; 1362 } else { 1363 s = NULL; 1364 } 1365 ret = mutex_lock_interruptible(&dev->mtx); 1366 if (ret) return ret; 1367 if ((s = isdn_net_new(s, NULL))) { 1368 if (copy_to_user(argp, s, strlen(s) + 1)) { 1369 ret = -EFAULT; 1370 } else { 1371 ret = 0; 1372 } 1373 } else 1374 ret = -ENODEV; 1375 mutex_unlock(&dev->mtx); 1376 return ret; 1377 case IIOCNETASL: 1378 /* Add a slave to a network-interface */ 1379 if (arg) { 1380 if (copy_from_user(bname, argp, sizeof(bname) - 1)) 1381 return -EFAULT; 1382 } else 1383 return -EINVAL; 1384 ret = mutex_lock_interruptible(&dev->mtx); 1385 if (ret) return ret; 1386 if ((s = isdn_net_newslave(bname))) { 1387 if (copy_to_user(argp, s, strlen(s) + 1)) { 1388 ret = -EFAULT; 1389 } else { 1390 ret = 0; 1391 } 1392 } else 1393 ret = -ENODEV; 1394 mutex_unlock(&dev->mtx); 1395 return ret; 1396 case IIOCNETDIF: 1397 /* Delete a network-interface */ 1398 if (arg) { 1399 if (copy_from_user(name, argp, sizeof(name))) 1400 return -EFAULT; 1401 ret = mutex_lock_interruptible(&dev->mtx); 1402 if (ret) return ret; 1403 ret = isdn_net_rm(name); 1404 mutex_unlock(&dev->mtx); 1405 return ret; 1406 } else 1407 return -EINVAL; 1408 case IIOCNETSCF: 1409 /* Set configurable parameters of a network-interface */ 1410 if (arg) { 1411 if (copy_from_user(&cfg, argp, sizeof(cfg))) 1412 return -EFAULT; 1413 return isdn_net_setcfg(&cfg); 1414 } else 1415 return -EINVAL; 1416 case IIOCNETGCF: 1417 /* Get configurable parameters of a network-interface */ 1418 if (arg) { 1419 if (copy_from_user(&cfg, argp, sizeof(cfg))) 1420 return -EFAULT; 1421 if (!(ret = isdn_net_getcfg(&cfg))) { 1422 if (copy_to_user(argp, &cfg, sizeof(cfg))) 1423 return -EFAULT; 1424 } 1425 return ret; 1426 } else 1427 return -EINVAL; 1428 case IIOCNETANM: 1429 /* Add a phone-number to a network-interface */ 1430 if (arg) { 1431 if (copy_from_user(&phone, argp, sizeof(phone))) 1432 return -EFAULT; 1433 ret = mutex_lock_interruptible(&dev->mtx); 1434 if (ret) return ret; 1435 ret = isdn_net_addphone(&phone); 1436 mutex_unlock(&dev->mtx); 1437 return ret; 1438 } else 1439 return -EINVAL; 1440 case IIOCNETGNM: 1441 /* Get list of phone-numbers of a network-interface */ 1442 if (arg) { 1443 if (copy_from_user(&phone, argp, sizeof(phone))) 1444 return -EFAULT; 1445 ret = mutex_lock_interruptible(&dev->mtx); 1446 if (ret) return ret; 1447 ret = isdn_net_getphones(&phone, argp); 1448 mutex_unlock(&dev->mtx); 1449 return ret; 1450 } else 1451 return -EINVAL; 1452 case IIOCNETDNM: 1453 /* Delete a phone-number of a network-interface */ 1454 if (arg) { 1455 if (copy_from_user(&phone, argp, sizeof(phone))) 1456 return -EFAULT; 1457 ret = mutex_lock_interruptible(&dev->mtx); 1458 if (ret) return ret; 1459 ret = isdn_net_delphone(&phone); 1460 mutex_unlock(&dev->mtx); 1461 return ret; 1462 } else 1463 return -EINVAL; 1464 case IIOCNETDIL: 1465 /* Force dialing of a network-interface */ 1466 if (arg) { 1467 if (copy_from_user(name, argp, sizeof(name))) 1468 return -EFAULT; 1469 return isdn_net_force_dial(name); 1470 } else 1471 return -EINVAL; 1472#ifdef CONFIG_ISDN_PPP 1473 case IIOCNETALN: 1474 if (!arg) 1475 return -EINVAL; 1476 if (copy_from_user(name, argp, sizeof(name))) 1477 return -EFAULT; 1478 return isdn_ppp_dial_slave(name); 1479 case IIOCNETDLN: 1480 if (!arg) 1481 return -EINVAL; 1482 if (copy_from_user(name, argp, sizeof(name))) 1483 return -EFAULT; 1484 return isdn_ppp_hangup_slave(name); 1485#endif 1486 case IIOCNETHUP: 1487 /* Force hangup of a network-interface */ 1488 if (!arg) 1489 return -EINVAL; 1490 if (copy_from_user(name, argp, sizeof(name))) 1491 return -EFAULT; 1492 return isdn_net_force_hangup(name); 1493 break; 1494 case IIOCSETVER: 1495 dev->net_verbose = arg; 1496 printk(KERN_INFO "isdn: Verbose-Level is %d\n", dev->net_verbose); 1497 return 0; 1498 case IIOCSETGST: 1499 if (arg) 1500 dev->global_flags |= ISDN_GLOBAL_STOPPED; 1501 else 1502 dev->global_flags &= ~ISDN_GLOBAL_STOPPED; 1503 printk(KERN_INFO "isdn: Global Mode %s\n", 1504 (dev->global_flags & ISDN_GLOBAL_STOPPED) ? "stopped" : "running"); 1505 return 0; 1506 case IIOCSETBRJ: 1507 drvidx = -1; 1508 if (arg) { 1509 int i; 1510 char *p; 1511 if (copy_from_user(&iocts, argp, 1512 sizeof(isdn_ioctl_struct))) 1513 return -EFAULT; 1514 iocts.drvid[sizeof(iocts.drvid) - 1] = 0; 1515 if (strlen(iocts.drvid)) { 1516 if ((p = strchr(iocts.drvid, ','))) 1517 *p = 0; 1518 drvidx = -1; 1519 for (i = 0; i < ISDN_MAX_DRIVERS; i++) 1520 if (!(strcmp(dev->drvid[i], iocts.drvid))) { 1521 drvidx = i; 1522 break; 1523 } 1524 } 1525 } 1526 if (drvidx == -1) 1527 return -ENODEV; 1528 if (iocts.arg) 1529 dev->drv[drvidx]->flags |= DRV_FLAG_REJBUS; 1530 else 1531 dev->drv[drvidx]->flags &= ~DRV_FLAG_REJBUS; 1532 return 0; 1533 case IIOCSIGPRF: 1534 dev->profd = current; 1535 return 0; 1536 break; 1537 case IIOCGETPRF: 1538 /* Get all Modem-Profiles */ 1539 if (arg) { 1540 char __user *p = argp; 1541 int i; 1542 1543 if (!access_ok(VERIFY_WRITE, argp, 1544 (ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN) 1545 * ISDN_MAX_CHANNELS)) 1546 return -EFAULT; 1547 1548 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1549 if (copy_to_user(p, dev->mdm.info[i].emu.profile, 1550 ISDN_MODEM_NUMREG)) 1551 return -EFAULT; 1552 p += ISDN_MODEM_NUMREG; 1553 if (copy_to_user(p, dev->mdm.info[i].emu.pmsn, ISDN_MSNLEN)) 1554 return -EFAULT; 1555 p += ISDN_MSNLEN; 1556 if (copy_to_user(p, dev->mdm.info[i].emu.plmsn, ISDN_LMSNLEN)) 1557 return -EFAULT; 1558 p += ISDN_LMSNLEN; 1559 } 1560 return (ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN) * ISDN_MAX_CHANNELS; 1561 } else 1562 return -EINVAL; 1563 break; 1564 case IIOCSETPRF: 1565 /* Set all Modem-Profiles */ 1566 if (arg) { 1567 char __user *p = argp; 1568 int i; 1569 1570 if (!access_ok(VERIFY_READ, argp, 1571 (ISDN_MODEM_NUMREG + ISDN_MSNLEN + ISDN_LMSNLEN) 1572 * ISDN_MAX_CHANNELS)) 1573 return -EFAULT; 1574 1575 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 1576 if (copy_from_user(dev->mdm.info[i].emu.profile, p, 1577 ISDN_MODEM_NUMREG)) 1578 return -EFAULT; 1579 p += ISDN_MODEM_NUMREG; 1580 if (copy_from_user(dev->mdm.info[i].emu.plmsn, p, ISDN_LMSNLEN)) 1581 return -EFAULT; 1582 p += ISDN_LMSNLEN; 1583 if (copy_from_user(dev->mdm.info[i].emu.pmsn, p, ISDN_MSNLEN)) 1584 return -EFAULT; 1585 p += ISDN_MSNLEN; 1586 } 1587 return 0; 1588 } else 1589 return -EINVAL; 1590 break; 1591 case IIOCSETMAP: 1592 case IIOCGETMAP: 1593 /* Set/Get MSN->EAZ-Mapping for a driver */ 1594 if (arg) { 1595 1596 if (copy_from_user(&iocts, argp, 1597 sizeof(isdn_ioctl_struct))) 1598 return -EFAULT; 1599 iocts.drvid[sizeof(iocts.drvid) - 1] = 0; 1600 if (strlen(iocts.drvid)) { 1601 drvidx = -1; 1602 for (i = 0; i < ISDN_MAX_DRIVERS; i++) 1603 if (!(strcmp(dev->drvid[i], iocts.drvid))) { 1604 drvidx = i; 1605 break; 1606 } 1607 } else 1608 drvidx = 0; 1609 if (drvidx == -1) 1610 return -ENODEV; 1611 if (cmd == IIOCSETMAP) { 1612 int loop = 1; 1613 1614 p = (char __user *) iocts.arg; 1615 i = 0; 1616 while (loop) { 1617 int j = 0; 1618 1619 while (1) { 1620 if (!access_ok(VERIFY_READ, p, 1)) 1621 return -EFAULT; 1622 get_user(bname[j], p++); 1623 switch (bname[j]) { 1624 case '\0': 1625 loop = 0; 1626 /* Fall through */ 1627 case ',': 1628 bname[j] = '\0'; 1629 strcpy(dev->drv[drvidx]->msn2eaz[i], bname); 1630 j = ISDN_MSNLEN; 1631 break; 1632 default: 1633 j++; 1634 } 1635 if (j >= ISDN_MSNLEN) 1636 break; 1637 } 1638 if (++i > 9) 1639 break; 1640 } 1641 } else { 1642 p = (char __user *) iocts.arg; 1643 for (i = 0; i < 10; i++) { 1644 snprintf(bname, sizeof(bname), "%s%s", 1645 strlen(dev->drv[drvidx]->msn2eaz[i]) ? 1646 dev->drv[drvidx]->msn2eaz[i] : "_", 1647 (i < 9) ? "," : "\0"); 1648 if (copy_to_user(p, bname, strlen(bname) + 1)) 1649 return -EFAULT; 1650 p += strlen(bname); 1651 } 1652 } 1653 return 0; 1654 } else 1655 return -EINVAL; 1656 case IIOCDBGVAR: 1657 if (arg) { 1658 if (copy_to_user(argp, &dev, sizeof(ulong))) 1659 return -EFAULT; 1660 return 0; 1661 } else 1662 return -EINVAL; 1663 break; 1664 default: 1665 if ((cmd & IIOCDRVCTL) == IIOCDRVCTL) 1666 cmd = ((cmd >> _IOC_NRSHIFT) & _IOC_NRMASK) & ISDN_DRVIOCTL_MASK; 1667 else 1668 return -EINVAL; 1669 if (arg) { 1670 int i; 1671 char *p; 1672 if (copy_from_user(&iocts, argp, sizeof(isdn_ioctl_struct))) 1673 return -EFAULT; 1674 iocts.drvid[sizeof(iocts.drvid) - 1] = 0; 1675 if (strlen(iocts.drvid)) { 1676 if ((p = strchr(iocts.drvid, ','))) 1677 *p = 0; 1678 drvidx = -1; 1679 for (i = 0; i < ISDN_MAX_DRIVERS; i++) 1680 if (!(strcmp(dev->drvid[i], iocts.drvid))) { 1681 drvidx = i; 1682 break; 1683 } 1684 } else 1685 drvidx = 0; 1686 if (drvidx == -1) 1687 return -ENODEV; 1688 if (!access_ok(VERIFY_WRITE, argp, 1689 sizeof(isdn_ioctl_struct))) 1690 return -EFAULT; 1691 c.driver = drvidx; 1692 c.command = ISDN_CMD_IOCTL; 1693 c.arg = cmd; 1694 memcpy(c.parm.num, &iocts.arg, sizeof(ulong)); 1695 ret = isdn_command(&c); 1696 memcpy(&iocts.arg, c.parm.num, sizeof(ulong)); 1697 if (copy_to_user(argp, &iocts, sizeof(isdn_ioctl_struct))) 1698 return -EFAULT; 1699 return ret; 1700 } else 1701 return -EINVAL; 1702 } 1703 } 1704#ifdef CONFIG_ISDN_PPP 1705 if (minor <= ISDN_MINOR_PPPMAX) 1706 return (isdn_ppp_ioctl(minor - ISDN_MINOR_PPP, file, cmd, arg)); 1707#endif 1708 return -ENODEV; 1709 1710#undef name 1711#undef bname 1712#undef iocts 1713#undef phone 1714#undef cfg 1715} 1716 1717static long 1718isdn_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 1719{ 1720 int ret; 1721 1722 mutex_lock(&isdn_mutex); 1723 ret = isdn_ioctl(file, cmd, arg); 1724 mutex_unlock(&isdn_mutex); 1725 1726 return ret; 1727} 1728 1729/* 1730 * Open the device code. 1731 */ 1732static int 1733isdn_open(struct inode *ino, struct file *filep) 1734{ 1735 uint minor = iminor(ino); 1736 int drvidx; 1737 int chidx; 1738 int retval = -ENODEV; 1739 1740 mutex_lock(&isdn_mutex); 1741 if (minor == ISDN_MINOR_STATUS) { 1742 infostruct *p; 1743 1744 if ((p = kmalloc(sizeof(infostruct), GFP_KERNEL))) { 1745 p->next = (char *) dev->infochain; 1746 p->private = (char *) &(filep->private_data); 1747 dev->infochain = p; 1748 /* At opening we allow a single update */ 1749 filep->private_data = (char *) 1; 1750 retval = 0; 1751 goto out; 1752 } else { 1753 retval = -ENOMEM; 1754 goto out; 1755 } 1756 } 1757 if (!dev->channels) 1758 goto out; 1759 if (minor <= ISDN_MINOR_BMAX) { 1760 printk(KERN_WARNING "isdn_open minor %d obsolete!\n", minor); 1761 drvidx = isdn_minor2drv(minor); 1762 if (drvidx < 0) 1763 goto out; 1764 chidx = isdn_minor2chan(minor); 1765 if (!(dev->drv[drvidx]->flags & DRV_FLAG_RUNNING)) 1766 goto out; 1767 if (!(dev->drv[drvidx]->online & (1 << chidx))) 1768 goto out; 1769 isdn_lock_drivers(); 1770 retval = 0; 1771 goto out; 1772 } 1773 if (minor <= ISDN_MINOR_CTRLMAX) { 1774 drvidx = isdn_minor2drv(minor - ISDN_MINOR_CTRL); 1775 if (drvidx < 0) 1776 goto out; 1777 isdn_lock_drivers(); 1778 retval = 0; 1779 goto out; 1780 } 1781#ifdef CONFIG_ISDN_PPP 1782 if (minor <= ISDN_MINOR_PPPMAX) { 1783 retval = isdn_ppp_open(minor - ISDN_MINOR_PPP, filep); 1784 if (retval == 0) 1785 isdn_lock_drivers(); 1786 goto out; 1787 } 1788#endif 1789out: 1790 nonseekable_open(ino, filep); 1791 mutex_unlock(&isdn_mutex); 1792 return retval; 1793} 1794 1795static int 1796isdn_close(struct inode *ino, struct file *filep) 1797{ 1798 uint minor = iminor(ino); 1799 1800 mutex_lock(&isdn_mutex); 1801 if (minor == ISDN_MINOR_STATUS) { 1802 infostruct *p = dev->infochain; 1803 infostruct *q = NULL; 1804 1805 while (p) { 1806 if (p->private == (char *) &(filep->private_data)) { 1807 if (q) 1808 q->next = p->next; 1809 else 1810 dev->infochain = (infostruct *) (p->next); 1811 kfree(p); 1812 goto out; 1813 } 1814 q = p; 1815 p = (infostruct *) (p->next); 1816 } 1817 printk(KERN_WARNING "isdn: No private data while closing isdnctrl\n"); 1818 goto out; 1819 } 1820 isdn_unlock_drivers(); 1821 if (minor <= ISDN_MINOR_BMAX) 1822 goto out; 1823 if (minor <= ISDN_MINOR_CTRLMAX) { 1824 if (dev->profd == current) 1825 dev->profd = NULL; 1826 goto out; 1827 } 1828#ifdef CONFIG_ISDN_PPP 1829 if (minor <= ISDN_MINOR_PPPMAX) 1830 isdn_ppp_release(minor - ISDN_MINOR_PPP, filep); 1831#endif 1832 1833out: 1834 mutex_unlock(&isdn_mutex); 1835 return 0; 1836} 1837 1838static const struct file_operations isdn_fops = 1839{ 1840 .owner = THIS_MODULE, 1841 .llseek = no_llseek, 1842 .read = isdn_read, 1843 .write = isdn_write, 1844 .poll = isdn_poll, 1845 .unlocked_ioctl = isdn_unlocked_ioctl, 1846 .open = isdn_open, 1847 .release = isdn_close, 1848}; 1849 1850char * 1851isdn_map_eaz2msn(char *msn, int di) 1852{ 1853 isdn_driver_t *this = dev->drv[di]; 1854 int i; 1855 1856 if (strlen(msn) == 1) { 1857 i = msn[0] - '0'; 1858 if ((i >= 0) && (i <= 9)) 1859 if (strlen(this->msn2eaz[i])) 1860 return (this->msn2eaz[i]); 1861 } 1862 return (msn); 1863} 1864 1865/* 1866 * Find an unused ISDN-channel, whose feature-flags match the 1867 * given L2- and L3-protocols. 1868 */ 1869#define L2V (~(ISDN_FEATURE_L2_V11096 | ISDN_FEATURE_L2_V11019 | ISDN_FEATURE_L2_V11038)) 1870 1871/* 1872 * This function must be called with holding the dev->lock. 1873 */ 1874int 1875isdn_get_free_channel(int usage, int l2_proto, int l3_proto, int pre_dev 1876 , int pre_chan, char *msn) 1877{ 1878 int i; 1879 ulong features; 1880 ulong vfeatures; 1881 1882 features = ((1 << l2_proto) | (0x10000 << l3_proto)); 1883 vfeatures = (((1 << l2_proto) | (0x10000 << l3_proto)) & 1884 ~(ISDN_FEATURE_L2_V11096 | ISDN_FEATURE_L2_V11019 | ISDN_FEATURE_L2_V11038)); 1885 /* If Layer-2 protocol is V.110, accept drivers with 1886 * transparent feature even if these don't support V.110 1887 * because we can emulate this in linklevel. 1888 */ 1889 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 1890 if (USG_NONE(dev->usage[i]) && 1891 (dev->drvmap[i] != -1)) { 1892 int d = dev->drvmap[i]; 1893 if ((dev->usage[i] & ISDN_USAGE_EXCLUSIVE) && 1894 ((pre_dev != d) || (pre_chan != dev->chanmap[i]))) 1895 continue; 1896 if (!strcmp(isdn_map_eaz2msn(msn, d), "-")) 1897 continue; 1898 if (dev->usage[i] & ISDN_USAGE_DISABLED) 1899 continue; /* usage not allowed */ 1900 if (dev->drv[d]->flags & DRV_FLAG_RUNNING) { 1901 if (((dev->drv[d]->interface->features & features) == features) || 1902 (((dev->drv[d]->interface->features & vfeatures) == vfeatures) && 1903 (dev->drv[d]->interface->features & ISDN_FEATURE_L2_TRANS))) { 1904 if ((pre_dev < 0) || (pre_chan < 0)) { 1905 dev->usage[i] &= ISDN_USAGE_EXCLUSIVE; 1906 dev->usage[i] |= usage; 1907 isdn_info_update(); 1908 return i; 1909 } else { 1910 if ((pre_dev == d) && (pre_chan == dev->chanmap[i])) { 1911 dev->usage[i] &= ISDN_USAGE_EXCLUSIVE; 1912 dev->usage[i] |= usage; 1913 isdn_info_update(); 1914 return i; 1915 } 1916 } 1917 } 1918 } 1919 } 1920 return -1; 1921} 1922 1923/* 1924 * Set state of ISDN-channel to 'unused' 1925 */ 1926void 1927isdn_free_channel(int di, int ch, int usage) 1928{ 1929 int i; 1930 1931 if ((di < 0) || (ch < 0)) { 1932 printk(KERN_WARNING "%s: called with invalid drv(%d) or channel(%d)\n", 1933 __func__, di, ch); 1934 return; 1935 } 1936 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 1937 if (((!usage) || ((dev->usage[i] & ISDN_USAGE_MASK) == usage)) && 1938 (dev->drvmap[i] == di) && 1939 (dev->chanmap[i] == ch)) { 1940 dev->usage[i] &= (ISDN_USAGE_NONE | ISDN_USAGE_EXCLUSIVE); 1941 strcpy(dev->num[i], "???"); 1942 dev->ibytes[i] = 0; 1943 dev->obytes[i] = 0; 1944// 20.10.99 JIM, try to reinitialize v110 ! 1945 dev->v110emu[i] = 0; 1946 atomic_set(&(dev->v110use[i]), 0); 1947 isdn_v110_close(dev->v110[i]); 1948 dev->v110[i] = NULL; 1949// 20.10.99 JIM, try to reinitialize v110 ! 1950 isdn_info_update(); 1951 if (dev->drv[di]) 1952 skb_queue_purge(&dev->drv[di]->rpqueue[ch]); 1953 } 1954} 1955 1956/* 1957 * Cancel Exclusive-Flag for ISDN-channel 1958 */ 1959void 1960isdn_unexclusive_channel(int di, int ch) 1961{ 1962 int i; 1963 1964 for (i = 0; i < ISDN_MAX_CHANNELS; i++) 1965 if ((dev->drvmap[i] == di) && 1966 (dev->chanmap[i] == ch)) { 1967 dev->usage[i] &= ~ISDN_USAGE_EXCLUSIVE; 1968 isdn_info_update(); 1969 return; 1970 } 1971} 1972 1973/* 1974 * writebuf replacement for SKB_ABLE drivers 1975 */ 1976static int 1977isdn_writebuf_stub(int drvidx, int chan, const u_char __user *buf, int len) 1978{ 1979 int ret; 1980 int hl = dev->drv[drvidx]->interface->hl_hdrlen; 1981 struct sk_buff *skb = alloc_skb(hl + len, GFP_ATOMIC); 1982 1983 if (!skb) 1984 return -ENOMEM; 1985 skb_reserve(skb, hl); 1986 if (copy_from_user(skb_put(skb, len), buf, len)) { 1987 dev_kfree_skb(skb); 1988 return -EFAULT; 1989 } 1990 ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, 1, skb); 1991 if (ret <= 0) 1992 dev_kfree_skb(skb); 1993 if (ret > 0) 1994 dev->obytes[isdn_dc2minor(drvidx, chan)] += ret; 1995 return ret; 1996} 1997 1998/* 1999 * Return: length of data on success, -ERRcode on failure. 2000 */ 2001int 2002isdn_writebuf_skb_stub(int drvidx, int chan, int ack, struct sk_buff *skb) 2003{ 2004 int ret; 2005 struct sk_buff *nskb = NULL; 2006 int v110_ret = skb->len; 2007 int idx = isdn_dc2minor(drvidx, chan); 2008 2009 if (dev->v110[idx]) { 2010 atomic_inc(&dev->v110use[idx]); 2011 nskb = isdn_v110_encode(dev->v110[idx], skb); 2012 atomic_dec(&dev->v110use[idx]); 2013 if (!nskb) 2014 return 0; 2015 v110_ret = *((int *)nskb->data); 2016 skb_pull(nskb, sizeof(int)); 2017 if (!nskb->len) { 2018 dev_kfree_skb(nskb); 2019 return v110_ret; 2020 } 2021 /* V.110 must always be acknowledged */ 2022 ack = 1; 2023 ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, ack, nskb); 2024 } else { 2025 int hl = dev->drv[drvidx]->interface->hl_hdrlen; 2026 2027 if (skb_headroom(skb) < hl) { 2028 /* 2029 * This should only occur when new HL driver with 2030 * increased hl_hdrlen was loaded after netdevice 2031 * was created and connected to the new driver. 2032 * 2033 * The V.110 branch (re-allocates on its own) does 2034 * not need this 2035 */ 2036 struct sk_buff *skb_tmp; 2037 2038 skb_tmp = skb_realloc_headroom(skb, hl); 2039 printk(KERN_DEBUG "isdn_writebuf_skb_stub: reallocating headroom%s\n", skb_tmp ? "" : " failed"); 2040 if (!skb_tmp) return -ENOMEM; /* 0 better? */ 2041 ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, ack, skb_tmp); 2042 if (ret > 0) { 2043 dev_kfree_skb(skb); 2044 } else { 2045 dev_kfree_skb(skb_tmp); 2046 } 2047 } else { 2048 ret = dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, ack, skb); 2049 } 2050 } 2051 if (ret > 0) { 2052 dev->obytes[idx] += ret; 2053 if (dev->v110[idx]) { 2054 atomic_inc(&dev->v110use[idx]); 2055 dev->v110[idx]->skbuser++; 2056 atomic_dec(&dev->v110use[idx]); 2057 /* For V.110 return unencoded data length */ 2058 ret = v110_ret; 2059 /* if the complete frame was send we free the skb; 2060 if not upper function will requeue the skb */ 2061 if (ret == skb->len) 2062 dev_kfree_skb(skb); 2063 } 2064 } else 2065 if (dev->v110[idx]) 2066 dev_kfree_skb(nskb); 2067 return ret; 2068} 2069 2070static int 2071isdn_add_channels(isdn_driver_t *d, int drvidx, int n, int adding) 2072{ 2073 int j, k, m; 2074 2075 init_waitqueue_head(&d->st_waitq); 2076 if (d->flags & DRV_FLAG_RUNNING) 2077 return -1; 2078 if (n < 1) return 0; 2079 2080 m = (adding) ? d->channels + n : n; 2081 2082 if (dev->channels + n > ISDN_MAX_CHANNELS) { 2083 printk(KERN_WARNING "register_isdn: Max. %d channels supported\n", 2084 ISDN_MAX_CHANNELS); 2085 return -1; 2086 } 2087 2088 if ((adding) && (d->rcverr)) 2089 kfree(d->rcverr); 2090 if (!(d->rcverr = kzalloc(sizeof(int) * m, GFP_ATOMIC))) { 2091 printk(KERN_WARNING "register_isdn: Could not alloc rcverr\n"); 2092 return -1; 2093 } 2094 2095 if ((adding) && (d->rcvcount)) 2096 kfree(d->rcvcount); 2097 if (!(d->rcvcount = kzalloc(sizeof(int) * m, GFP_ATOMIC))) { 2098 printk(KERN_WARNING "register_isdn: Could not alloc rcvcount\n"); 2099 if (!adding) 2100 kfree(d->rcverr); 2101 return -1; 2102 } 2103 2104 if ((adding) && (d->rpqueue)) { 2105 for (j = 0; j < d->channels; j++) 2106 skb_queue_purge(&d->rpqueue[j]); 2107 kfree(d->rpqueue); 2108 } 2109 if (!(d->rpqueue = kmalloc(sizeof(struct sk_buff_head) * m, GFP_ATOMIC))) { 2110 printk(KERN_WARNING "register_isdn: Could not alloc rpqueue\n"); 2111 if (!adding) { 2112 kfree(d->rcvcount); 2113 kfree(d->rcverr); 2114 } 2115 return -1; 2116 } 2117 for (j = 0; j < m; j++) { 2118 skb_queue_head_init(&d->rpqueue[j]); 2119 } 2120 2121 if ((adding) && (d->rcv_waitq)) 2122 kfree(d->rcv_waitq); 2123 d->rcv_waitq = kmalloc(sizeof(wait_queue_head_t) * 2 * m, GFP_ATOMIC); 2124 if (!d->rcv_waitq) { 2125 printk(KERN_WARNING "register_isdn: Could not alloc rcv_waitq\n"); 2126 if (!adding) { 2127 kfree(d->rpqueue); 2128 kfree(d->rcvcount); 2129 kfree(d->rcverr); 2130 } 2131 return -1; 2132 } 2133 d->snd_waitq = d->rcv_waitq + m; 2134 for (j = 0; j < m; j++) { 2135 init_waitqueue_head(&d->rcv_waitq[j]); 2136 init_waitqueue_head(&d->snd_waitq[j]); 2137 } 2138 2139 dev->channels += n; 2140 for (j = d->channels; j < m; j++) 2141 for (k = 0; k < ISDN_MAX_CHANNELS; k++) 2142 if (dev->chanmap[k] < 0) { 2143 dev->chanmap[k] = j; 2144 dev->drvmap[k] = drvidx; 2145 break; 2146 } 2147 d->channels = m; 2148 return 0; 2149} 2150 2151/* 2152 * Low-level-driver registration 2153 */ 2154 2155static void 2156set_global_features(void) 2157{ 2158 int drvidx; 2159 2160 dev->global_features = 0; 2161 for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++) { 2162 if (!dev->drv[drvidx]) 2163 continue; 2164 if (dev->drv[drvidx]->interface) 2165 dev->global_features |= dev->drv[drvidx]->interface->features; 2166 } 2167} 2168 2169#ifdef CONFIG_ISDN_DIVERSION 2170 2171static char *map_drvname(int di) 2172{ 2173 if ((di < 0) || (di >= ISDN_MAX_DRIVERS)) 2174 return (NULL); 2175 return (dev->drvid[di]); /* driver name */ 2176} /* map_drvname */ 2177 2178static int map_namedrv(char *id) 2179{ int i; 2180 2181 for (i = 0; i < ISDN_MAX_DRIVERS; i++) 2182 { if (!strcmp(dev->drvid[i], id)) 2183 return (i); 2184 } 2185 return (-1); 2186} /* map_namedrv */ 2187 2188int DIVERT_REG_NAME(isdn_divert_if *i_div) 2189{ 2190 if (i_div->if_magic != DIVERT_IF_MAGIC) 2191 return (DIVERT_VER_ERR); 2192 switch (i_div->cmd) 2193 { 2194 case DIVERT_CMD_REL: 2195 if (divert_if != i_div) 2196 return (DIVERT_REL_ERR); 2197 divert_if = NULL; /* free interface */ 2198 return (DIVERT_NO_ERR); 2199 2200 case DIVERT_CMD_REG: 2201 if (divert_if) 2202 return (DIVERT_REG_ERR); 2203 i_div->ll_cmd = isdn_command; /* set command function */ 2204 i_div->drv_to_name = map_drvname; 2205 i_div->name_to_drv = map_namedrv; 2206 divert_if = i_div; /* remember interface */ 2207 return (DIVERT_NO_ERR); 2208 2209 default: 2210 return (DIVERT_CMD_ERR); 2211 } 2212} /* DIVERT_REG_NAME */ 2213 2214EXPORT_SYMBOL(DIVERT_REG_NAME); 2215 2216#endif /* CONFIG_ISDN_DIVERSION */ 2217 2218 2219EXPORT_SYMBOL(register_isdn); 2220#ifdef CONFIG_ISDN_PPP 2221EXPORT_SYMBOL(isdn_ppp_register_compressor); 2222EXPORT_SYMBOL(isdn_ppp_unregister_compressor); 2223#endif 2224 2225int 2226register_isdn(isdn_if *i) 2227{ 2228 isdn_driver_t *d; 2229 int j; 2230 ulong flags; 2231 int drvidx; 2232 2233 if (dev->drivers >= ISDN_MAX_DRIVERS) { 2234 printk(KERN_WARNING "register_isdn: Max. %d drivers supported\n", 2235 ISDN_MAX_DRIVERS); 2236 return 0; 2237 } 2238 if (!i->writebuf_skb) { 2239 printk(KERN_WARNING "register_isdn: No write routine given.\n"); 2240 return 0; 2241 } 2242 if (!(d = kzalloc(sizeof(isdn_driver_t), GFP_KERNEL))) { 2243 printk(KERN_WARNING "register_isdn: Could not alloc driver-struct\n"); 2244 return 0; 2245 } 2246 2247 d->maxbufsize = i->maxbufsize; 2248 d->pktcount = 0; 2249 d->stavail = 0; 2250 d->flags = DRV_FLAG_LOADED; 2251 d->online = 0; 2252 d->interface = i; 2253 d->channels = 0; 2254 spin_lock_irqsave(&dev->lock, flags); 2255 for (drvidx = 0; drvidx < ISDN_MAX_DRIVERS; drvidx++) 2256 if (!dev->drv[drvidx]) 2257 break; 2258 if (isdn_add_channels(d, drvidx, i->channels, 0)) { 2259 spin_unlock_irqrestore(&dev->lock, flags); 2260 kfree(d); 2261 return 0; 2262 } 2263 i->channels = drvidx; 2264 i->rcvcallb_skb = isdn_receive_skb_callback; 2265 i->statcallb = isdn_status_callback; 2266 if (!strlen(i->id)) 2267 sprintf(i->id, "line%d", drvidx); 2268 for (j = 0; j < drvidx; j++) 2269 if (!strcmp(i->id, dev->drvid[j])) 2270 sprintf(i->id, "line%d", drvidx); 2271 dev->drv[drvidx] = d; 2272 strcpy(dev->drvid[drvidx], i->id); 2273 isdn_info_update(); 2274 dev->drivers++; 2275 set_global_features(); 2276 spin_unlock_irqrestore(&dev->lock, flags); 2277 return 1; 2278} 2279 2280/* 2281***************************************************************************** 2282* And now the modules code. 2283***************************************************************************** 2284*/ 2285 2286static char * 2287isdn_getrev(const char *revision) 2288{ 2289 char *rev; 2290 char *p; 2291 2292 if ((p = strchr(revision, ':'))) { 2293 rev = p + 2; 2294 p = strchr(rev, '$'); 2295 *--p = 0; 2296 } else 2297 rev = "???"; 2298 return rev; 2299} 2300 2301/* 2302 * Allocate and initialize all data, register modem-devices 2303 */ 2304static int __init isdn_init(void) 2305{ 2306 int i; 2307 char tmprev[50]; 2308 2309 dev = vzalloc(sizeof(isdn_dev)); 2310 if (!dev) { 2311 printk(KERN_WARNING "isdn: Could not allocate device-struct.\n"); 2312 return -EIO; 2313 } 2314 init_timer(&dev->timer); 2315 dev->timer.function = isdn_timer_funct; 2316 spin_lock_init(&dev->lock); 2317 spin_lock_init(&dev->timerlock); 2318#ifdef MODULE 2319 dev->owner = THIS_MODULE; 2320#endif 2321 mutex_init(&dev->mtx); 2322 init_waitqueue_head(&dev->info_waitq); 2323 for (i = 0; i < ISDN_MAX_CHANNELS; i++) { 2324 dev->drvmap[i] = -1; 2325 dev->chanmap[i] = -1; 2326 dev->m_idx[i] = -1; 2327 strcpy(dev->num[i], "???"); 2328 } 2329 if (register_chrdev(ISDN_MAJOR, "isdn", &isdn_fops)) { 2330 printk(KERN_WARNING "isdn: Could not register control devices\n"); 2331 vfree(dev); 2332 return -EIO; 2333 } 2334 if ((isdn_tty_modem_init()) < 0) { 2335 printk(KERN_WARNING "isdn: Could not register tty devices\n"); 2336 vfree(dev); 2337 unregister_chrdev(ISDN_MAJOR, "isdn"); 2338 return -EIO; 2339 } 2340#ifdef CONFIG_ISDN_PPP 2341 if (isdn_ppp_init() < 0) { 2342 printk(KERN_WARNING "isdn: Could not create PPP-device-structs\n"); 2343 isdn_tty_exit(); 2344 unregister_chrdev(ISDN_MAJOR, "isdn"); 2345 vfree(dev); 2346 return -EIO; 2347 } 2348#endif /* CONFIG_ISDN_PPP */ 2349 2350 strcpy(tmprev, isdn_revision); 2351 printk(KERN_NOTICE "ISDN subsystem Rev: %s/", isdn_getrev(tmprev)); 2352 strcpy(tmprev, isdn_net_revision); 2353 printk("%s/", isdn_getrev(tmprev)); 2354 strcpy(tmprev, isdn_ppp_revision); 2355 printk("%s/", isdn_getrev(tmprev)); 2356 strcpy(tmprev, isdn_audio_revision); 2357 printk("%s/", isdn_getrev(tmprev)); 2358 strcpy(tmprev, isdn_v110_revision); 2359 printk("%s", isdn_getrev(tmprev)); 2360 2361#ifdef MODULE 2362 printk(" loaded\n"); 2363#else 2364 printk("\n"); 2365#endif 2366 isdn_info_update(); 2367 return 0; 2368} 2369 2370/* 2371 * Unload module 2372 */ 2373static void __exit isdn_exit(void) 2374{ 2375#ifdef CONFIG_ISDN_PPP 2376 isdn_ppp_cleanup(); 2377#endif 2378 if (isdn_net_rmall() < 0) { 2379 printk(KERN_WARNING "isdn: net-device busy, remove cancelled\n"); 2380 return; 2381 } 2382 isdn_tty_exit(); 2383 unregister_chrdev(ISDN_MAJOR, "isdn"); 2384 del_timer_sync(&dev->timer); 2385 /* call vfree with interrupts enabled, else it will hang */ 2386 vfree(dev); 2387 printk(KERN_NOTICE "ISDN-subsystem unloaded\n"); 2388} 2389 2390module_init(isdn_init); 2391module_exit(isdn_exit); 2392