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