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