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