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