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 CONFIG_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/seq_file.h>
  22 #include <linux/skbuff.h>
  23 #include <linux/workqueue.h>
  24 #include <linux/capi.h>
  25 #include <linux/kernelcapi.h>
  26 #include <linux/init.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/delay.h>
  29 #include <asm/uaccess.h>
  30 #include <linux/isdn/capicmd.h>
  31 #include <linux/isdn/capiutil.h>
  32 #ifdef CONFIG_AVMB1_COMPAT
  33 #include <linux/b1lli.h>
  34 #endif
  35
  36 static char *revision = "$Revision: 1.1.2.8 $";
  37
  38 /* ------------------------------------------------------------- */
  39
  40 static int showcapimsgs = 0;
  41
  42 MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
  43 MODULE_AUTHOR("Carsten Paeth");
  44 MODULE_LICENSE("GPL");
  45 module_param(showcapimsgs, uint, 0);
  46
  47 /* ------------------------------------------------------------- */
  48
  49 struct capi_notifier {
  50         struct work_struct work;
  51         unsigned int cmd;
  52         u32 controller;
  53         u16 applid;
  54         u32 ncci;
  55 };
  56
  57 /* ------------------------------------------------------------- */
  58
  59 static struct capi_version driver_version = {2, 0, 1, 1<<4};
  60 static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
  61 static char capi_manufakturer[64] = "AVM Berlin";
  62
  63 #define NCCI2CTRL(ncci)    (((ncci) >> 24) & 0x7f)
  64
  65 LIST_HEAD(capi_drivers);
  66 DEFINE_RWLOCK(capi_drivers_list_lock);
  67
  68 static DEFINE_RWLOCK(application_lock);
  69 static DECLARE_MUTEX(controller_sem);
  70
  71 struct capi20_appl *capi_applications[CAPI_MAXAPPL];
  72 struct capi_ctr *capi_cards[CAPI_MAXCONTR];
  73
  74 static int ncards;
  75
  76 /* -------- controller ref counting -------------------------------------- */
  77
  78 static inline struct capi_ctr *
  79 capi_ctr_get(struct capi_ctr *card)
  80 {
  81         if (!try_module_get(card->owner))
  82                 return NULL;
  83         return card;
  84 }
  85
  86 static inline void
  87 capi_ctr_put(struct capi_ctr *card)
  88 {
  89         module_put(card->owner);
  90 }
  91
  92 /* ------------------------------------------------------------- */
  93
  94 static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
  95 {
  96         if (contr - 1 >= CAPI_MAXCONTR)
  97                 return NULL;
  98
  99         return capi_cards[contr - 1];
 100 }
 101
 102 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
 103 {
 104         if (applid - 1 >= CAPI_MAXAPPL)
 105                 return NULL;
 106
 107         return capi_applications[applid - 1];
 108 }
 109
 110 /* -------- util functions ------------------------------------ */
 111
 112 static inline int capi_cmd_valid(u8 cmd)
 113 {
 114         switch (cmd) {
 115         case CAPI_ALERT:
 116         case CAPI_CONNECT:
 117         case CAPI_CONNECT_ACTIVE:
 118         case CAPI_CONNECT_B3_ACTIVE:
 119         case CAPI_CONNECT_B3:
 120         case CAPI_CONNECT_B3_T90_ACTIVE:
 121         case CAPI_DATA_B3:
 122         case CAPI_DISCONNECT_B3:
 123         case CAPI_DISCONNECT:
 124         case CAPI_FACILITY:
 125         case CAPI_INFO:
 126         case CAPI_LISTEN:
 127         case CAPI_MANUFACTURER:
 128         case CAPI_RESET_B3:
 129         case CAPI_SELECT_B_PROTOCOL:
 130                 return 1;
 131         }
 132         return 0;
 133 }
 134
 135 static inline int capi_subcmd_valid(u8 subcmd)
 136 {
 137         switch (subcmd) {
 138         case CAPI_REQ:
 139         case CAPI_CONF:
 140         case CAPI_IND:
 141         case CAPI_RESP:
 142                 return 1;
 143         }
 144         return 0;
 145 }
 146
 147 /* ------------------------------------------------------------ */
 148
 149 static void register_appl(struct capi_ctr *card, u16 applid, capi_register_params *rparam)
 150 {
 151         card = capi_ctr_get(card);
 152
 153         if (card)
 154                 card->register_appl(card, applid, rparam);
 155         else
 156                 printk(KERN_WARNING "%s: cannot get card resources\n", __FUNCTION__);
 157 }
 158
 159
 160 static void release_appl(struct capi_ctr *card, u16 applid)
 161 {
 162         DBG("applid %#x", applid);
 163
 164         card->release_appl(card, applid);
 165         capi_ctr_put(card);
 166 }
 167
 168 /* -------- KCI_CONTRUP --------------------------------------- */
 169
 170 static void notify_up(u32 contr)
 171 {
 172         struct capi_ctr *card = get_capi_ctr_by_nr(contr);
 173         struct capi20_appl *ap;
 174         u16 applid;
 175
 176         if (showcapimsgs & 1) {
 177                 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
 178         }
 179         if (!card) {
 180                 printk(KERN_WARNING "%s: invalid contr %d\n", __FUNCTION__, contr);
 181                 return;
 182         }
 183         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 184                 ap = get_capi_appl_by_nr(applid);
 185                 if (!ap || ap->release_in_progress) continue;
 186                 register_appl(card, applid, &ap->rparam);
 187                 if (ap->callback && !ap->release_in_progress)
 188                         ap->callback(KCI_CONTRUP, contr, &card->profile);
 189         }
 190 }
 191
 192 /* -------- KCI_CONTRDOWN ------------------------------------- */
 193
 194 static void notify_down(u32 contr)
 195 {
 196         struct capi20_appl *ap;
 197         u16 applid;
 198
 199         if (showcapimsgs & 1) {
 200                 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
 201         }
 202
 203         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 204                 ap = get_capi_appl_by_nr(applid);
 205                 if (ap && ap->callback && !ap->release_in_progress)
 206                         ap->callback(KCI_CONTRDOWN, contr, NULL);
 207         }
 208 }
 209
 210 static void notify_handler(void *data)
 211 {
 212         struct capi_notifier *np = data;
 213
 214         switch (np->cmd) {
 215         case KCI_CONTRUP:
 216                 notify_up(np->controller);
 217                 break;
 218         case KCI_CONTRDOWN:
 219                 notify_down(np->controller);
 220                 break;
 221         }
 222
 223         kfree(np);
 224 }
 225
 226 /*
 227  * The notifier will result in adding/deleteing of devices. Devices can
 228  * only removed in user process, not in bh.
 229  */
 230 static int notify_push(unsigned int cmd, u32 controller, u16 applid, u32 ncci)
 231 {
 232         struct capi_notifier *np = kmalloc(sizeof(*np), GFP_ATOMIC);
 233
 234         if (!np)
 235                 return -ENOMEM;
 236
 237         INIT_WORK(&np->work, notify_handler, np);
 238         np->cmd = cmd;
 239         np->controller = controller;
 240         np->applid = applid;
 241         np->ncci = ncci;
 242
 243         schedule_work(&np->work);
 244         return 0;
 245 }
 246
 247
 248 /* -------- Receiver ------------------------------------------ */
 249
 250 static void recv_handler(void *_ap)
 251 {
 252         struct sk_buff *skb;
 253         struct capi20_appl *ap = (struct capi20_appl *) _ap;
 254
 255         if ((!ap) || (ap->release_in_progress))
 256                 return;
 257
 258         down(&ap->recv_sem);
 259         while ((skb = skb_dequeue(&ap->recv_queue))) {
 260                 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
 261                         ap->nrecvdatapkt++;
 262                 else
 263                         ap->nrecvctlpkt++;
 264
 265                 ap->recv_message(ap, skb);
 266         }
 267         up(&ap->recv_sem);
 268 }
 269
 270 void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *skb)
 271 {
 272         struct capi20_appl *ap;
 273         int showctl = 0;
 274         u8 cmd, subcmd;
 275         unsigned long flags;
 276
 277         if (card->cardstate != CARD_RUNNING) {
 278                 printk(KERN_INFO "kcapi: controller %d not active, got: %s",
 279                        card->cnr, capi_message2str(skb->data));
 280                 goto error;
 281         }
 282
 283         cmd = CAPIMSG_COMMAND(skb->data);
 284         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 285         if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
 286                 card->nrecvdatapkt++;
 287                 if (card->traceflag > 2) showctl |= 2;
 288         } else {
 289                 card->nrecvctlpkt++;
 290                 if (card->traceflag) showctl |= 2;
 291         }
 292         showctl |= (card->traceflag & 1);
 293         if (showctl & 2) {
 294                 if (showctl & 1) {
 295                         printk(KERN_DEBUG "kcapi: got [0x%lx] id#%d %s len=%u\n",
 296                                (unsigned long) card->cnr,
 297                                CAPIMSG_APPID(skb->data),
 298                                capi_cmd2str(cmd, subcmd),
 299                                CAPIMSG_LEN(skb->data));
 300                 } else {
 301                         printk(KERN_DEBUG "kcapi: got [0x%lx] %s\n",
 302                                         (unsigned long) card->cnr,
 303                                         capi_message2str(skb->data));
 304                 }
 305
 306         }
 307
 308         read_lock_irqsave(&application_lock, flags);
 309         ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
 310         if ((!ap) || (ap->release_in_progress)) {
 311                 read_unlock_irqrestore(&application_lock, flags);
 312                 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
 313                         CAPIMSG_APPID(skb->data), capi_message2str(skb->data));
 314                 goto error;
 315         }
 316         skb_queue_tail(&ap->recv_queue, skb);
 317         schedule_work(&ap->recv_work);
 318         read_unlock_irqrestore(&application_lock, flags);
 319
 320         return;
 321
 322 error:
 323         kfree_skb(skb);
 324 }
 325
 326 EXPORT_SYMBOL(capi_ctr_handle_message);
 327
 328 void capi_ctr_ready(struct capi_ctr * card)
 329 {
 330         card->cardstate = CARD_RUNNING;
 331
 332         printk(KERN_NOTICE "kcapi: card %d \"%s\" ready.\n",
 333                card->cnr, card->name);
 334
 335         notify_push(KCI_CONTRUP, card->cnr, 0, 0);
 336 }
 337
 338 EXPORT_SYMBOL(capi_ctr_ready);
 339
 340 void capi_ctr_reseted(struct capi_ctr * card)
 341 {
 342         u16 appl;
 343
 344         DBG("");
 345
 346         if (card->cardstate == CARD_DETECTED)
 347                 return;
 348
 349         card->cardstate = CARD_DETECTED;
 350
 351         memset(card->manu, 0, sizeof(card->manu));
 352         memset(&card->version, 0, sizeof(card->version));
 353         memset(&card->profile, 0, sizeof(card->profile));
 354         memset(card->serial, 0, sizeof(card->serial));
 355
 356         for (appl = 1; appl <= CAPI_MAXAPPL; appl++) {
 357                 struct capi20_appl *ap = get_capi_appl_by_nr(appl);
 358                 if (!ap || ap->release_in_progress)
 359                         continue;
 360
 361                 capi_ctr_put(card);
 362         }
 363
 364         printk(KERN_NOTICE "kcapi: card %d down.\n", card->cnr);
 365
 366         notify_push(KCI_CONTRDOWN, card->cnr, 0, 0);
 367 }
 368
 369 EXPORT_SYMBOL(capi_ctr_reseted);
 370
 371 void capi_ctr_suspend_output(struct capi_ctr *card)
 372 {
 373         if (!card->blocked) {
 374                 printk(KERN_DEBUG "kcapi: card %d suspend\n", card->cnr);
 375                 card->blocked = 1;
 376         }
 377 }
 378
 379 EXPORT_SYMBOL(capi_ctr_suspend_output);
 380
 381 void capi_ctr_resume_output(struct capi_ctr *card)
 382 {
 383         if (card->blocked) {
 384                 printk(KERN_DEBUG "kcapi: card %d resume\n", card->cnr);
 385                 card->blocked = 0;
 386         }
 387 }
 388
 389 EXPORT_SYMBOL(capi_ctr_resume_output);
 390
 391 /* ------------------------------------------------------------- */
 392
 393 int
 394 attach_capi_ctr(struct capi_ctr *card)
 395 {
 396         int i;
 397
 398         down(&controller_sem);
 399
 400         for (i = 0; i < CAPI_MAXCONTR; i++) {
 401                 if (capi_cards[i] == NULL)
 402                         break;
 403         }
 404         if (i == CAPI_MAXCONTR) {
 405                 up(&controller_sem);
 406                 printk(KERN_ERR "kcapi: out of controller slots\n");
 407                 return -EBUSY;
 408         }
 409         capi_cards[i] = card;
 410
 411         up(&controller_sem);
 412
 413         card->nrecvctlpkt = 0;
 414         card->nrecvdatapkt = 0;
 415         card->nsentctlpkt = 0;
 416         card->nsentdatapkt = 0;
 417         card->cnr = i + 1;
 418         card->cardstate = CARD_DETECTED;
 419         card->blocked = 0;
 420         card->traceflag = showcapimsgs;
 421
 422         sprintf(card->procfn, "capi/controllers/%d", card->cnr);
 423         card->procent = create_proc_entry(card->procfn, 0, NULL);
 424         if (card->procent) {
 425            card->procent->read_proc =
 426                 (int (*)(char *,char **,off_t,int,int *,void *))
 427                         card->ctr_read_proc;
 428            card->procent->data = card;
 429         }
 430
 431         ncards++;
 432         printk(KERN_NOTICE "kcapi: Controller %d: %s attached\n",
 433                         card->cnr, card->name);
 434         return 0;
 435 }
 436
 437 EXPORT_SYMBOL(attach_capi_ctr);
 438
 439 int detach_capi_ctr(struct capi_ctr *card)
 440 {
 441         if (card->cardstate != CARD_DETECTED)
 442                 capi_ctr_reseted(card);
 443
 444         ncards--;
 445
 446         if (card->procent) {
 447            remove_proc_entry(card->procfn, NULL);
 448            card->procent = NULL;
 449         }
 450         capi_cards[card->cnr - 1] = NULL;
 451         printk(KERN_NOTICE "kcapi: Controller %d: %s unregistered\n",
 452                         card->cnr, card->name);
 453
 454         return 0;
 455 }
 456
 457 EXPORT_SYMBOL(detach_capi_ctr);
 458
 459 void register_capi_driver(struct capi_driver *driver)
 460 {
 461         unsigned long flags;
 462
 463         write_lock_irqsave(&capi_drivers_list_lock, flags);
 464         list_add_tail(&driver->list, &capi_drivers);
 465         write_unlock_irqrestore(&capi_drivers_list_lock, flags);
 466 }
 467
 468 EXPORT_SYMBOL(register_capi_driver);
 469
 470 void unregister_capi_driver(struct capi_driver *driver)
 471 {
 472         unsigned long flags;
 473
 474         write_lock_irqsave(&capi_drivers_list_lock, flags);
 475         list_del(&driver->list);
 476         write_unlock_irqrestore(&capi_drivers_list_lock, flags);
 477 }
 478
 479 EXPORT_SYMBOL(unregister_capi_driver);
 480
 481 /* ------------------------------------------------------------- */
 482 /* -------- CAPI2.0 Interface ---------------------------------- */
 483 /* ------------------------------------------------------------- */
 484
 485 u16 capi20_isinstalled(void)
 486 {
 487         int i;
 488         for (i = 0; i < CAPI_MAXCONTR; i++) {
 489                 if (capi_cards[i] && capi_cards[i]->cardstate == CARD_RUNNING)
 490                         return CAPI_NOERROR;
 491         }
 492         return CAPI_REGNOTINSTALLED;
 493 }
 494
 495 EXPORT_SYMBOL(capi20_isinstalled);
 496
 497 u16 capi20_register(struct capi20_appl *ap)
 498 {
 499         int i;
 500         u16 applid;
 501         unsigned long flags;
 502
 503         DBG("");
 504
 505         if (ap->rparam.datablklen < 128)
 506                 return CAPI_LOGBLKSIZETOSMALL;
 507
 508         write_lock_irqsave(&application_lock, flags);
 509
 510         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 511                 if (capi_applications[applid - 1] == NULL)
 512                         break;
 513         }
 514         if (applid > CAPI_MAXAPPL) {
 515                 write_unlock_irqrestore(&application_lock, flags);
 516                 return CAPI_TOOMANYAPPLS;
 517         }
 518
 519         ap->applid = applid;
 520         capi_applications[applid - 1] = ap;
 521
 522         ap->nrecvctlpkt = 0;
 523         ap->nrecvdatapkt = 0;
 524         ap->nsentctlpkt = 0;
 525         ap->nsentdatapkt = 0;
 526         ap->callback = NULL;
 527         init_MUTEX(&ap->recv_sem);
 528         skb_queue_head_init(&ap->recv_queue);
 529         INIT_WORK(&ap->recv_work, recv_handler, (void *)ap);
 530         ap->release_in_progress = 0;
 531
 532         write_unlock_irqrestore(&application_lock, flags);
 533
 534         down(&controller_sem);
 535         for (i = 0; i < CAPI_MAXCONTR; i++) {
 536                 if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)
 537                         continue;
 538                 register_appl(capi_cards[i], applid, &ap->rparam);
 539         }
 540         up(&controller_sem);
 541
 542         if (showcapimsgs & 1) {
 543                 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
 544         }
 545
 546         return CAPI_NOERROR;
 547 }
 548
 549 EXPORT_SYMBOL(capi20_register);
 550
 551 u16 capi20_release(struct capi20_appl *ap)
 552 {
 553         int i;
 554         unsigned long flags;
 555
 556         DBG("applid %#x", ap->applid);
 557
 558         write_lock_irqsave(&application_lock, flags);
 559         ap->release_in_progress = 1;
 560         capi_applications[ap->applid - 1] = NULL;
 561         write_unlock_irqrestore(&application_lock, flags);
 562
 563         down(&controller_sem);
 564         for (i = 0; i < CAPI_MAXCONTR; i++) {
 565                 if (!capi_cards[i] || capi_cards[i]->cardstate != CARD_RUNNING)
 566                         continue;
 567                 release_appl(capi_cards[i], ap->applid);
 568         }
 569         up(&controller_sem);
 570
 571         flush_scheduled_work();
 572         skb_queue_purge(&ap->recv_queue);
 573
 574         if (showcapimsgs & 1) {
 575                 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
 576         }
 577
 578         return CAPI_NOERROR;
 579 }
 580
 581 EXPORT_SYMBOL(capi20_release);
 582
 583 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
 584 {
 585         struct capi_ctr *card;
 586         int showctl = 0;
 587         u8 cmd, subcmd;
 588
 589         DBG("applid %#x", ap->applid);
 590
 591         if (ncards == 0)
 592                 return CAPI_REGNOTINSTALLED;
 593         if ((ap->applid == 0) || ap->release_in_progress)
 594                 return CAPI_ILLAPPNR;
 595         if (skb->len < 12
 596             || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
 597             || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
 598                 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
 599         card = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
 600         if (!card || card->cardstate != CARD_RUNNING) {
 601                 card = get_capi_ctr_by_nr(1); // XXX why?
 602                 if (!card || card->cardstate != CARD_RUNNING)
 603                         return CAPI_REGNOTINSTALLED;
 604         }
 605         if (card->blocked)
 606                 return CAPI_SENDQUEUEFULL;
 607
 608         cmd = CAPIMSG_COMMAND(skb->data);
 609         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 610
 611         if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
 612                 card->nsentdatapkt++;
 613                 ap->nsentdatapkt++;
 614                 if (card->traceflag > 2) showctl |= 2;
 615         } else {
 616                 card->nsentctlpkt++;
 617                 ap->nsentctlpkt++;
 618                 if (card->traceflag) showctl |= 2;
 619         }
 620         showctl |= (card->traceflag & 1);
 621         if (showctl & 2) {
 622                 if (showctl & 1) {
 623                         printk(KERN_DEBUG "kcapi: put [%#x] id#%d %s len=%u\n",
 624                                CAPIMSG_CONTROLLER(skb->data),
 625                                CAPIMSG_APPID(skb->data),
 626                                capi_cmd2str(cmd, subcmd),
 627                                CAPIMSG_LEN(skb->data));
 628                 } else {
 629                         printk(KERN_DEBUG "kcapi: put [%#x] %s\n",
 630                                CAPIMSG_CONTROLLER(skb->data),
 631                                capi_message2str(skb->data));
 632                 }
 633
 634         }
 635         return card->send_message(card, skb);
 636 }
 637
 638 EXPORT_SYMBOL(capi20_put_message);
 639
 640 u16 capi20_get_manufacturer(u32 contr, u8 *buf)
 641 {
 642         struct capi_ctr *card;
 643
 644         if (contr == 0) {
 645                 strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
 646                 return CAPI_NOERROR;
 647         }
 648         card = get_capi_ctr_by_nr(contr);
 649         if (!card || card->cardstate != CARD_RUNNING)
 650                 return CAPI_REGNOTINSTALLED;
 651         strlcpy(buf, card->manu, CAPI_MANUFACTURER_LEN);
 652         return CAPI_NOERROR;
 653 }
 654
 655 EXPORT_SYMBOL(capi20_get_manufacturer);
 656
 657 u16 capi20_get_version(u32 contr, struct capi_version *verp)
 658 {
 659         struct capi_ctr *card;
 660
 661         if (contr == 0) {
 662                 *verp = driver_version;
 663                 return CAPI_NOERROR;
 664         }
 665         card = get_capi_ctr_by_nr(contr);
 666         if (!card || card->cardstate != CARD_RUNNING)
 667                 return CAPI_REGNOTINSTALLED;
 668
 669         memcpy((void *) verp, &card->version, sizeof(capi_version));
 670         return CAPI_NOERROR;
 671 }
 672
 673 EXPORT_SYMBOL(capi20_get_version);
 674
 675 u16 capi20_get_serial(u32 contr, u8 *serial)
 676 {
 677         struct capi_ctr *card;
 678
 679         if (contr == 0) {
 680                 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
 681                 return CAPI_NOERROR;
 682         }
 683         card = get_capi_ctr_by_nr(contr);
 684         if (!card || card->cardstate != CARD_RUNNING)
 685                 return CAPI_REGNOTINSTALLED;
 686
 687         strlcpy((void *) serial, card->serial, CAPI_SERIAL_LEN);
 688         return CAPI_NOERROR;
 689 }
 690
 691 EXPORT_SYMBOL(capi20_get_serial);
 692
 693 u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
 694 {
 695         struct capi_ctr *card;
 696
 697         if (contr == 0) {
 698                 profp->ncontroller = ncards;
 699                 return CAPI_NOERROR;
 700         }
 701         card = get_capi_ctr_by_nr(contr);
 702         if (!card || card->cardstate != CARD_RUNNING)
 703                 return CAPI_REGNOTINSTALLED;
 704
 705         memcpy((void *) profp, &card->profile,
 706                         sizeof(struct capi_profile));
 707         return CAPI_NOERROR;
 708 }
 709
 710 EXPORT_SYMBOL(capi20_get_profile);
 711
 712 #ifdef CONFIG_AVMB1_COMPAT
 713 static int old_capi_manufacturer(unsigned int cmd, void __user *data)
 714 {
 715         avmb1_loadandconfigdef ldef;
 716         avmb1_extcarddef cdef;
 717         avmb1_resetdef rdef;
 718         capicardparams cparams;
 719         struct capi_ctr *card;
 720         struct capi_driver *driver = NULL;
 721         capiloaddata ldata;
 722         struct list_head *l;
 723         unsigned long flags;
 724         int retval;
 725
 726         switch (cmd) {
 727         case AVMB1_ADDCARD:
 728         case AVMB1_ADDCARD_WITH_TYPE:
 729                 if (cmd == AVMB1_ADDCARD) {
 730                    if ((retval = copy_from_user(&cdef, data,
 731                                             sizeof(avmb1_carddef))))
 732                            return retval;
 733                    cdef.cardtype = AVM_CARDTYPE_B1;
 734                 } else {
 735                    if ((retval = copy_from_user(&cdef, data,
 736                                             sizeof(avmb1_extcarddef))))
 737                            return retval;
 738                 }
 739                 cparams.port = cdef.port;
 740                 cparams.irq = cdef.irq;
 741                 cparams.cardnr = cdef.cardnr;
 742
 743                 read_lock_irqsave(&capi_drivers_list_lock, flags);
 744                 switch (cdef.cardtype) {
 745                         case AVM_CARDTYPE_B1:
 746                                 list_for_each(l, &capi_drivers) {
 747                                         driver = list_entry(l, struct capi_driver, list);
 748                                         if (strcmp(driver->name, "b1isa") == 0)
 749                                                 break;
 750                                 }
 751                                 break;
 752                         case AVM_CARDTYPE_T1:
 753                                 list_for_each(l, &capi_drivers) {
 754                                         driver = list_entry(l, struct capi_driver, list);
 755                                         if (strcmp(driver->name, "t1isa") == 0)
 756                                                 break;
 757                                 }
 758                                 break;
 759                         default:
 760                                 driver = NULL;
 761                                 break;
 762                 }
 763                 if (!driver) {
 764                         read_unlock_irqrestore(&capi_drivers_list_lock, flags);
 765                         printk(KERN_ERR "kcapi: driver not loaded.\n");
 766                         return -EIO;
 767                 }
 768                 if (!driver->add_card) {
 769                         read_unlock_irqrestore(&capi_drivers_list_lock, flags);
 770                         printk(KERN_ERR "kcapi: driver has no add card function.\n");
 771                         return -EIO;
 772                 }
 773
 774                 retval = driver->add_card(driver, &cparams);
 775                 read_unlock_irqrestore(&capi_drivers_list_lock, flags);
 776                 return retval;
 777
 778         case AVMB1_LOAD:
 779         case AVMB1_LOAD_AND_CONFIG:
 780
 781                 if (cmd == AVMB1_LOAD) {
 782                         if (copy_from_user(&ldef, data,
 783                                            sizeof(avmb1_loaddef)))
 784                                 return -EFAULT;
 785                         ldef.t4config.len = 0;
 786                         ldef.t4config.data = NULL;
 787                 } else {
 788                         if (copy_from_user(&ldef, data,
 789                                            sizeof(avmb1_loadandconfigdef)))
 790                                 return -EFAULT;
 791                 }
 792                 card = get_capi_ctr_by_nr(ldef.contr);
 793                 card = capi_ctr_get(card);
 794                 if (!card)
 795                         return -ESRCH;
 796                 if (card->load_firmware == 0) {
 797                         printk(KERN_DEBUG "kcapi: load: no load function\n");
 798                         return -ESRCH;
 799                 }
 800
 801                 if (ldef.t4file.len <= 0) {
 802                         printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
 803                         return -EINVAL;
 804                 }
 805                 if (ldef.t4file.data == 0) {
 806                         printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
 807                         return -EINVAL;
 808                 }
 809
 810                 ldata.firmware.user = 1;
 811                 ldata.firmware.data = ldef.t4file.data;
 812                 ldata.firmware.len = ldef.t4file.len;
 813                 ldata.configuration.user = 1;
 814                 ldata.configuration.data = ldef.t4config.data;
 815                 ldata.configuration.len = ldef.t4config.len;
 816
 817                 if (card->cardstate != CARD_DETECTED) {
 818                         printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
 819                         return -EBUSY;
 820                 }
 821                 card->cardstate = CARD_LOADING;
 822
 823                 retval = card->load_firmware(card, &ldata);
 824
 825                 if (retval) {
 826                         card->cardstate = CARD_DETECTED;
 827                         capi_ctr_put(card);
 828                         return retval;
 829                 }
 830
 831                 while (card->cardstate != CARD_RUNNING) {
 832
 833                         msleep_interruptible(100);      /* 0.1 sec */
 834
 835                         if (signal_pending(current)) {
 836                                 capi_ctr_put(card);
 837                                 return -EINTR;
 838                         }
 839                 }
 840                 capi_ctr_put(card);
 841                 return 0;
 842
 843         case AVMB1_RESETCARD:
 844                 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
 845                         return -EFAULT;
 846                 card = get_capi_ctr_by_nr(rdef.contr);
 847                 if (!card)
 848                         return -ESRCH;
 849
 850                 if (card->cardstate == CARD_DETECTED)
 851                         return 0;
 852
 853                 card->reset_ctr(card);
 854
 855                 while (card->cardstate > CARD_DETECTED) {
 856
 857                         msleep_interruptible(100);      /* 0.1 sec */
 858
 859                         if (signal_pending(current))
 860                                 return -EINTR;
 861                 }
 862                 return 0;
 863
 864         }
 865         return -EINVAL;
 866 }
 867 #endif
 868
 869 int capi20_manufacturer(unsigned int cmd, void __user *data)
 870 {
 871         struct capi_ctr *card;
 872
 873         switch (cmd) {
 874 #ifdef CONFIG_AVMB1_COMPAT
 875         case AVMB1_LOAD:
 876         case AVMB1_LOAD_AND_CONFIG:
 877         case AVMB1_RESETCARD:
 878         case AVMB1_GET_CARDINFO:
 879         case AVMB1_REMOVECARD:
 880                 return old_capi_manufacturer(cmd, data);
 881 #endif
 882         case KCAPI_CMD_TRACE:
 883         {
 884                 kcapi_flagdef fdef;
 885
 886                 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
 887                         return -EFAULT;
 888
 889                 card = get_capi_ctr_by_nr(fdef.contr);
 890                 if (!card)
 891                         return -ESRCH;
 892
 893                 card->traceflag = fdef.flag;
 894                 printk(KERN_INFO "kcapi: contr %d set trace=%d\n",
 895                         card->cnr, card->traceflag);
 896                 return 0;
 897         }
 898         case KCAPI_CMD_ADDCARD:
 899         {
 900                 struct list_head *l;
 901                 struct capi_driver *driver = NULL;
 902                 capicardparams cparams;
 903                 kcapi_carddef cdef;
 904                 int retval;
 905
 906                 if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
 907                         return retval;
 908
 909                 cparams.port = cdef.port;
 910                 cparams.irq = cdef.irq;
 911                 cparams.membase = cdef.membase;
 912                 cparams.cardnr = cdef.cardnr;
 913                 cparams.cardtype = 0;
 914                 cdef.driver[sizeof(cdef.driver)-1] = 0;
 915
 916                 list_for_each(l, &capi_drivers) {
 917                         driver = list_entry(l, struct capi_driver, list);
 918                         if (strcmp(driver->name, cdef.driver) == 0)
 919                                 break;
 920                 }
 921                 if (driver == 0) {
 922                         printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
 923                                         cdef.driver);
 924                         return -ESRCH;
 925                 }
 926
 927                 if (!driver->add_card) {
 928                         printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
 929                         return -EIO;
 930                 }
 931
 932                 return driver->add_card(driver, &cparams);
 933         }
 934
 935         default:
 936                 printk(KERN_ERR "kcapi: manufacturer command %d unknown.\n",
 937                                         cmd);
 938                 break;
 939
 940         }
 941         return -EINVAL;
 942 }
 943
 944 EXPORT_SYMBOL(capi20_manufacturer);
 945
 946 /* temporary hack */
 947 void capi20_set_callback(struct capi20_appl *ap,
 948                          void (*callback) (unsigned int cmd, __u32 contr, void *data))
 949 {
 950         ap->callback = callback;
 951 }
 952
 953 EXPORT_SYMBOL(capi20_set_callback);
 954
 955 /* ------------------------------------------------------------- */
 956 /* -------- Init & Cleanup ------------------------------------- */
 957 /* ------------------------------------------------------------- */
 958
 959 /*
 960  * init / exit functions
 961  */
 962
 963 static int __init kcapi_init(void)
 964 {
 965         char *p;
 966         char rev[32];
 967
 968         kcapi_proc_init();
 969
 970         if ((p = strchr(revision, ':')) != 0 && p[1]) {
 971                 strlcpy(rev, p + 2, sizeof(rev));
 972                 if ((p = strchr(rev, '$')) != 0 && p > rev)
 973                    *(p-1) = 0;
 974         } else
 975                 strcpy(rev, "1.0");
 976
 977         printk(KERN_NOTICE "CAPI Subsystem Rev %s\n", rev);
 978
 979         return 0;
 980 }
 981
 982 static void __exit kcapi_exit(void)
 983 {
 984         kcapi_proc_exit();
 985
 986         /* make sure all notifiers are finished */
 987         flush_scheduled_work();
 988 }
 989
 990 module_init(kcapi_init);
 991 module_exit(kcapi_exit);