SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/isdn/capi/kcapi.c

   1 /* $Id: kcapi.c,v 1.1.2.8 2004/03/26 19:57:20 armin Exp $
   2  *
   3  * Kernel CAPI 2.0 Module
   4  *
   5  * Copyright 1999 by Carsten Paeth <calle@calle.de>
   6  * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name>
   7  *
   8  * This software may be used and distributed according to the terms
   9  * of the GNU General Public License, incorporated herein by reference.
  10  *
  11  */
  12
  13 #define AVMB1_COMPAT
  14
  15 #include "kcapi.h"
  16 #include <linux/module.h>
  17 #include <linux/mm.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/ioport.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/sched.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/skbuff.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/capi.h>
  26 #include <linux/kernelcapi.h>
  27 #include <linux/init.h>
  28 #include <linux/moduleparam.h>
  29 #include <linux/delay.h>
  30 #include <asm/uaccess.h>
  31 #include <linux/isdn/capicmd.h>
  32 #include <linux/isdn/capiutil.h>
  33 #ifdef AVMB1_COMPAT
  34 #include <linux/b1lli.h>
  35 #endif
  36 #include <linux/mutex.h>
  37
  38 static int showcapimsgs = 0;
  39
  40 MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
  41 MODULE_AUTHOR("Carsten Paeth");
  42 MODULE_LICENSE("GPL");
  43 module_param(showcapimsgs, uint, 0);
  44
  45 /* ------------------------------------------------------------- */
  46
  47 struct capi_notifier {
  48         struct work_struct work;
  49         unsigned int cmd;
  50         u32 controller;
  51         u16 applid;
  52         u32 ncci;
  53 };
  54
  55 /* ------------------------------------------------------------- */
  56
  57 static struct capi_version driver_version = {2, 0, 1, 1<<4};
  58 static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
  59 static char capi_manufakturer[64] = "AVM Berlin";
  60
  61 #define NCCI2CTRL(ncci)    (((ncci) >> 24) & 0x7f)
  62
  63 LIST_HEAD(capi_drivers);
  64 DEFINE_RWLOCK(capi_drivers_list_lock);
  65
  66 static DEFINE_RWLOCK(application_lock);
  67 static DEFINE_MUTEX(controller_mutex);
  68
  69 struct capi20_appl *capi_applications[CAPI_MAXAPPL];
  70 struct capi_ctr *capi_controller[CAPI_MAXCONTR];
  71
  72 static int ncontrollers;
  73
  74 /* -------- controller ref counting -------------------------------------- */
  75
  76 static inline struct capi_ctr *
  77 capi_ctr_get(struct capi_ctr *ctr)
  78 {
  79         if (!try_module_get(ctr->owner))
  80                 return NULL;
  81         return ctr;
  82 }
  83
  84 static inline void
  85 capi_ctr_put(struct capi_ctr *ctr)
  86 {
  87         module_put(ctr->owner);
  88 }
  89
  90 /* ------------------------------------------------------------- */
  91
  92 static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
  93 {
  94         if (contr - 1 >= CAPI_MAXCONTR)
  95                 return NULL;
  96
  97         return capi_controller[contr - 1];
  98 }
  99
 100 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
 101 {
 102         if (applid - 1 >= CAPI_MAXAPPL)
 103                 return NULL;
 104
 105         return capi_applications[applid - 1];
 106 }
 107
 108 /* -------- util functions ------------------------------------ */
 109
 110 static inline int capi_cmd_valid(u8 cmd)
 111 {
 112         switch (cmd) {
 113         case CAPI_ALERT:
 114         case CAPI_CONNECT:
 115         case CAPI_CONNECT_ACTIVE:
 116         case CAPI_CONNECT_B3_ACTIVE:
 117         case CAPI_CONNECT_B3:
 118         case CAPI_CONNECT_B3_T90_ACTIVE:
 119         case CAPI_DATA_B3:
 120         case CAPI_DISCONNECT_B3:
 121         case CAPI_DISCONNECT:
 122         case CAPI_FACILITY:
 123         case CAPI_INFO:
 124         case CAPI_LISTEN:
 125         case CAPI_MANUFACTURER:
 126         case CAPI_RESET_B3:
 127         case CAPI_SELECT_B_PROTOCOL:
 128                 return 1;
 129         }
 130         return 0;
 131 }
 132
 133 static inline int capi_subcmd_valid(u8 subcmd)
 134 {
 135         switch (subcmd) {
 136         case CAPI_REQ:
 137         case CAPI_CONF:
 138         case CAPI_IND:
 139         case CAPI_RESP:
 140                 return 1;
 141         }
 142         return 0;
 143 }
 144
 145 /* ------------------------------------------------------------ */
 146
 147 static void
 148 register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
 149 {
 150         ctr = capi_ctr_get(ctr);
 151
 152         if (ctr)
 153                 ctr->register_appl(ctr, applid, rparam);
 154         else
 155                 printk(KERN_WARNING "%s: cannot get controller resources\n",
 156                        __func__);
 157 }
 158
 159
 160 static void release_appl(struct capi_ctr *ctr, u16 applid)
 161 {
 162         DBG("applid %#x", applid);
 163
 164         ctr->release_appl(ctr, applid);
 165         capi_ctr_put(ctr);
 166 }
 167
 168 /* -------- KCI_CONTRUP --------------------------------------- */
 169
 170 static void notify_up(u32 contr)
 171 {
 172         struct capi_ctr *ctr = get_capi_ctr_by_nr(contr);
 173         struct capi20_appl *ap;
 174         u16 applid;
 175
 176         if (showcapimsgs & 1) {
 177                 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
 178         }
 179         if (!ctr) {
 180                 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
 181                 return;
 182         }
 183         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 184                 ap = get_capi_appl_by_nr(applid);
 185                 if (!ap || ap->release_in_progress) continue;
 186                 register_appl(ctr, applid, &ap->rparam);
 187                 if (ap->callback && !ap->release_in_progress)
 188                         ap->callback(KCI_CONTRUP, contr, &ctr->profile);
 189         }
 190 }
 191
 192 /* -------- KCI_CONTRDOWN ------------------------------------- */
 193
 194 static void notify_down(u32 contr)
 195 {
 196         struct capi20_appl *ap;
 197         u16 applid;
 198
 199         if (showcapimsgs & 1) {
 200                 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
 201         }
 202
 203         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 204                 ap = get_capi_appl_by_nr(applid);
 205                 if (ap && ap->callback && !ap->release_in_progress)
 206                         ap->callback(KCI_CONTRDOWN, contr, NULL);
 207         }
 208 }
 209
 210 static void notify_handler(struct work_struct *work)
 211 {
 212         struct capi_notifier *np =
 213                 container_of(work, struct capi_notifier, work);
 214
 215         switch (np->cmd) {
 216         case KCI_CONTRUP:
 217                 notify_up(np->controller);
 218                 break;
 219         case KCI_CONTRDOWN:
 220                 notify_down(np->controller);
 221                 break;
 222         }
 223
 224         kfree(np);
 225 }
 226
 227 /*
 228  * The notifier will result in adding/deleteing of devices. Devices can
 229  * only removed in user process, not in bh.
 230  */
 231 static int notify_push(unsigned int cmd, u32 controller, u16 applid, u32 ncci)
 232 {
 233         struct capi_notifier *np = kmalloc(sizeof(*np), GFP_ATOMIC);
 234
 235         if (!np)
 236                 return -ENOMEM;
 237
 238         INIT_WORK(&np->work, notify_handler);
 239         np->cmd = cmd;
 240         np->controller = controller;
 241         np->applid = applid;
 242         np->ncci = ncci;
 243
 244         schedule_work(&np->work);
 245         return 0;
 246 }
 247
 248
 249 /* -------- Receiver ------------------------------------------ */
 250
 251 static void recv_handler(struct work_struct *work)
 252 {
 253         struct sk_buff *skb;
 254         struct capi20_appl *ap =
 255                 container_of(work, struct capi20_appl, recv_work);
 256
 257         if ((!ap) || (ap->release_in_progress))
 258                 return;
 259
 260         mutex_lock(&ap->recv_mtx);
 261         while ((skb = skb_dequeue(&ap->recv_queue))) {
 262                 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
 263                         ap->nrecvdatapkt++;
 264                 else
 265                         ap->nrecvctlpkt++;
 266
 267                 ap->recv_message(ap, skb);
 268         }
 269         mutex_unlock(&ap->recv_mtx);
 270 }
 271
 272 /**
 273  * capi_ctr_handle_message() - handle incoming CAPI message
 274  * @ctr:        controller descriptor structure.
 275  * @appl:       application ID.
 276  * @skb:        message.
 277  *
 278  * Called by hardware driver to pass a CAPI message to the application.
 279  */
 280
 281 void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
 282                              struct sk_buff *skb)
 283 {
 284         struct capi20_appl *ap;
 285         int showctl = 0;
 286         u8 cmd, subcmd;
 287         unsigned long flags;
 288         _cdebbuf *cdb;
 289
 290         if (ctr->state != CAPI_CTR_RUNNING) {
 291                 cdb = capi_message2str(skb->data);
 292                 if (cdb) {
 293                         printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
 294                                 ctr->cnr, cdb->buf);
 295                         cdebbuf_free(cdb);
 296                 } else
 297                         printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
 298                                 ctr->cnr);
 299                 goto error;
 300         }
 301
 302         cmd = CAPIMSG_COMMAND(skb->data);
 303         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 304         if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
 305                 ctr->nrecvdatapkt++;
 306                 if (ctr->traceflag > 2)
 307                         showctl |= 2;
 308         } else {
 309                 ctr->nrecvctlpkt++;
 310                 if (ctr->traceflag)
 311                         showctl |= 2;
 312         }
 313         showctl |= (ctr->traceflag & 1);
 314         if (showctl & 2) {
 315                 if (showctl & 1) {
 316                         printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",
 317                                ctr->cnr, CAPIMSG_APPID(skb->data),
 318                                capi_cmd2str(cmd, subcmd),
 319                                CAPIMSG_LEN(skb->data));
 320                 } else {
 321                         cdb = capi_message2str(skb->data);
 322                         if (cdb) {
 323                                 printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
 324                                         ctr->cnr, cdb->buf);
 325                                 cdebbuf_free(cdb);
 326                         } else
 327                                 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
 328                                         ctr->cnr, CAPIMSG_APPID(skb->data),
 329                                         capi_cmd2str(cmd, subcmd),
 330                                         CAPIMSG_LEN(skb->data));
 331                 }
 332
 333         }
 334
 335         read_lock_irqsave(&application_lock, flags);
 336         ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
 337         if ((!ap) || (ap->release_in_progress)) {
 338                 read_unlock_irqrestore(&application_lock, flags);
 339                 cdb = capi_message2str(skb->data);
 340                 if (cdb) {
 341                         printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
 342                         CAPIMSG_APPID(skb->data), cdb->buf);
 343                         cdebbuf_free(cdb);
 344                 } else
 345                         printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n",
 346                                 CAPIMSG_APPID(skb->data),
 347                                 capi_cmd2str(cmd, subcmd));
 348                 goto error;
 349         }
 350         skb_queue_tail(&ap->recv_queue, skb);
 351         schedule_work(&ap->recv_work);
 352         read_unlock_irqrestore(&application_lock, flags);
 353
 354         return;
 355
 356 error:
 357         kfree_skb(skb);
 358 }
 359
 360 EXPORT_SYMBOL(capi_ctr_handle_message);
 361
 362 /**
 363  * capi_ctr_ready() - signal CAPI controller ready
 364  * @ctr:        controller descriptor structure.
 365  *
 366  * Called by hardware driver to signal that the controller is up and running.
 367  */
 368
 369 void capi_ctr_ready(struct capi_ctr *ctr)
 370 {
 371         ctr->state = CAPI_CTR_RUNNING;
 372
 373         printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
 374                ctr->cnr, ctr->name);
 375
 376         notify_push(KCI_CONTRUP, ctr->cnr, 0, 0);
 377 }
 378
 379 EXPORT_SYMBOL(capi_ctr_ready);
 380
 381 /**
 382  * capi_ctr_down() - signal CAPI controller not ready
 383  * @ctr:        controller descriptor structure.
 384  *
 385  * Called by hardware driver to signal that the controller is down and
 386  * unavailable for use.
 387  */
 388
 389 void capi_ctr_down(struct capi_ctr *ctr)
 390 {
 391         u16 appl;
 392
 393         DBG("");
 394
 395         if (ctr->state == CAPI_CTR_DETECTED)
 396                 return;
 397
 398         ctr->state = CAPI_CTR_DETECTED;
 399
 400         memset(ctr->manu, 0, sizeof(ctr->manu));
 401         memset(&ctr->version, 0, sizeof(ctr->version));
 402         memset(&ctr->profile, 0, sizeof(ctr->profile));
 403         memset(ctr->serial, 0, sizeof(ctr->serial));
 404
 405         for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
 406                 struct capi20_appl *ap = get_capi_appl_by_nr(appl);
 407                 if (!ap || ap->release_in_progress)
 408                         continue;
 409
 410                 capi_ctr_put(ctr);
 411         }
 412
 413         printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
 414
 415         notify_push(KCI_CONTRDOWN, ctr->cnr, 0, 0);
 416 }
 417
 418 EXPORT_SYMBOL(capi_ctr_down);
 419
 420 /**
 421  * capi_ctr_suspend_output() - suspend controller
 422  * @ctr:        controller descriptor structure.
 423  *
 424  * Called by hardware driver to stop data flow.
 425  */
 426
 427 void capi_ctr_suspend_output(struct capi_ctr *ctr)
 428 {
 429         if (!ctr->blocked) {
 430                 printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
 431                        ctr->cnr);
 432                 ctr->blocked = 1;
 433         }
 434 }
 435
 436 EXPORT_SYMBOL(capi_ctr_suspend_output);
 437
 438 /**
 439  * capi_ctr_resume_output() - resume controller
 440  * @ctr:        controller descriptor structure.
 441  *
 442  * Called by hardware driver to resume data flow.
 443  */
 444
 445 void capi_ctr_resume_output(struct capi_ctr *ctr)
 446 {
 447         if (ctr->blocked) {
 448                 printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
 449                        ctr->cnr);
 450                 ctr->blocked = 0;
 451         }
 452 }
 453
 454 EXPORT_SYMBOL(capi_ctr_resume_output);
 455
 456 /* ------------------------------------------------------------- */
 457
 458 /**
 459  * attach_capi_ctr() - register CAPI controller
 460  * @ctr:        controller descriptor structure.
 461  *
 462  * Called by hardware driver to register a controller with the CAPI subsystem.
 463  * Return value: 0 on success, error code < 0 on error
 464  */
 465
 466 int attach_capi_ctr(struct capi_ctr *ctr)
 467 {
 468         int i;
 469
 470         mutex_lock(&controller_mutex);
 471
 472         for (i = 0; i < CAPI_MAXCONTR; i++) {
 473                 if (!capi_controller[i])
 474                         break;
 475         }
 476         if (i == CAPI_MAXCONTR) {
 477                 mutex_unlock(&controller_mutex);
 478                 printk(KERN_ERR "kcapi: out of controller slots\n");
 479                 return -EBUSY;
 480         }
 481         capi_controller[i] = ctr;
 482
 483         mutex_unlock(&controller_mutex);
 484
 485         ctr->nrecvctlpkt = 0;
 486         ctr->nrecvdatapkt = 0;
 487         ctr->nsentctlpkt = 0;
 488         ctr->nsentdatapkt = 0;
 489         ctr->cnr = i + 1;
 490         ctr->state = CAPI_CTR_DETECTED;
 491         ctr->blocked = 0;
 492         ctr->traceflag = showcapimsgs;
 493
 494         sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
 495         ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);
 496
 497         ncontrollers++;
 498         printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
 499                         ctr->cnr, ctr->name);
 500         return 0;
 501 }
 502
 503 EXPORT_SYMBOL(attach_capi_ctr);
 504
 505 /**
 506  * detach_capi_ctr() - unregister CAPI controller
 507  * @ctr:        controller descriptor structure.
 508  *
 509  * Called by hardware driver to remove the registration of a controller
 510  * with the CAPI subsystem.
 511  * Return value: 0 on success, error code < 0 on error
 512  */
 513
 514 int detach_capi_ctr(struct capi_ctr *ctr)
 515 {
 516         if (ctr->state != CAPI_CTR_DETECTED)
 517                 capi_ctr_down(ctr);
 518
 519         ncontrollers--;
 520
 521         if (ctr->procent) {
 522                 remove_proc_entry(ctr->procfn, NULL);
 523                 ctr->procent = NULL;
 524         }
 525         capi_controller[ctr->cnr - 1] = NULL;
 526         printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
 527                ctr->cnr, ctr->name);
 528
 529         return 0;
 530 }
 531
 532 EXPORT_SYMBOL(detach_capi_ctr);
 533
 534 /**
 535  * register_capi_driver() - register CAPI driver
 536  * @driver:     driver descriptor structure.
 537  *
 538  * Called by hardware driver to register itself with the CAPI subsystem.
 539  */
 540
 541 void register_capi_driver(struct capi_driver *driver)
 542 {
 543         unsigned long flags;
 544
 545         write_lock_irqsave(&capi_drivers_list_lock, flags);
 546         list_add_tail(&driver->list, &capi_drivers);
 547         write_unlock_irqrestore(&capi_drivers_list_lock, flags);
 548 }
 549
 550 EXPORT_SYMBOL(register_capi_driver);
 551
 552 /**
 553  * unregister_capi_driver() - unregister CAPI driver
 554  * @driver:     driver descriptor structure.
 555  *
 556  * Called by hardware driver to unregister itself from the CAPI subsystem.
 557  */
 558
 559 void unregister_capi_driver(struct capi_driver *driver)
 560 {
 561         unsigned long flags;
 562
 563         write_lock_irqsave(&capi_drivers_list_lock, flags);
 564         list_del(&driver->list);
 565         write_unlock_irqrestore(&capi_drivers_list_lock, flags);
 566 }
 567
 568 EXPORT_SYMBOL(unregister_capi_driver);
 569
 570 /* ------------------------------------------------------------- */
 571 /* -------- CAPI2.0 Interface ---------------------------------- */
 572 /* ------------------------------------------------------------- */
 573
 574 /**
 575  * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED
 576  *
 577  * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller
 578  *      is ready for use, CAPI_REGNOTINSTALLED otherwise)
 579  */
 580
 581 u16 capi20_isinstalled(void)
 582 {
 583         int i;
 584         for (i = 0; i < CAPI_MAXCONTR; i++) {
 585                 if (capi_controller[i] &&
 586                     capi_controller[i]->state == CAPI_CTR_RUNNING)
 587                         return CAPI_NOERROR;
 588         }
 589         return CAPI_REGNOTINSTALLED;
 590 }
 591
 592 EXPORT_SYMBOL(capi20_isinstalled);
 593
 594 /**
 595  * capi20_register() - CAPI 2.0 operation CAPI_REGISTER
 596  * @ap:         CAPI application descriptor structure.
 597  *
 598  * Register an application's presence with CAPI.
 599  * A unique application ID is assigned and stored in @ap->applid.
 600  * After this function returns successfully, the message receive
 601  * callback function @ap->recv_message() may be called at any time
 602  * until capi20_release() has been called for the same @ap.
 603  * Return value: CAPI result code
 604  */
 605
 606 u16 capi20_register(struct capi20_appl *ap)
 607 {
 608         int i;
 609         u16 applid;
 610         unsigned long flags;
 611
 612         DBG("");
 613
 614         if (ap->rparam.datablklen < 128)
 615                 return CAPI_LOGBLKSIZETOSMALL;
 616
 617         write_lock_irqsave(&application_lock, flags);
 618
 619         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 620                 if (capi_applications[applid - 1] == NULL)
 621                         break;
 622         }
 623         if (applid > CAPI_MAXAPPL) {
 624                 write_unlock_irqrestore(&application_lock, flags);
 625                 return CAPI_TOOMANYAPPLS;
 626         }
 627
 628         ap->applid = applid;
 629         capi_applications[applid - 1] = ap;
 630
 631         ap->nrecvctlpkt = 0;
 632         ap->nrecvdatapkt = 0;
 633         ap->nsentctlpkt = 0;
 634         ap->nsentdatapkt = 0;
 635         ap->callback = NULL;
 636         mutex_init(&ap->recv_mtx);
 637         skb_queue_head_init(&ap->recv_queue);
 638         INIT_WORK(&ap->recv_work, recv_handler);
 639         ap->release_in_progress = 0;
 640
 641         write_unlock_irqrestore(&application_lock, flags);
 642
 643         mutex_lock(&controller_mutex);
 644         for (i = 0; i < CAPI_MAXCONTR; i++) {
 645                 if (!capi_controller[i] ||
 646                     capi_controller[i]->state != CAPI_CTR_RUNNING)
 647                         continue;
 648                 register_appl(capi_controller[i], applid, &ap->rparam);
 649         }
 650         mutex_unlock(&controller_mutex);
 651
 652         if (showcapimsgs & 1) {
 653                 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
 654         }
 655
 656         return CAPI_NOERROR;
 657 }
 658
 659 EXPORT_SYMBOL(capi20_register);
 660
 661 /**
 662  * capi20_release() - CAPI 2.0 operation CAPI_RELEASE
 663  * @ap:         CAPI application descriptor structure.
 664  *
 665  * Terminate an application's registration with CAPI.
 666  * After this function returns successfully, the message receive
 667  * callback function @ap->recv_message() will no longer be called.
 668  * Return value: CAPI result code
 669  */
 670
 671 u16 capi20_release(struct capi20_appl *ap)
 672 {
 673         int i;
 674         unsigned long flags;
 675
 676         DBG("applid %#x", ap->applid);
 677
 678         write_lock_irqsave(&application_lock, flags);
 679         ap->release_in_progress = 1;
 680         capi_applications[ap->applid - 1] = NULL;
 681         write_unlock_irqrestore(&application_lock, flags);
 682
 683         mutex_lock(&controller_mutex);
 684         for (i = 0; i < CAPI_MAXCONTR; i++) {
 685                 if (!capi_controller[i] ||
 686                     capi_controller[i]->state != CAPI_CTR_RUNNING)
 687                         continue;
 688                 release_appl(capi_controller[i], ap->applid);
 689         }
 690         mutex_unlock(&controller_mutex);
 691
 692         flush_scheduled_work();
 693         skb_queue_purge(&ap->recv_queue);
 694
 695         if (showcapimsgs & 1) {
 696                 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
 697         }
 698
 699         return CAPI_NOERROR;
 700 }
 701
 702 EXPORT_SYMBOL(capi20_release);
 703
 704 /**
 705  * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE
 706  * @ap:         CAPI application descriptor structure.
 707  * @skb:        CAPI message.
 708  *
 709  * Transfer a single message to CAPI.
 710  * Return value: CAPI result code
 711  */
 712
 713 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
 714 {
 715         struct capi_ctr *ctr;
 716         int showctl = 0;
 717         u8 cmd, subcmd;
 718
 719         DBG("applid %#x", ap->applid);
 720
 721         if (ncontrollers == 0)
 722                 return CAPI_REGNOTINSTALLED;
 723         if ((ap->applid == 0) || ap->release_in_progress)
 724                 return CAPI_ILLAPPNR;
 725         if (skb->len < 12
 726             || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
 727             || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
 728                 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
 729         ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
 730         if (!ctr || ctr->state != CAPI_CTR_RUNNING) {
 731                 ctr = get_capi_ctr_by_nr(1); /* XXX why? */
 732                 if (!ctr || ctr->state != CAPI_CTR_RUNNING)
 733                         return CAPI_REGNOTINSTALLED;
 734         }
 735         if (ctr->blocked)
 736                 return CAPI_SENDQUEUEFULL;
 737
 738         cmd = CAPIMSG_COMMAND(skb->data);
 739         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 740
 741         if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
 742                 ctr->nsentdatapkt++;
 743                 ap->nsentdatapkt++;
 744                 if (ctr->traceflag > 2)
 745                         showctl |= 2;
 746         } else {
 747                 ctr->nsentctlpkt++;
 748                 ap->nsentctlpkt++;
 749                 if (ctr->traceflag)
 750                         showctl |= 2;
 751         }
 752         showctl |= (ctr->traceflag & 1);
 753         if (showctl & 2) {
 754                 if (showctl & 1) {
 755                         printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
 756                                CAPIMSG_CONTROLLER(skb->data),
 757                                CAPIMSG_APPID(skb->data),
 758                                capi_cmd2str(cmd, subcmd),
 759                                CAPIMSG_LEN(skb->data));
 760                 } else {
 761                         _cdebbuf *cdb = capi_message2str(skb->data);
 762                         if (cdb) {
 763                                 printk(KERN_DEBUG "kcapi: put [%03d] %s\n",
 764                                         CAPIMSG_CONTROLLER(skb->data),
 765                                         cdb->buf);
 766                                 cdebbuf_free(cdb);
 767                         } else
 768                                 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
 769                                         CAPIMSG_CONTROLLER(skb->data),
 770                                         CAPIMSG_APPID(skb->data),
 771                                         capi_cmd2str(cmd, subcmd),
 772                                         CAPIMSG_LEN(skb->data));
 773                 }
 774         }
 775         return ctr->send_message(ctr, skb);
 776 }
 777
 778 EXPORT_SYMBOL(capi20_put_message);
 779
 780 /**
 781  * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER
 782  * @contr:      controller number.
 783  * @buf:        result buffer (64 bytes).
 784  *
 785  * Retrieve information about the manufacturer of the specified ISDN controller
 786  * or (for @contr == 0) the driver itself.
 787  * Return value: CAPI result code
 788  */
 789
 790 u16 capi20_get_manufacturer(u32 contr, u8 *buf)
 791 {
 792         struct capi_ctr *ctr;
 793
 794         if (contr == 0) {
 795                 strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
 796                 return CAPI_NOERROR;
 797         }
 798         ctr = get_capi_ctr_by_nr(contr);
 799         if (!ctr || ctr->state != CAPI_CTR_RUNNING)
 800                 return CAPI_REGNOTINSTALLED;
 801         strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
 802         return CAPI_NOERROR;
 803 }
 804
 805 EXPORT_SYMBOL(capi20_get_manufacturer);
 806
 807 /**
 808  * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION
 809  * @contr:      controller number.
 810  * @verp:       result structure.
 811  *
 812  * Retrieve version information for the specified ISDN controller
 813  * or (for @contr == 0) the driver itself.
 814  * Return value: CAPI result code
 815  */
 816
 817 u16 capi20_get_version(u32 contr, struct capi_version *verp)
 818 {
 819         struct capi_ctr *ctr;
 820
 821         if (contr == 0) {
 822                 *verp = driver_version;
 823                 return CAPI_NOERROR;
 824         }
 825         ctr = get_capi_ctr_by_nr(contr);
 826         if (!ctr || ctr->state != CAPI_CTR_RUNNING)
 827                 return CAPI_REGNOTINSTALLED;
 828
 829         memcpy(verp, &ctr->version, sizeof(capi_version));
 830         return CAPI_NOERROR;
 831 }
 832
 833 EXPORT_SYMBOL(capi20_get_version);
 834
 835 /**
 836  * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER
 837  * @contr:      controller number.
 838  * @serial:     result buffer (8 bytes).
 839  *
 840  * Retrieve the serial number of the specified ISDN controller
 841  * or (for @contr == 0) the driver itself.
 842  * Return value: CAPI result code
 843  */
 844
 845 u16 capi20_get_serial(u32 contr, u8 *serial)
 846 {
 847         struct capi_ctr *ctr;
 848
 849         if (contr == 0) {
 850                 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
 851                 return CAPI_NOERROR;
 852         }
 853         ctr = get_capi_ctr_by_nr(contr);
 854         if (!ctr || ctr->state != CAPI_CTR_RUNNING)
 855                 return CAPI_REGNOTINSTALLED;
 856
 857         strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
 858         return CAPI_NOERROR;
 859 }
 860
 861 EXPORT_SYMBOL(capi20_get_serial);
 862
 863 /**
 864  * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE
 865  * @contr:      controller number.
 866  * @profp:      result structure.
 867  *
 868  * Retrieve capability information for the specified ISDN controller
 869  * or (for @contr == 0) the number of installed controllers.
 870  * Return value: CAPI result code
 871  */
 872
 873 u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
 874 {
 875         struct capi_ctr *ctr;
 876
 877         if (contr == 0) {
 878                 profp->ncontroller = ncontrollers;
 879                 return CAPI_NOERROR;
 880         }
 881         ctr = get_capi_ctr_by_nr(contr);
 882         if (!ctr || ctr->state != CAPI_CTR_RUNNING)
 883                 return CAPI_REGNOTINSTALLED;
 884
 885         memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
 886         return CAPI_NOERROR;
 887 }
 888
 889 EXPORT_SYMBOL(capi20_get_profile);
 890
 891 #ifdef AVMB1_COMPAT
 892 static int old_capi_manufacturer(unsigned int cmd, void __user *data)
 893 {
 894         avmb1_loadandconfigdef ldef;
 895         avmb1_extcarddef cdef;
 896         avmb1_resetdef rdef;
 897         capicardparams cparams;
 898         struct capi_ctr *ctr;
 899         struct capi_driver *driver = NULL;
 900         capiloaddata ldata;
 901         struct list_head *l;
 902         unsigned long flags;
 903         int retval;
 904
 905         switch (cmd) {
 906         case AVMB1_ADDCARD:
 907         case AVMB1_ADDCARD_WITH_TYPE:
 908                 if (cmd == AVMB1_ADDCARD) {
 909                    if ((retval = copy_from_user(&cdef, data,
 910                                             sizeof(avmb1_carddef))))
 911                            return retval;
 912                    cdef.cardtype = AVM_CARDTYPE_B1;
 913                 } else {
 914                    if ((retval = copy_from_user(&cdef, data,
 915                                             sizeof(avmb1_extcarddef))))
 916                            return retval;
 917                 }
 918                 cparams.port = cdef.port;
 919                 cparams.irq = cdef.irq;
 920                 cparams.cardnr = cdef.cardnr;
 921
 922                 read_lock_irqsave(&capi_drivers_list_lock, flags);
 923                 switch (cdef.cardtype) {
 924                         case AVM_CARDTYPE_B1:
 925                                 list_for_each(l, &capi_drivers) {
 926                                         driver = list_entry(l, struct capi_driver, list);
 927                                         if (strcmp(driver->name, "b1isa") == 0)
 928                                                 break;
 929                                 }
 930                                 break;
 931                         case AVM_CARDTYPE_T1:
 932                                 list_for_each(l, &capi_drivers) {
 933                                         driver = list_entry(l, struct capi_driver, list);
 934                                         if (strcmp(driver->name, "t1isa") == 0)
 935                                                 break;
 936                                 }
 937                                 break;
 938                         default:
 939                                 driver = NULL;
 940                                 break;
 941                 }
 942                 if (!driver) {
 943                         read_unlock_irqrestore(&capi_drivers_list_lock, flags);
 944                         printk(KERN_ERR "kcapi: driver not loaded.\n");
 945                         return -EIO;
 946                 }
 947                 if (!driver->add_card) {
 948                         read_unlock_irqrestore(&capi_drivers_list_lock, flags);
 949                         printk(KERN_ERR "kcapi: driver has no add card function.\n");
 950                         return -EIO;
 951                 }
 952
 953                 retval = driver->add_card(driver, &cparams);
 954                 read_unlock_irqrestore(&capi_drivers_list_lock, flags);
 955                 return retval;
 956
 957         case AVMB1_LOAD:
 958         case AVMB1_LOAD_AND_CONFIG:
 959
 960                 if (cmd == AVMB1_LOAD) {
 961                         if (copy_from_user(&ldef, data,
 962                                            sizeof(avmb1_loaddef)))
 963                                 return -EFAULT;
 964                         ldef.t4config.len = 0;
 965                         ldef.t4config.data = NULL;
 966                 } else {
 967                         if (copy_from_user(&ldef, data,
 968                                            sizeof(avmb1_loadandconfigdef)))
 969                                 return -EFAULT;
 970                 }
 971                 ctr = get_capi_ctr_by_nr(ldef.contr);
 972                 if (!ctr)
 973                         return -EINVAL;
 974                 ctr = capi_ctr_get(ctr);
 975                 if (!ctr)
 976                         return -ESRCH;
 977                 if (ctr->load_firmware == NULL) {
 978                         printk(KERN_DEBUG "kcapi: load: no load function\n");
 979                         capi_ctr_put(ctr);
 980                         return -ESRCH;
 981                 }
 982
 983                 if (ldef.t4file.len <= 0) {
 984                         printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
 985                         capi_ctr_put(ctr);
 986                         return -EINVAL;
 987                 }
 988                 if (ldef.t4file.data == NULL) {
 989                         printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
 990                         capi_ctr_put(ctr);
 991                         return -EINVAL;
 992                 }
 993
 994                 ldata.firmware.user = 1;
 995                 ldata.firmware.data = ldef.t4file.data;
 996                 ldata.firmware.len = ldef.t4file.len;
 997                 ldata.configuration.user = 1;
 998                 ldata.configuration.data = ldef.t4config.data;
 999                 ldata.configuration.len = ldef.t4config.len;
1000
1001                 if (ctr->state != CAPI_CTR_DETECTED) {
1002                         printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
1003                         capi_ctr_put(ctr);
1004                         return -EBUSY;
1005                 }
1006                 ctr->state = CAPI_CTR_LOADING;
1007
1008                 retval = ctr->load_firmware(ctr, &ldata);
1009
1010                 if (retval) {
1011                         ctr->state = CAPI_CTR_DETECTED;
1012                         capi_ctr_put(ctr);
1013                         return retval;
1014                 }
1015
1016                 while (ctr->state != CAPI_CTR_RUNNING) {
1017
1018                         msleep_interruptible(100);      /* 0.1 sec */
1019
1020                         if (signal_pending(current)) {
1021                                 capi_ctr_put(ctr);
1022                                 return -EINTR;
1023                         }
1024                 }
1025                 capi_ctr_put(ctr);
1026                 return 0;
1027
1028         case AVMB1_RESETCARD:
1029                 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
1030                         return -EFAULT;
1031                 ctr = get_capi_ctr_by_nr(rdef.contr);
1032                 if (!ctr)
1033                         return -ESRCH;
1034
1035                 if (ctr->state == CAPI_CTR_DETECTED)
1036                         return 0;
1037
1038                 ctr->reset_ctr(ctr);
1039
1040                 while (ctr->state > CAPI_CTR_DETECTED) {
1041
1042                         msleep_interruptible(100);      /* 0.1 sec */
1043
1044                         if (signal_pending(current))
1045                                 return -EINTR;
1046                 }
1047                 return 0;
1048
1049         }
1050         return -EINVAL;
1051 }
1052 #endif
1053
1054 /**
1055  * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER
1056  * @cmd:        command.
1057  * @data:       parameter.
1058  *
1059  * Perform manufacturer specific command.
1060  * Return value: CAPI result code
1061  */
1062
1063 int capi20_manufacturer(unsigned int cmd, void __user *data)
1064 {
1065         struct capi_ctr *ctr;
1066
1067         switch (cmd) {
1068 #ifdef AVMB1_COMPAT
1069         case AVMB1_LOAD:
1070         case AVMB1_LOAD_AND_CONFIG:
1071         case AVMB1_RESETCARD:
1072         case AVMB1_GET_CARDINFO:
1073         case AVMB1_REMOVECARD:
1074                 return old_capi_manufacturer(cmd, data);
1075 #endif
1076         case KCAPI_CMD_TRACE:
1077         {
1078                 kcapi_flagdef fdef;
1079
1080                 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
1081                         return -EFAULT;
1082
1083                 ctr = get_capi_ctr_by_nr(fdef.contr);
1084                 if (!ctr)
1085                         return -ESRCH;
1086
1087                 ctr->traceflag = fdef.flag;
1088                 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
1089                        ctr->cnr, ctr->traceflag);
1090                 return 0;
1091         }
1092         case KCAPI_CMD_ADDCARD:
1093         {
1094                 struct list_head *l;
1095                 struct capi_driver *driver = NULL;
1096                 capicardparams cparams;
1097                 kcapi_carddef cdef;
1098                 int retval;
1099
1100                 if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
1101                         return retval;
1102
1103                 cparams.port = cdef.port;
1104                 cparams.irq = cdef.irq;
1105                 cparams.membase = cdef.membase;
1106                 cparams.cardnr = cdef.cardnr;
1107                 cparams.cardtype = 0;
1108                 cdef.driver[sizeof(cdef.driver)-1] = 0;
1109
1110                 list_for_each(l, &capi_drivers) {
1111                         driver = list_entry(l, struct capi_driver, list);
1112                         if (strcmp(driver->name, cdef.driver) == 0)
1113                                 break;
1114                 }
1115                 if (driver == NULL) {
1116                         printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
1117                                         cdef.driver);
1118                         return -ESRCH;
1119                 }
1120
1121                 if (!driver->add_card) {
1122                         printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
1123                         return -EIO;
1124                 }
1125
1126                 return driver->add_card(driver, &cparams);
1127         }
1128
1129         default:
1130                 printk(KERN_ERR "kcapi: manufacturer command %d unknown.\n",
1131                                         cmd);
1132                 break;
1133
1134         }
1135         return -EINVAL;
1136 }
1137
1138 EXPORT_SYMBOL(capi20_manufacturer);
1139
1140 /* temporary hack */
1141
1142 /**
1143  * capi20_set_callback() - set CAPI application notification callback function
1144  * @ap:         CAPI application descriptor structure.
1145  * @callback:   callback function (NULL to remove).
1146  *
1147  * If not NULL, the callback function will be called to notify the
1148  * application of the addition or removal of a controller.
1149  * The first argument (cmd) will tell whether the controller was added
1150  * (KCI_CONTRUP) or removed (KCI_CONTRDOWN).
1151  * The second argument (contr) will be the controller number.
1152  * For cmd==KCI_CONTRUP the third argument (data) will be a pointer to the
1153  * new controller's capability profile structure.
1154  */
1155
1156 void capi20_set_callback(struct capi20_appl *ap,
1157                          void (*callback) (unsigned int cmd, __u32 contr, void *data))
1158 {
1159         ap->callback = callback;
1160 }
1161
1162 EXPORT_SYMBOL(capi20_set_callback);
1163
1164 /* ------------------------------------------------------------- */
1165 /* -------- Init & Cleanup ------------------------------------- */
1166 /* ------------------------------------------------------------- */
1167
1168 /*
1169  * init / exit functions
1170  */
1171
1172 static int __init kcapi_init(void)
1173 {
1174         int err;
1175
1176         err = cdebug_init();
1177         if (!err)
1178                 kcapi_proc_init();
1179         return err;
1180 }
1181
1182 static void __exit kcapi_exit(void)
1183 {
1184         kcapi_proc_exit();
1185
1186         /* make sure all notifiers are finished */
1187         flush_scheduled_work();
1188         cdebug_exit();
1189 }
1190
1191 module_init(kcapi_init);
1192 module_exit(kcapi_exit);