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 #include "kcapi.h"
  14 #include <linux/module.h>
  15 #include <linux/mm.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/ioport.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/sched/signal.h>
  20 #include <linux/seq_file.h>
  21 #include <linux/skbuff.h>
  22 #include <linux/workqueue.h>
  23 #include <linux/capi.h>
  24 #include <linux/kernelcapi.h>
  25 #include <linux/init.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/isdn/capicmd.h>
  31 #include <linux/isdn/capiutil.h>
  32 #include <linux/mutex.h>
  33 #include <linux/rcupdate.h>
  34
  35 static int showcapimsgs = 0;
  36 static struct workqueue_struct *kcapi_wq;
  37
  38 module_param(showcapimsgs, uint, 0);
  39
  40 /* ------------------------------------------------------------- */
  41
  42 struct capictr_event {
  43         struct work_struct work;
  44         unsigned int type;
  45         u32 controller;
  46 };
  47
  48 /* ------------------------------------------------------------- */
  49
  50 static const struct capi_version driver_version = {2, 0, 1, 1 << 4};
  51 static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
  52 static char capi_manufakturer[64] = "AVM Berlin";
  53
  54 #define NCCI2CTRL(ncci)    (((ncci) >> 24) & 0x7f)
  55
  56 struct capi_ctr *capi_controller[CAPI_MAXCONTR];
  57 DEFINE_MUTEX(capi_controller_lock);
  58
  59 struct capi20_appl *capi_applications[CAPI_MAXAPPL];
  60
  61 static int ncontrollers;
  62
  63 /* -------- controller ref counting -------------------------------------- */
  64
  65 static inline struct capi_ctr *
  66 capi_ctr_get(struct capi_ctr *ctr)
  67 {
  68         if (!try_module_get(ctr->owner))
  69                 return NULL;
  70         return ctr;
  71 }
  72
  73 static inline void
  74 capi_ctr_put(struct capi_ctr *ctr)
  75 {
  76         module_put(ctr->owner);
  77 }
  78
  79 /* ------------------------------------------------------------- */
  80
  81 static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
  82 {
  83         if (contr < 1 || contr - 1 >= CAPI_MAXCONTR)
  84                 return NULL;
  85
  86         return capi_controller[contr - 1];
  87 }
  88
  89 static inline struct capi20_appl *__get_capi_appl_by_nr(u16 applid)
  90 {
  91         lockdep_assert_held(&capi_controller_lock);
  92
  93         if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
  94                 return NULL;
  95
  96         return capi_applications[applid - 1];
  97 }
  98
  99 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
 100 {
 101         if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
 102                 return NULL;
 103
 104         return rcu_dereference(capi_applications[applid - 1]);
 105 }
 106
 107 /* -------- util functions ------------------------------------ */
 108
 109 static inline int capi_cmd_valid(u8 cmd)
 110 {
 111         switch (cmd) {
 112         case CAPI_ALERT:
 113         case CAPI_CONNECT:
 114         case CAPI_CONNECT_ACTIVE:
 115         case CAPI_CONNECT_B3_ACTIVE:
 116         case CAPI_CONNECT_B3:
 117         case CAPI_CONNECT_B3_T90_ACTIVE:
 118         case CAPI_DATA_B3:
 119         case CAPI_DISCONNECT_B3:
 120         case CAPI_DISCONNECT:
 121         case CAPI_FACILITY:
 122         case CAPI_INFO:
 123         case CAPI_LISTEN:
 124         case CAPI_MANUFACTURER:
 125         case CAPI_RESET_B3:
 126         case CAPI_SELECT_B_PROTOCOL:
 127                 return 1;
 128         }
 129         return 0;
 130 }
 131
 132 static inline int capi_subcmd_valid(u8 subcmd)
 133 {
 134         switch (subcmd) {
 135         case CAPI_REQ:
 136         case CAPI_CONF:
 137         case CAPI_IND:
 138         case CAPI_RESP:
 139                 return 1;
 140         }
 141         return 0;
 142 }
 143
 144 /* ------------------------------------------------------------ */
 145
 146 static void
 147 register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
 148 {
 149         ctr = capi_ctr_get(ctr);
 150
 151         if (ctr)
 152                 ctr->register_appl(ctr, applid, rparam);
 153         else
 154                 printk(KERN_WARNING "%s: cannot get controller resources\n",
 155                        __func__);
 156 }
 157
 158
 159 static void release_appl(struct capi_ctr *ctr, u16 applid)
 160 {
 161         DBG("applid %#x", applid);
 162
 163         ctr->release_appl(ctr, applid);
 164         capi_ctr_put(ctr);
 165 }
 166
 167 static void notify_up(u32 contr)
 168 {
 169         struct capi20_appl *ap;
 170         struct capi_ctr *ctr;
 171         u16 applid;
 172
 173         mutex_lock(&capi_controller_lock);
 174
 175         if (showcapimsgs & 1)
 176                 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
 177
 178         ctr = get_capi_ctr_by_nr(contr);
 179         if (ctr) {
 180                 if (ctr->state == CAPI_CTR_RUNNING)
 181                         goto unlock_out;
 182
 183                 ctr->state = CAPI_CTR_RUNNING;
 184
 185                 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 186                         ap = __get_capi_appl_by_nr(applid);
 187                         if (ap)
 188                                 register_appl(ctr, applid, &ap->rparam);
 189                 }
 190         } else
 191                 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
 192
 193 unlock_out:
 194         mutex_unlock(&capi_controller_lock);
 195 }
 196
 197 static void ctr_down(struct capi_ctr *ctr, int new_state)
 198 {
 199         struct capi20_appl *ap;
 200         u16 applid;
 201
 202         if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED)
 203                 return;
 204
 205         ctr->state = new_state;
 206
 207         memset(ctr->manu, 0, sizeof(ctr->manu));
 208         memset(&ctr->version, 0, sizeof(ctr->version));
 209         memset(&ctr->profile, 0, sizeof(ctr->profile));
 210         memset(ctr->serial, 0, sizeof(ctr->serial));
 211
 212         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 213                 ap = __get_capi_appl_by_nr(applid);
 214                 if (ap)
 215                         capi_ctr_put(ctr);
 216         }
 217 }
 218
 219 static void notify_down(u32 contr)
 220 {
 221         struct capi_ctr *ctr;
 222
 223         mutex_lock(&capi_controller_lock);
 224
 225         if (showcapimsgs & 1)
 226                 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
 227
 228         ctr = get_capi_ctr_by_nr(contr);
 229         if (ctr)
 230                 ctr_down(ctr, CAPI_CTR_DETECTED);
 231         else
 232                 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
 233
 234         mutex_unlock(&capi_controller_lock);
 235 }
 236
 237 static void do_notify_work(struct work_struct *work)
 238 {
 239         struct capictr_event *event =
 240                 container_of(work, struct capictr_event, work);
 241
 242         switch (event->type) {
 243         case CAPICTR_UP:
 244                 notify_up(event->controller);
 245                 break;
 246         case CAPICTR_DOWN:
 247                 notify_down(event->controller);
 248                 break;
 249         }
 250
 251         kfree(event);
 252 }
 253
 254 static int notify_push(unsigned int event_type, u32 controller)
 255 {
 256         struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);
 257
 258         if (!event)
 259                 return -ENOMEM;
 260
 261         INIT_WORK(&event->work, do_notify_work);
 262         event->type = event_type;
 263         event->controller = controller;
 264
 265         queue_work(kcapi_wq, &event->work);
 266         return 0;
 267 }
 268
 269 /* -------- Receiver ------------------------------------------ */
 270
 271 static void recv_handler(struct work_struct *work)
 272 {
 273         struct sk_buff *skb;
 274         struct capi20_appl *ap =
 275                 container_of(work, struct capi20_appl, recv_work);
 276
 277         if ((!ap) || (ap->release_in_progress))
 278                 return;
 279
 280         mutex_lock(&ap->recv_mtx);
 281         while ((skb = skb_dequeue(&ap->recv_queue))) {
 282                 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
 283                         ap->nrecvdatapkt++;
 284                 else
 285                         ap->nrecvctlpkt++;
 286
 287                 ap->recv_message(ap, skb);
 288         }
 289         mutex_unlock(&ap->recv_mtx);
 290 }
 291
 292 /**
 293  * capi_ctr_handle_message() - handle incoming CAPI message
 294  * @ctr:        controller descriptor structure.
 295  * @appl:       application ID.
 296  * @skb:        message.
 297  *
 298  * Called by hardware driver to pass a CAPI message to the application.
 299  */
 300
 301 void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
 302                              struct sk_buff *skb)
 303 {
 304         struct capi20_appl *ap;
 305         int showctl = 0;
 306         u8 cmd, subcmd;
 307         _cdebbuf *cdb;
 308
 309         if (ctr->state != CAPI_CTR_RUNNING) {
 310                 cdb = capi_message2str(skb->data);
 311                 if (cdb) {
 312                         printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
 313                                ctr->cnr, cdb->buf);
 314                         cdebbuf_free(cdb);
 315                 } else
 316                         printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
 317                                ctr->cnr);
 318                 goto error;
 319         }
 320
 321         cmd = CAPIMSG_COMMAND(skb->data);
 322         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 323         if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
 324                 ctr->nrecvdatapkt++;
 325                 if (ctr->traceflag > 2)
 326                         showctl |= 2;
 327         } else {
 328                 ctr->nrecvctlpkt++;
 329                 if (ctr->traceflag)
 330                         showctl |= 2;
 331         }
 332         showctl |= (ctr->traceflag & 1);
 333         if (showctl & 2) {
 334                 if (showctl & 1) {
 335                         printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",
 336                                ctr->cnr, CAPIMSG_APPID(skb->data),
 337                                capi_cmd2str(cmd, subcmd),
 338                                CAPIMSG_LEN(skb->data));
 339                 } else {
 340                         cdb = capi_message2str(skb->data);
 341                         if (cdb) {
 342                                 printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
 343                                        ctr->cnr, cdb->buf);
 344                                 cdebbuf_free(cdb);
 345                         } else
 346                                 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
 347                                        ctr->cnr, CAPIMSG_APPID(skb->data),
 348                                        capi_cmd2str(cmd, subcmd),
 349                                        CAPIMSG_LEN(skb->data));
 350                 }
 351
 352         }
 353
 354         rcu_read_lock();
 355         ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
 356         if (!ap) {
 357                 rcu_read_unlock();
 358                 cdb = capi_message2str(skb->data);
 359                 if (cdb) {
 360                         printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
 361                                CAPIMSG_APPID(skb->data), cdb->buf);
 362                         cdebbuf_free(cdb);
 363                 } else
 364                         printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n",
 365                                CAPIMSG_APPID(skb->data),
 366                                capi_cmd2str(cmd, subcmd));
 367                 goto error;
 368         }
 369         skb_queue_tail(&ap->recv_queue, skb);
 370         queue_work(kcapi_wq, &ap->recv_work);
 371         rcu_read_unlock();
 372
 373         return;
 374
 375 error:
 376         kfree_skb(skb);
 377 }
 378
 379 EXPORT_SYMBOL(capi_ctr_handle_message);
 380
 381 /**
 382  * capi_ctr_ready() - signal CAPI controller ready
 383  * @ctr:        controller descriptor structure.
 384  *
 385  * Called by hardware driver to signal that the controller is up and running.
 386  */
 387
 388 void capi_ctr_ready(struct capi_ctr *ctr)
 389 {
 390         printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
 391                ctr->cnr, ctr->name);
 392
 393         notify_push(CAPICTR_UP, ctr->cnr);
 394 }
 395
 396 EXPORT_SYMBOL(capi_ctr_ready);
 397
 398 /**
 399  * capi_ctr_down() - signal CAPI controller not ready
 400  * @ctr:        controller descriptor structure.
 401  *
 402  * Called by hardware driver to signal that the controller is down and
 403  * unavailable for use.
 404  */
 405
 406 void capi_ctr_down(struct capi_ctr *ctr)
 407 {
 408         printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
 409
 410         notify_push(CAPICTR_DOWN, ctr->cnr);
 411 }
 412
 413 EXPORT_SYMBOL(capi_ctr_down);
 414
 415 /* ------------------------------------------------------------- */
 416
 417 /**
 418  * attach_capi_ctr() - register CAPI controller
 419  * @ctr:        controller descriptor structure.
 420  *
 421  * Called by hardware driver to register a controller with the CAPI subsystem.
 422  * Return value: 0 on success, error code < 0 on error
 423  */
 424
 425 int attach_capi_ctr(struct capi_ctr *ctr)
 426 {
 427         int i;
 428
 429         mutex_lock(&capi_controller_lock);
 430
 431         for (i = 0; i < CAPI_MAXCONTR; i++) {
 432                 if (!capi_controller[i])
 433                         break;
 434         }
 435         if (i == CAPI_MAXCONTR) {
 436                 mutex_unlock(&capi_controller_lock);
 437                 printk(KERN_ERR "kcapi: out of controller slots\n");
 438                 return -EBUSY;
 439         }
 440         capi_controller[i] = ctr;
 441
 442         ctr->nrecvctlpkt = 0;
 443         ctr->nrecvdatapkt = 0;
 444         ctr->nsentctlpkt = 0;
 445         ctr->nsentdatapkt = 0;
 446         ctr->cnr = i + 1;
 447         ctr->state = CAPI_CTR_DETECTED;
 448         ctr->blocked = 0;
 449         ctr->traceflag = showcapimsgs;
 450
 451         sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
 452         ctr->procent = proc_create_single_data(ctr->procfn, 0, NULL,
 453                         ctr->proc_show, ctr);
 454
 455         ncontrollers++;
 456
 457         mutex_unlock(&capi_controller_lock);
 458
 459         printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
 460                ctr->cnr, ctr->name);
 461         return 0;
 462 }
 463
 464 EXPORT_SYMBOL(attach_capi_ctr);
 465
 466 /**
 467  * detach_capi_ctr() - unregister CAPI controller
 468  * @ctr:        controller descriptor structure.
 469  *
 470  * Called by hardware driver to remove the registration of a controller
 471  * with the CAPI subsystem.
 472  * Return value: 0 on success, error code < 0 on error
 473  */
 474
 475 int detach_capi_ctr(struct capi_ctr *ctr)
 476 {
 477         int err = 0;
 478
 479         mutex_lock(&capi_controller_lock);
 480
 481         ctr_down(ctr, CAPI_CTR_DETACHED);
 482
 483         if (capi_controller[ctr->cnr - 1] != ctr) {
 484                 err = -EINVAL;
 485                 goto unlock_out;
 486         }
 487         capi_controller[ctr->cnr - 1] = NULL;
 488         ncontrollers--;
 489
 490         if (ctr->procent)
 491                 remove_proc_entry(ctr->procfn, NULL);
 492
 493         printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
 494                ctr->cnr, ctr->name);
 495
 496 unlock_out:
 497         mutex_unlock(&capi_controller_lock);
 498
 499         return err;
 500 }
 501
 502 EXPORT_SYMBOL(detach_capi_ctr);
 503
 504 /* ------------------------------------------------------------- */
 505 /* -------- CAPI2.0 Interface ---------------------------------- */
 506 /* ------------------------------------------------------------- */
 507
 508 /**
 509  * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED
 510  *
 511  * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller
 512  *      is ready for use, CAPI_REGNOTINSTALLED otherwise)
 513  */
 514
 515 u16 capi20_isinstalled(void)
 516 {
 517         u16 ret = CAPI_REGNOTINSTALLED;
 518         int i;
 519
 520         mutex_lock(&capi_controller_lock);
 521
 522         for (i = 0; i < CAPI_MAXCONTR; i++)
 523                 if (capi_controller[i] &&
 524                     capi_controller[i]->state == CAPI_CTR_RUNNING) {
 525                         ret = CAPI_NOERROR;
 526                         break;
 527                 }
 528
 529         mutex_unlock(&capi_controller_lock);
 530
 531         return ret;
 532 }
 533
 534 /**
 535  * capi20_register() - CAPI 2.0 operation CAPI_REGISTER
 536  * @ap:         CAPI application descriptor structure.
 537  *
 538  * Register an application's presence with CAPI.
 539  * A unique application ID is assigned and stored in @ap->applid.
 540  * After this function returns successfully, the message receive
 541  * callback function @ap->recv_message() may be called at any time
 542  * until capi20_release() has been called for the same @ap.
 543  * Return value: CAPI result code
 544  */
 545
 546 u16 capi20_register(struct capi20_appl *ap)
 547 {
 548         int i;
 549         u16 applid;
 550
 551         DBG("");
 552
 553         if (ap->rparam.datablklen < 128)
 554                 return CAPI_LOGBLKSIZETOSMALL;
 555
 556         ap->nrecvctlpkt = 0;
 557         ap->nrecvdatapkt = 0;
 558         ap->nsentctlpkt = 0;
 559         ap->nsentdatapkt = 0;
 560         mutex_init(&ap->recv_mtx);
 561         skb_queue_head_init(&ap->recv_queue);
 562         INIT_WORK(&ap->recv_work, recv_handler);
 563         ap->release_in_progress = 0;
 564
 565         mutex_lock(&capi_controller_lock);
 566
 567         for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
 568                 if (capi_applications[applid - 1] == NULL)
 569                         break;
 570         }
 571         if (applid > CAPI_MAXAPPL) {
 572                 mutex_unlock(&capi_controller_lock);
 573                 return CAPI_TOOMANYAPPLS;
 574         }
 575
 576         ap->applid = applid;
 577         capi_applications[applid - 1] = ap;
 578
 579         for (i = 0; i < CAPI_MAXCONTR; i++) {
 580                 if (!capi_controller[i] ||
 581                     capi_controller[i]->state != CAPI_CTR_RUNNING)
 582                         continue;
 583                 register_appl(capi_controller[i], applid, &ap->rparam);
 584         }
 585
 586         mutex_unlock(&capi_controller_lock);
 587
 588         if (showcapimsgs & 1) {
 589                 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
 590         }
 591
 592         return CAPI_NOERROR;
 593 }
 594
 595 /**
 596  * capi20_release() - CAPI 2.0 operation CAPI_RELEASE
 597  * @ap:         CAPI application descriptor structure.
 598  *
 599  * Terminate an application's registration with CAPI.
 600  * After this function returns successfully, the message receive
 601  * callback function @ap->recv_message() will no longer be called.
 602  * Return value: CAPI result code
 603  */
 604
 605 u16 capi20_release(struct capi20_appl *ap)
 606 {
 607         int i;
 608
 609         DBG("applid %#x", ap->applid);
 610
 611         mutex_lock(&capi_controller_lock);
 612
 613         ap->release_in_progress = 1;
 614         capi_applications[ap->applid - 1] = NULL;
 615
 616         synchronize_rcu();
 617
 618         for (i = 0; i < CAPI_MAXCONTR; i++) {
 619                 if (!capi_controller[i] ||
 620                     capi_controller[i]->state != CAPI_CTR_RUNNING)
 621                         continue;
 622                 release_appl(capi_controller[i], ap->applid);
 623         }
 624
 625         mutex_unlock(&capi_controller_lock);
 626
 627         flush_workqueue(kcapi_wq);
 628         skb_queue_purge(&ap->recv_queue);
 629
 630         if (showcapimsgs & 1) {
 631                 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
 632         }
 633
 634         return CAPI_NOERROR;
 635 }
 636
 637 /**
 638  * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE
 639  * @ap:         CAPI application descriptor structure.
 640  * @skb:        CAPI message.
 641  *
 642  * Transfer a single message to CAPI.
 643  * Return value: CAPI result code
 644  */
 645
 646 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
 647 {
 648         struct capi_ctr *ctr;
 649         int showctl = 0;
 650         u8 cmd, subcmd;
 651
 652         DBG("applid %#x", ap->applid);
 653
 654         if (ncontrollers == 0)
 655                 return CAPI_REGNOTINSTALLED;
 656         if ((ap->applid == 0) || ap->release_in_progress)
 657                 return CAPI_ILLAPPNR;
 658         if (skb->len < 12
 659             || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
 660             || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
 661                 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
 662
 663         /*
 664          * The controller reference is protected by the existence of the
 665          * application passed to us. We assume that the caller properly
 666          * synchronizes this service with capi20_release.
 667          */
 668         ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
 669         if (!ctr || ctr->state != CAPI_CTR_RUNNING)
 670                 return CAPI_REGNOTINSTALLED;
 671         if (ctr->blocked)
 672                 return CAPI_SENDQUEUEFULL;
 673
 674         cmd = CAPIMSG_COMMAND(skb->data);
 675         subcmd = CAPIMSG_SUBCOMMAND(skb->data);
 676
 677         if (cmd == CAPI_DATA_B3 && subcmd == CAPI_REQ) {
 678                 ctr->nsentdatapkt++;
 679                 ap->nsentdatapkt++;
 680                 if (ctr->traceflag > 2)
 681                         showctl |= 2;
 682         } else {
 683                 ctr->nsentctlpkt++;
 684                 ap->nsentctlpkt++;
 685                 if (ctr->traceflag)
 686                         showctl |= 2;
 687         }
 688         showctl |= (ctr->traceflag & 1);
 689         if (showctl & 2) {
 690                 if (showctl & 1) {
 691                         printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
 692                                CAPIMSG_CONTROLLER(skb->data),
 693                                CAPIMSG_APPID(skb->data),
 694                                capi_cmd2str(cmd, subcmd),
 695                                CAPIMSG_LEN(skb->data));
 696                 } else {
 697                         _cdebbuf *cdb = capi_message2str(skb->data);
 698                         if (cdb) {
 699                                 printk(KERN_DEBUG "kcapi: put [%03d] %s\n",
 700                                        CAPIMSG_CONTROLLER(skb->data),
 701                                        cdb->buf);
 702                                 cdebbuf_free(cdb);
 703                         } else
 704                                 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
 705                                        CAPIMSG_CONTROLLER(skb->data),
 706                                        CAPIMSG_APPID(skb->data),
 707                                        capi_cmd2str(cmd, subcmd),
 708                                        CAPIMSG_LEN(skb->data));
 709                 }
 710         }
 711         return ctr->send_message(ctr, skb);
 712 }
 713
 714 /**
 715  * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER
 716  * @contr:      controller number.
 717  * @buf:        result buffer (64 bytes).
 718  *
 719  * Retrieve information about the manufacturer of the specified ISDN controller
 720  * or (for @contr == 0) the driver itself.
 721  * Return value: CAPI result code
 722  */
 723
 724 u16 capi20_get_manufacturer(u32 contr, u8 buf[CAPI_MANUFACTURER_LEN])
 725 {
 726         struct capi_ctr *ctr;
 727         u16 ret;
 728
 729         if (contr == 0) {
 730                 strncpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
 731                 return CAPI_NOERROR;
 732         }
 733
 734         mutex_lock(&capi_controller_lock);
 735
 736         ctr = get_capi_ctr_by_nr(contr);
 737         if (ctr && ctr->state == CAPI_CTR_RUNNING) {
 738                 strncpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
 739                 ret = CAPI_NOERROR;
 740         } else
 741                 ret = CAPI_REGNOTINSTALLED;
 742
 743         mutex_unlock(&capi_controller_lock);
 744         return ret;
 745 }
 746
 747 /**
 748  * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION
 749  * @contr:      controller number.
 750  * @verp:       result structure.
 751  *
 752  * Retrieve version information for the specified ISDN controller
 753  * or (for @contr == 0) the driver itself.
 754  * Return value: CAPI result code
 755  */
 756
 757 u16 capi20_get_version(u32 contr, struct capi_version *verp)
 758 {
 759         struct capi_ctr *ctr;
 760         u16 ret;
 761
 762         if (contr == 0) {
 763                 *verp = driver_version;
 764                 return CAPI_NOERROR;
 765         }
 766
 767         mutex_lock(&capi_controller_lock);
 768
 769         ctr = get_capi_ctr_by_nr(contr);
 770         if (ctr && ctr->state == CAPI_CTR_RUNNING) {
 771                 memcpy(verp, &ctr->version, sizeof(capi_version));
 772                 ret = CAPI_NOERROR;
 773         } else
 774                 ret = CAPI_REGNOTINSTALLED;
 775
 776         mutex_unlock(&capi_controller_lock);
 777         return ret;
 778 }
 779
 780 /**
 781  * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER
 782  * @contr:      controller number.
 783  * @serial:     result buffer (8 bytes).
 784  *
 785  * Retrieve the serial number of the specified ISDN controller
 786  * or (for @contr == 0) the driver itself.
 787  * Return value: CAPI result code
 788  */
 789
 790 u16 capi20_get_serial(u32 contr, u8 serial[CAPI_SERIAL_LEN])
 791 {
 792         struct capi_ctr *ctr;
 793         u16 ret;
 794
 795         if (contr == 0) {
 796                 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
 797                 return CAPI_NOERROR;
 798         }
 799
 800         mutex_lock(&capi_controller_lock);
 801
 802         ctr = get_capi_ctr_by_nr(contr);
 803         if (ctr && ctr->state == CAPI_CTR_RUNNING) {
 804                 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
 805                 ret = CAPI_NOERROR;
 806         } else
 807                 ret = CAPI_REGNOTINSTALLED;
 808
 809         mutex_unlock(&capi_controller_lock);
 810         return ret;
 811 }
 812
 813 /**
 814  * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE
 815  * @contr:      controller number.
 816  * @profp:      result structure.
 817  *
 818  * Retrieve capability information for the specified ISDN controller
 819  * or (for @contr == 0) the number of installed controllers.
 820  * Return value: CAPI result code
 821  */
 822
 823 u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
 824 {
 825         struct capi_ctr *ctr;
 826         u16 ret;
 827
 828         if (contr == 0) {
 829                 profp->ncontroller = ncontrollers;
 830                 return CAPI_NOERROR;
 831         }
 832
 833         mutex_lock(&capi_controller_lock);
 834
 835         ctr = get_capi_ctr_by_nr(contr);
 836         if (ctr && ctr->state == CAPI_CTR_RUNNING) {
 837                 memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
 838                 ret = CAPI_NOERROR;
 839         } else
 840                 ret = CAPI_REGNOTINSTALLED;
 841
 842         mutex_unlock(&capi_controller_lock);
 843         return ret;
 844 }
 845
 846 /**
 847  * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER
 848  * @cmd:        command.
 849  * @data:       parameter.
 850  *
 851  * Perform manufacturer specific command.
 852  * Return value: CAPI result code
 853  */
 854
 855 int capi20_manufacturer(unsigned long cmd, void __user *data)
 856 {
 857         struct capi_ctr *ctr;
 858         int retval;
 859
 860         switch (cmd) {
 861         case KCAPI_CMD_TRACE:
 862         {
 863                 kcapi_flagdef fdef;
 864
 865                 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
 866                         return -EFAULT;
 867
 868                 mutex_lock(&capi_controller_lock);
 869
 870                 ctr = get_capi_ctr_by_nr(fdef.contr);
 871                 if (ctr) {
 872                         ctr->traceflag = fdef.flag;
 873                         printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
 874                                ctr->cnr, ctr->traceflag);
 875                         retval = 0;
 876                 } else
 877                         retval = -ESRCH;
 878
 879                 mutex_unlock(&capi_controller_lock);
 880
 881                 return retval;
 882         }
 883
 884         default:
 885                 printk(KERN_ERR "kcapi: manufacturer command %lu unknown.\n",
 886                        cmd);
 887                 break;
 888
 889         }
 890         return -EINVAL;
 891 }
 892
 893 /* ------------------------------------------------------------- */
 894 /* -------- Init & Cleanup ------------------------------------- */
 895 /* ------------------------------------------------------------- */
 896
 897 /*
 898  * init / exit functions
 899  */
 900
 901 int __init kcapi_init(void)
 902 {
 903         int err;
 904
 905         kcapi_wq = alloc_workqueue("kcapi", 0, 0);
 906         if (!kcapi_wq)
 907                 return -ENOMEM;
 908
 909         err = cdebug_init();
 910         if (err) {
 911                 destroy_workqueue(kcapi_wq);
 912                 return err;
 913         }
 914
 915         kcapi_proc_init();
 916         return 0;
 917 }
 918
 919 void kcapi_exit(void)
 920 {
 921         kcapi_proc_exit();
 922
 923         cdebug_exit();
 924         destroy_workqueue(kcapi_wq);
 925 }