drivers/isdn/gigaset/capi.c

   1 /*
   2  * Kernel CAPI interface for the Gigaset driver
   3  *
   4  * Copyright (c) 2009 by Tilman Schmidt <tilman@imap.cc>.
   5  *
   6  * =====================================================================
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License as
   9  *      published by the Free Software Foundation; either version 2 of
  10  *      the License, or (at your option) any later version.
  11  * =====================================================================
  12  */
  13
  14 #include "gigaset.h"
  15 #include <linux/proc_fs.h>
  16 #include <linux/seq_file.h>
  17 #include <linux/isdn/capilli.h>
  18 #include <linux/isdn/capicmd.h>
  19 #include <linux/isdn/capiutil.h>
  20
  21 /* missing from kernelcapi.h */
  22 #define CapiNcpiNotSupportedByProtocol  0x0001
  23 #define CapiFlagsNotSupportedByProtocol 0x0002
  24 #define CapiAlertAlreadySent            0x0003
  25 #define CapiFacilitySpecificFunctionNotSupported        0x3011
  26
  27 /* missing from capicmd.h */
  28 #define CAPI_CONNECT_IND_BASELEN        (CAPI_MSG_BASELEN+4+2+8*1)
  29 #define CAPI_CONNECT_ACTIVE_IND_BASELEN (CAPI_MSG_BASELEN+4+3*1)
  30 #define CAPI_CONNECT_B3_IND_BASELEN     (CAPI_MSG_BASELEN+4+1)
  31 #define CAPI_CONNECT_B3_ACTIVE_IND_BASELEN      (CAPI_MSG_BASELEN+4+1)
  32 #define CAPI_DATA_B3_REQ_LEN64          (CAPI_MSG_BASELEN+4+4+2+2+2+8)
  33 #define CAPI_DATA_B3_CONF_LEN           (CAPI_MSG_BASELEN+4+2+2)
  34 #define CAPI_DISCONNECT_IND_LEN         (CAPI_MSG_BASELEN+4+2)
  35 #define CAPI_DISCONNECT_B3_IND_BASELEN  (CAPI_MSG_BASELEN+4+2+1)
  36 #define CAPI_FACILITY_CONF_BASELEN      (CAPI_MSG_BASELEN+4+2+2+1)
  37 /* most _CONF messages contain only Controller/PLCI/NCCI and Info parameters */
  38 #define CAPI_STDCONF_LEN                (CAPI_MSG_BASELEN+4+2)
  39
  40 #define CAPI_FACILITY_HANDSET   0x0000
  41 #define CAPI_FACILITY_DTMF      0x0001
  42 #define CAPI_FACILITY_V42BIS    0x0002
  43 #define CAPI_FACILITY_SUPPSVC   0x0003
  44 #define CAPI_FACILITY_WAKEUP    0x0004
  45 #define CAPI_FACILITY_LI        0x0005
  46
  47 #define CAPI_SUPPSVC_GETSUPPORTED       0x0000
  48 #define CAPI_SUPPSVC_LISTEN             0x0001
  49
  50 /* missing from capiutil.h */
  51 #define CAPIMSG_PLCI_PART(m)    CAPIMSG_U8(m, 9)
  52 #define CAPIMSG_NCCI_PART(m)    CAPIMSG_U16(m, 10)
  53 #define CAPIMSG_HANDLE_REQ(m)   CAPIMSG_U16(m, 18) /* DATA_B3_REQ/_IND only! */
  54 #define CAPIMSG_FLAGS(m)        CAPIMSG_U16(m, 20)
  55 #define CAPIMSG_SETCONTROLLER(m, contr) capimsg_setu8(m, 8, contr)
  56 #define CAPIMSG_SETPLCI_PART(m, plci)   capimsg_setu8(m, 9, plci)
  57 #define CAPIMSG_SETNCCI_PART(m, ncci)   capimsg_setu16(m, 10, ncci)
  58 #define CAPIMSG_SETFLAGS(m, flags)      capimsg_setu16(m, 20, flags)
  59
  60 /* parameters with differing location in DATA_B3_CONF/_RESP: */
  61 #define CAPIMSG_SETHANDLE_CONF(m, handle)       capimsg_setu16(m, 12, handle)
  62 #define CAPIMSG_SETINFO_CONF(m, info)           capimsg_setu16(m, 14, info)
  63
  64 /* Flags (DATA_B3_REQ/_IND) */
  65 #define CAPI_FLAGS_DELIVERY_CONFIRMATION        0x04
  66 #define CAPI_FLAGS_RESERVED                     (~0x1f)
  67
  68 /* buffer sizes */
  69 #define MAX_BC_OCTETS 11
  70 #define MAX_HLC_OCTETS 3
  71 #define MAX_NUMBER_DIGITS 20
  72 #define MAX_FMT_IE_LEN 20
  73
  74 /* values for bcs->apconnstate */
  75 #define APCONN_NONE     0       /* inactive/listening */
  76 #define APCONN_SETUP    1       /* connecting */
  77 #define APCONN_ACTIVE   2       /* B channel up */
  78
  79 /* registered application data structure */
  80 struct gigaset_capi_appl {
  81         struct list_head ctrlist;
  82         struct gigaset_capi_appl *bcnext;
  83         u16 id;
  84         struct capi_register_params rp;
  85         u16 nextMessageNumber;
  86         u32 listenInfoMask;
  87         u32 listenCIPmask;
  88 };
  89
  90 /* CAPI specific controller data structure */
  91 struct gigaset_capi_ctr {
  92         struct capi_ctr ctr;
  93         struct list_head appls;
  94         struct sk_buff_head sendqueue;
  95         atomic_t sendqlen;
  96         /* two _cmsg structures possibly used concurrently: */
  97         _cmsg hcmsg;    /* for message composition triggered from hardware */
  98         _cmsg acmsg;    /* for dissection of messages sent from application */
  99         u8 bc_buf[MAX_BC_OCTETS+1];
 100         u8 hlc_buf[MAX_HLC_OCTETS+1];
 101         u8 cgpty_buf[MAX_NUMBER_DIGITS+3];
 102         u8 cdpty_buf[MAX_NUMBER_DIGITS+2];
 103 };
 104
 105 /* CIP Value table (from CAPI 2.0 standard, ch. 6.1) */
 106 static struct {
 107         u8 *bc;
 108         u8 *hlc;
 109 } cip2bchlc[] = {
 110         [1] = { "8090A3", NULL },
 111                 /* Speech (A-law) */
 112         [2] = { "8890", NULL },
 113                 /* Unrestricted digital information */
 114         [3] = { "8990", NULL },
 115                 /* Restricted digital information */
 116         [4] = { "9090A3", NULL },
 117                 /* 3,1 kHz audio (A-law) */
 118         [5] = { "9190", NULL },
 119                 /* 7 kHz audio */
 120         [6] = { "9890", NULL },
 121                 /* Video */
 122         [7] = { "88C0C6E6", NULL },
 123                 /* Packet mode */
 124         [8] = { "8890218F", NULL },
 125                 /* 56 kbit/s rate adaptation */
 126         [9] = { "9190A5", NULL },
 127                 /* Unrestricted digital information with tones/announcements */
 128         [16] = { "8090A3", "9181" },
 129                 /* Telephony */
 130         [17] = { "9090A3", "9184" },
 131                 /* Group 2/3 facsimile */
 132         [18] = { "8890", "91A1" },
 133                 /* Group 4 facsimile Class 1 */
 134         [19] = { "8890", "91A4" },
 135                 /* Teletex service basic and mixed mode
 136                    and Group 4 facsimile service Classes II and III */
 137         [20] = { "8890", "91A8" },
 138                 /* Teletex service basic and processable mode */
 139         [21] = { "8890", "91B1" },
 140                 /* Teletex service basic mode */
 141         [22] = { "8890", "91B2" },
 142                 /* International interworking for Videotex */
 143         [23] = { "8890", "91B5" },
 144                 /* Telex */
 145         [24] = { "8890", "91B8" },
 146                 /* Message Handling Systems in accordance with X.400 */
 147         [25] = { "8890", "91C1" },
 148                 /* OSI application in accordance with X.200 */
 149         [26] = { "9190A5", "9181" },
 150                 /* 7 kHz telephony */
 151         [27] = { "9190A5", "916001" },
 152                 /* Video telephony, first connection */
 153         [28] = { "8890", "916002" },
 154                 /* Video telephony, second connection */
 155 };
 156
 157 /*
 158  * helper functions
 159  * ================
 160  */
 161
 162 /*
 163  * emit unsupported parameter warning
 164  */
 165 static inline void ignore_cstruct_param(struct cardstate *cs, _cstruct param,
 166                                        char *msgname, char *paramname)
 167 {
 168         if (param && *param)
 169                 dev_warn(cs->dev, "%s: ignoring unsupported parameter: %s\n",
 170                          msgname, paramname);
 171 }
 172
 173 /*
 174  * convert an IE from Gigaset hex string to ETSI binary representation
 175  * including length byte
 176  * return value: result length, -1 on error
 177  */
 178 static int encode_ie(char *in, u8 *out, int maxlen)
 179 {
 180         int l = 0;
 181         while (*in) {
 182                 if (!isxdigit(in[0]) || !isxdigit(in[1]) || l >= maxlen)
 183                         return -1;
 184                 out[++l] = (hex_to_bin(in[0]) << 4) + hex_to_bin(in[1]);
 185                 in += 2;
 186         }
 187         out[0] = l;
 188         return l;
 189 }
 190
 191 /*
 192  * convert an IE from ETSI binary representation including length byte
 193  * to Gigaset hex string
 194  */
 195 static void decode_ie(u8 *in, char *out)
 196 {
 197         int i = *in;
 198         while (i-- > 0) {
 199                 /* ToDo: conversion to upper case necessary? */
 200                 *out++ = toupper(hex_asc_hi(*++in));
 201                 *out++ = toupper(hex_asc_lo(*in));
 202         }
 203 }
 204
 205 /*
 206  * retrieve application data structure for an application ID
 207  */
 208 static inline struct gigaset_capi_appl *
 209 get_appl(struct gigaset_capi_ctr *iif, u16 appl)
 210 {
 211         struct gigaset_capi_appl *ap;
 212
 213         list_for_each_entry(ap, &iif->appls, ctrlist)
 214                 if (ap->id == appl)
 215                         return ap;
 216         return NULL;
 217 }
 218
 219 /*
 220  * dump CAPI message to kernel messages for debugging
 221  */
 222 static inline void dump_cmsg(enum debuglevel level, const char *tag, _cmsg *p)
 223 {
 224 #ifdef CONFIG_GIGASET_DEBUG
 225         _cdebbuf *cdb;
 226
 227         if (!(gigaset_debuglevel & level))
 228                 return;
 229
 230         cdb = capi_cmsg2str(p);
 231         if (cdb) {
 232                 gig_dbg(level, "%s: [%d] %s", tag, p->ApplId, cdb->buf);
 233                 cdebbuf_free(cdb);
 234         } else {
 235                 gig_dbg(level, "%s: [%d] %s", tag, p->ApplId,
 236                         capi_cmd2str(p->Command, p->Subcommand));
 237         }
 238 #endif
 239 }
 240
 241 static inline void dump_rawmsg(enum debuglevel level, const char *tag,
 242                                unsigned char *data)
 243 {
 244 #ifdef CONFIG_GIGASET_DEBUG
 245         char *dbgline;
 246         int i, l;
 247
 248         if (!(gigaset_debuglevel & level))
 249                 return;
 250
 251         l = CAPIMSG_LEN(data);
 252         if (l < 12) {
 253                 gig_dbg(level, "%s: ??? LEN=%04d", tag, l);
 254                 return;
 255         }
 256         gig_dbg(level, "%s: 0x%02x:0x%02x: ID=%03d #0x%04x LEN=%04d NCCI=0x%x",
 257                 tag, CAPIMSG_COMMAND(data), CAPIMSG_SUBCOMMAND(data),
 258                 CAPIMSG_APPID(data), CAPIMSG_MSGID(data), l,
 259                 CAPIMSG_CONTROL(data));
 260         l -= 12;
 261         dbgline = kmalloc(3*l, GFP_ATOMIC);
 262         if (!dbgline)
 263                 return;
 264         for (i = 0; i < l; i++) {
 265                 dbgline[3*i] = hex_asc_hi(data[12+i]);
 266                 dbgline[3*i+1] = hex_asc_lo(data[12+i]);
 267                 dbgline[3*i+2] = ' ';
 268         }
 269         dbgline[3*l-1] = '\0';
 270         gig_dbg(level, "  %s", dbgline);
 271         kfree(dbgline);
 272         if (CAPIMSG_COMMAND(data) == CAPI_DATA_B3 &&
 273             (CAPIMSG_SUBCOMMAND(data) == CAPI_REQ ||
 274              CAPIMSG_SUBCOMMAND(data) == CAPI_IND)) {
 275                 l = CAPIMSG_DATALEN(data);
 276                 gig_dbg(level, "   DataLength=%d", l);
 277                 if (l <= 0 || !(gigaset_debuglevel & DEBUG_LLDATA))
 278                         return;
 279                 if (l > 64)
 280                         l = 64; /* arbitrary limit */
 281                 dbgline = kmalloc(3*l, GFP_ATOMIC);
 282                 if (!dbgline)
 283                         return;
 284                 data += CAPIMSG_LEN(data);
 285                 for (i = 0; i < l; i++) {
 286                         dbgline[3*i] = hex_asc_hi(data[i]);
 287                         dbgline[3*i+1] = hex_asc_lo(data[i]);
 288                         dbgline[3*i+2] = ' ';
 289                 }
 290                 dbgline[3*l-1] = '\0';
 291                 gig_dbg(level, "  %s", dbgline);
 292                 kfree(dbgline);
 293         }
 294 #endif
 295 }
 296
 297 /*
 298  * format CAPI IE as string
 299  */
 300
 301 static const char *format_ie(const char *ie)
 302 {
 303         static char result[3*MAX_FMT_IE_LEN];
 304         int len, count;
 305         char *pout = result;
 306
 307         if (!ie)
 308                 return "NULL";
 309
 310         count = len = ie[0];
 311         if (count > MAX_FMT_IE_LEN)
 312                 count = MAX_FMT_IE_LEN-1;
 313         while (count--) {
 314                 *pout++ = hex_asc_hi(*++ie);
 315                 *pout++ = hex_asc_lo(*ie);
 316                 *pout++ = ' ';
 317         }
 318         if (len > MAX_FMT_IE_LEN) {
 319                 *pout++ = '.';
 320                 *pout++ = '.';
 321                 *pout++ = '.';
 322         }
 323         *--pout = 0;
 324         return result;
 325 }
 326
 327 /*
 328  * emit DATA_B3_CONF message
 329  */
 330 static void send_data_b3_conf(struct cardstate *cs, struct capi_ctr *ctr,
 331                               u16 appl, u16 msgid, int channel,
 332                               u16 handle, u16 info)
 333 {
 334         struct sk_buff *cskb;
 335         u8 *msg;
 336
 337         cskb = alloc_skb(CAPI_DATA_B3_CONF_LEN, GFP_ATOMIC);
 338         if (!cskb) {
 339                 dev_err(cs->dev, "%s: out of memory\n", __func__);
 340                 return;
 341         }
 342         /* frequent message, avoid _cmsg overhead */
 343         msg = __skb_put(cskb, CAPI_DATA_B3_CONF_LEN);
 344         CAPIMSG_SETLEN(msg, CAPI_DATA_B3_CONF_LEN);
 345         CAPIMSG_SETAPPID(msg, appl);
 346         CAPIMSG_SETCOMMAND(msg, CAPI_DATA_B3);
 347         CAPIMSG_SETSUBCOMMAND(msg,  CAPI_CONF);
 348         CAPIMSG_SETMSGID(msg, msgid);
 349         CAPIMSG_SETCONTROLLER(msg, ctr->cnr);
 350         CAPIMSG_SETPLCI_PART(msg, channel);
 351         CAPIMSG_SETNCCI_PART(msg, 1);
 352         CAPIMSG_SETHANDLE_CONF(msg, handle);
 353         CAPIMSG_SETINFO_CONF(msg, info);
 354
 355         /* emit message */
 356         dump_rawmsg(DEBUG_MCMD, __func__, msg);
 357         capi_ctr_handle_message(ctr, appl, cskb);
 358 }
 359
 360
 361 /*
 362  * driver interface functions
 363  * ==========================
 364  */
 365
 366 /**
 367  * gigaset_skb_sent() - acknowledge transmission of outgoing skb
 368  * @bcs:        B channel descriptor structure.
 369  * @skb:        sent data.
 370  *
 371  * Called by hardware module {bas,ser,usb}_gigaset when the data in a
 372  * skb has been successfully sent, for signalling completion to the LL.
 373  */
 374 void gigaset_skb_sent(struct bc_state *bcs, struct sk_buff *dskb)
 375 {
 376         struct cardstate *cs = bcs->cs;
 377         struct gigaset_capi_ctr *iif = cs->iif;
 378         struct gigaset_capi_appl *ap = bcs->ap;
 379         unsigned char *req = skb_mac_header(dskb);
 380         u16 flags;
 381
 382         /* update statistics */
 383         ++bcs->trans_up;
 384
 385         if (!ap) {
 386                 gig_dbg(DEBUG_MCMD, "%s: application gone", __func__);
 387                 return;
 388         }
 389
 390         /* don't send further B3 messages if disconnected */
 391         if (bcs->apconnstate < APCONN_ACTIVE) {
 392                 gig_dbg(DEBUG_MCMD, "%s: disconnected", __func__);
 393                 return;
 394         }
 395
 396         /*
 397          * send DATA_B3_CONF if "delivery confirmation" bit was set in request;
 398          * otherwise it has already been sent by do_data_b3_req()
 399          */
 400         flags = CAPIMSG_FLAGS(req);
 401         if (flags & CAPI_FLAGS_DELIVERY_CONFIRMATION)
 402                 send_data_b3_conf(cs, &iif->ctr, ap->id, CAPIMSG_MSGID(req),
 403                                   bcs->channel + 1, CAPIMSG_HANDLE_REQ(req),
 404                                   (flags & ~CAPI_FLAGS_DELIVERY_CONFIRMATION) ?
 405                                         CapiFlagsNotSupportedByProtocol :
 406                                         CAPI_NOERROR);
 407 }
 408 EXPORT_SYMBOL_GPL(gigaset_skb_sent);
 409
 410 /**
 411  * gigaset_skb_rcvd() - pass received skb to LL
 412  * @bcs:        B channel descriptor structure.
 413  * @skb:        received data.
 414  *
 415  * Called by hardware module {bas,ser,usb}_gigaset when user data has
 416  * been successfully received, for passing to the LL.
 417  * Warning: skb must not be accessed anymore!
 418  */
 419 void gigaset_skb_rcvd(struct bc_state *bcs, struct sk_buff *skb)
 420 {
 421         struct cardstate *cs = bcs->cs;
 422         struct gigaset_capi_ctr *iif = cs->iif;
 423         struct gigaset_capi_appl *ap = bcs->ap;
 424         int len = skb->len;
 425
 426         /* update statistics */
 427         bcs->trans_down++;
 428
 429         if (!ap) {
 430                 gig_dbg(DEBUG_MCMD, "%s: application gone", __func__);
 431                 dev_kfree_skb_any(skb);
 432                 return;
 433         }
 434
 435         /* don't send further B3 messages if disconnected */
 436         if (bcs->apconnstate < APCONN_ACTIVE) {
 437                 gig_dbg(DEBUG_MCMD, "%s: disconnected", __func__);
 438                 dev_kfree_skb_any(skb);
 439                 return;
 440         }
 441
 442         /*
 443          * prepend DATA_B3_IND message to payload
 444          * Parameters: NCCI = 1, all others 0/unused
 445          * frequent message, avoid _cmsg overhead
 446          */
 447         skb_push(skb, CAPI_DATA_B3_REQ_LEN);
 448         CAPIMSG_SETLEN(skb->data, CAPI_DATA_B3_REQ_LEN);
 449         CAPIMSG_SETAPPID(skb->data, ap->id);
 450         CAPIMSG_SETCOMMAND(skb->data, CAPI_DATA_B3);
 451         CAPIMSG_SETSUBCOMMAND(skb->data,  CAPI_IND);
 452         CAPIMSG_SETMSGID(skb->data, ap->nextMessageNumber++);
 453         CAPIMSG_SETCONTROLLER(skb->data, iif->ctr.cnr);
 454         CAPIMSG_SETPLCI_PART(skb->data, bcs->channel + 1);
 455         CAPIMSG_SETNCCI_PART(skb->data, 1);
 456         /* Data parameter not used */
 457         CAPIMSG_SETDATALEN(skb->data, len);
 458         /* Data handle parameter not used */
 459         CAPIMSG_SETFLAGS(skb->data, 0);
 460         /* Data64 parameter not present */
 461
 462         /* emit message */
 463         dump_rawmsg(DEBUG_MCMD, __func__, skb->data);
 464         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
 465 }
 466 EXPORT_SYMBOL_GPL(gigaset_skb_rcvd);
 467
 468 /**
 469  * gigaset_isdn_rcv_err() - signal receive error
 470  * @bcs:        B channel descriptor structure.
 471  *
 472  * Called by hardware module {bas,ser,usb}_gigaset when a receive error
 473  * has occurred, for signalling to the LL.
 474  */
 475 void gigaset_isdn_rcv_err(struct bc_state *bcs)
 476 {
 477         /* if currently ignoring packets, just count down */
 478         if (bcs->ignore) {
 479                 bcs->ignore--;
 480                 return;
 481         }
 482
 483         /* update statistics */
 484         bcs->corrupted++;
 485
 486         /* ToDo: signal error -> LL */
 487 }
 488 EXPORT_SYMBOL_GPL(gigaset_isdn_rcv_err);
 489
 490 /**
 491  * gigaset_isdn_icall() - signal incoming call
 492  * @at_state:   connection state structure.
 493  *
 494  * Called by main module at tasklet level to notify the LL that an incoming
 495  * call has been received. @at_state contains the parameters of the call.
 496  *
 497  * Return value: call disposition (ICALL_*)
 498  */
 499 int gigaset_isdn_icall(struct at_state_t *at_state)
 500 {
 501         struct cardstate *cs = at_state->cs;
 502         struct bc_state *bcs = at_state->bcs;
 503         struct gigaset_capi_ctr *iif = cs->iif;
 504         struct gigaset_capi_appl *ap;
 505         u32 actCIPmask;
 506         struct sk_buff *skb;
 507         unsigned int msgsize;
 508         unsigned long flags;
 509         int i;
 510
 511         /*
 512          * ToDo: signal calls without a free B channel, too
 513          * (requires a u8 handle for the at_state structure that can
 514          * be stored in the PLCI and used in the CONNECT_RESP message
 515          * handler to retrieve it)
 516          */
 517         if (!bcs)
 518                 return ICALL_IGNORE;
 519
 520         /* prepare CONNECT_IND message, using B channel number as PLCI */
 521         capi_cmsg_header(&iif->hcmsg, 0, CAPI_CONNECT, CAPI_IND, 0,
 522                          iif->ctr.cnr | ((bcs->channel + 1) << 8));
 523
 524         /* minimum size, all structs empty */
 525         msgsize = CAPI_CONNECT_IND_BASELEN;
 526
 527         /* Bearer Capability (mandatory) */
 528         if (at_state->str_var[STR_ZBC]) {
 529                 /* pass on BC from Gigaset */
 530                 if (encode_ie(at_state->str_var[STR_ZBC], iif->bc_buf,
 531                               MAX_BC_OCTETS) < 0) {
 532                         dev_warn(cs->dev, "RING ignored - bad BC %s\n",
 533                                  at_state->str_var[STR_ZBC]);
 534                         return ICALL_IGNORE;
 535                 }
 536
 537                 /* look up corresponding CIP value */
 538                 iif->hcmsg.CIPValue = 0;        /* default if nothing found */
 539                 for (i = 0; i < ARRAY_SIZE(cip2bchlc); i++)
 540                         if (cip2bchlc[i].bc != NULL &&
 541                             cip2bchlc[i].hlc == NULL &&
 542                             !strcmp(cip2bchlc[i].bc,
 543                                     at_state->str_var[STR_ZBC])) {
 544                                 iif->hcmsg.CIPValue = i;
 545                                 break;
 546                         }
 547         } else {
 548                 /* no BC (internal call): assume CIP 1 (speech, A-law) */
 549                 iif->hcmsg.CIPValue = 1;
 550                 encode_ie(cip2bchlc[1].bc, iif->bc_buf, MAX_BC_OCTETS);
 551         }
 552         iif->hcmsg.BC = iif->bc_buf;
 553         msgsize += iif->hcmsg.BC[0];
 554
 555         /* High Layer Compatibility (optional) */
 556         if (at_state->str_var[STR_ZHLC]) {
 557                 /* pass on HLC from Gigaset */
 558                 if (encode_ie(at_state->str_var[STR_ZHLC], iif->hlc_buf,
 559                               MAX_HLC_OCTETS) < 0) {
 560                         dev_warn(cs->dev, "RING ignored - bad HLC %s\n",
 561                                  at_state->str_var[STR_ZHLC]);
 562                         return ICALL_IGNORE;
 563                 }
 564                 iif->hcmsg.HLC = iif->hlc_buf;
 565                 msgsize += iif->hcmsg.HLC[0];
 566
 567                 /* look up corresponding CIP value */
 568                 /* keep BC based CIP value if none found */
 569                 if (at_state->str_var[STR_ZBC])
 570                         for (i = 0; i < ARRAY_SIZE(cip2bchlc); i++)
 571                                 if (cip2bchlc[i].hlc != NULL &&
 572                                     !strcmp(cip2bchlc[i].hlc,
 573                                             at_state->str_var[STR_ZHLC]) &&
 574                                     !strcmp(cip2bchlc[i].bc,
 575                                             at_state->str_var[STR_ZBC])) {
 576                                         iif->hcmsg.CIPValue = i;
 577                                         break;
 578                                 }
 579         }
 580
 581         /* Called Party Number (optional) */
 582         if (at_state->str_var[STR_ZCPN]) {
 583                 i = strlen(at_state->str_var[STR_ZCPN]);
 584                 if (i > MAX_NUMBER_DIGITS) {
 585                         dev_warn(cs->dev, "RING ignored - bad number %s\n",
 586                                  at_state->str_var[STR_ZBC]);
 587                         return ICALL_IGNORE;
 588                 }
 589                 iif->cdpty_buf[0] = i + 1;
 590                 iif->cdpty_buf[1] = 0x80; /* type / numbering plan unknown */
 591                 memcpy(iif->cdpty_buf+2, at_state->str_var[STR_ZCPN], i);
 592                 iif->hcmsg.CalledPartyNumber = iif->cdpty_buf;
 593                 msgsize += iif->hcmsg.CalledPartyNumber[0];
 594         }
 595
 596         /* Calling Party Number (optional) */
 597         if (at_state->str_var[STR_NMBR]) {
 598                 i = strlen(at_state->str_var[STR_NMBR]);
 599                 if (i > MAX_NUMBER_DIGITS) {
 600                         dev_warn(cs->dev, "RING ignored - bad number %s\n",
 601                                  at_state->str_var[STR_ZBC]);
 602                         return ICALL_IGNORE;
 603                 }
 604                 iif->cgpty_buf[0] = i + 2;
 605                 iif->cgpty_buf[1] = 0x00; /* type / numbering plan unknown */
 606                 iif->cgpty_buf[2] = 0x80; /* pres. allowed, not screened */
 607                 memcpy(iif->cgpty_buf+3, at_state->str_var[STR_NMBR], i);
 608                 iif->hcmsg.CallingPartyNumber = iif->cgpty_buf;
 609                 msgsize += iif->hcmsg.CallingPartyNumber[0];
 610         }
 611
 612         /* remaining parameters (not supported, always left NULL):
 613          * - CalledPartySubaddress
 614          * - CallingPartySubaddress
 615          * - AdditionalInfo
 616          *   - BChannelinformation
 617          *   - Keypadfacility
 618          *   - Useruserdata
 619          *   - Facilitydataarray
 620          */
 621
 622         gig_dbg(DEBUG_CMD, "icall: PLCI %x CIP %d BC %s",
 623                 iif->hcmsg.adr.adrPLCI, iif->hcmsg.CIPValue,
 624                 format_ie(iif->hcmsg.BC));
 625         gig_dbg(DEBUG_CMD, "icall: HLC %s",
 626                 format_ie(iif->hcmsg.HLC));
 627         gig_dbg(DEBUG_CMD, "icall: CgPty %s",
 628                 format_ie(iif->hcmsg.CallingPartyNumber));
 629         gig_dbg(DEBUG_CMD, "icall: CdPty %s",
 630                 format_ie(iif->hcmsg.CalledPartyNumber));
 631
 632         /* scan application list for matching listeners */
 633         spin_lock_irqsave(&bcs->aplock, flags);
 634         if (bcs->ap != NULL || bcs->apconnstate != APCONN_NONE) {
 635                 dev_warn(cs->dev, "%s: channel not properly cleared (%p/%d)\n",
 636                          __func__, bcs->ap, bcs->apconnstate);
 637                 bcs->ap = NULL;
 638                 bcs->apconnstate = APCONN_NONE;
 639         }
 640         spin_unlock_irqrestore(&bcs->aplock, flags);
 641         actCIPmask = 1 | (1 << iif->hcmsg.CIPValue);
 642         list_for_each_entry(ap, &iif->appls, ctrlist)
 643                 if (actCIPmask & ap->listenCIPmask) {
 644                         /* build CONNECT_IND message for this application */
 645                         iif->hcmsg.ApplId = ap->id;
 646                         iif->hcmsg.Messagenumber = ap->nextMessageNumber++;
 647
 648                         skb = alloc_skb(msgsize, GFP_ATOMIC);
 649                         if (!skb) {
 650                                 dev_err(cs->dev, "%s: out of memory\n",
 651                                         __func__);
 652                                 break;
 653                         }
 654                         capi_cmsg2message(&iif->hcmsg, __skb_put(skb, msgsize));
 655                         dump_cmsg(DEBUG_CMD, __func__, &iif->hcmsg);
 656
 657                         /* add to listeners on this B channel, update state */
 658                         spin_lock_irqsave(&bcs->aplock, flags);
 659                         ap->bcnext = bcs->ap;
 660                         bcs->ap = ap;
 661                         bcs->chstate |= CHS_NOTIFY_LL;
 662                         bcs->apconnstate = APCONN_SETUP;
 663                         spin_unlock_irqrestore(&bcs->aplock, flags);
 664
 665                         /* emit message */
 666                         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
 667                 }
 668
 669         /*
 670          * Return "accept" if any listeners.
 671          * Gigaset will send ALERTING.
 672          * There doesn't seem to be a way to avoid this.
 673          */
 674         return bcs->ap ? ICALL_ACCEPT : ICALL_IGNORE;
 675 }
 676
 677 /*
 678  * send a DISCONNECT_IND message to an application
 679  * does not sleep, clobbers the controller's hcmsg structure
 680  */
 681 static void send_disconnect_ind(struct bc_state *bcs,
 682                                 struct gigaset_capi_appl *ap, u16 reason)
 683 {
 684         struct cardstate *cs = bcs->cs;
 685         struct gigaset_capi_ctr *iif = cs->iif;
 686         struct sk_buff *skb;
 687
 688         if (bcs->apconnstate == APCONN_NONE)
 689                 return;
 690
 691         capi_cmsg_header(&iif->hcmsg, ap->id, CAPI_DISCONNECT, CAPI_IND,
 692                          ap->nextMessageNumber++,
 693                          iif->ctr.cnr | ((bcs->channel + 1) << 8));
 694         iif->hcmsg.Reason = reason;
 695         skb = alloc_skb(CAPI_DISCONNECT_IND_LEN, GFP_ATOMIC);
 696         if (!skb) {
 697                 dev_err(cs->dev, "%s: out of memory\n", __func__);
 698                 return;
 699         }
 700         capi_cmsg2message(&iif->hcmsg, __skb_put(skb, CAPI_DISCONNECT_IND_LEN));
 701         dump_cmsg(DEBUG_CMD, __func__, &iif->hcmsg);
 702         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
 703 }
 704
 705 /*
 706  * send a DISCONNECT_B3_IND message to an application
 707  * Parameters: NCCI = 1, NCPI empty, Reason_B3 = 0
 708  * does not sleep, clobbers the controller's hcmsg structure
 709  */
 710 static void send_disconnect_b3_ind(struct bc_state *bcs,
 711                                    struct gigaset_capi_appl *ap)
 712 {
 713         struct cardstate *cs = bcs->cs;
 714         struct gigaset_capi_ctr *iif = cs->iif;
 715         struct sk_buff *skb;
 716
 717         /* nothing to do if no logical connection active */
 718         if (bcs->apconnstate < APCONN_ACTIVE)
 719                 return;
 720         bcs->apconnstate = APCONN_SETUP;
 721
 722         capi_cmsg_header(&iif->hcmsg, ap->id, CAPI_DISCONNECT_B3, CAPI_IND,
 723                          ap->nextMessageNumber++,
 724                          iif->ctr.cnr | ((bcs->channel + 1) << 8) | (1 << 16));
 725         skb = alloc_skb(CAPI_DISCONNECT_B3_IND_BASELEN, GFP_ATOMIC);
 726         if (!skb) {
 727                 dev_err(cs->dev, "%s: out of memory\n", __func__);
 728                 return;
 729         }
 730         capi_cmsg2message(&iif->hcmsg,
 731                           __skb_put(skb, CAPI_DISCONNECT_B3_IND_BASELEN));
 732         dump_cmsg(DEBUG_CMD, __func__, &iif->hcmsg);
 733         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
 734 }
 735
 736 /**
 737  * gigaset_isdn_connD() - signal D channel connect
 738  * @bcs:        B channel descriptor structure.
 739  *
 740  * Called by main module at tasklet level to notify the LL that the D channel
 741  * connection has been established.
 742  */
 743 void gigaset_isdn_connD(struct bc_state *bcs)
 744 {
 745         struct cardstate *cs = bcs->cs;
 746         struct gigaset_capi_ctr *iif = cs->iif;
 747         struct gigaset_capi_appl *ap;
 748         struct sk_buff *skb;
 749         unsigned int msgsize;
 750         unsigned long flags;
 751
 752         spin_lock_irqsave(&bcs->aplock, flags);
 753         ap = bcs->ap;
 754         if (!ap) {
 755                 spin_unlock_irqrestore(&bcs->aplock, flags);
 756                 gig_dbg(DEBUG_CMD, "%s: application gone", __func__);
 757                 return;
 758         }
 759         if (bcs->apconnstate == APCONN_NONE) {
 760                 spin_unlock_irqrestore(&bcs->aplock, flags);
 761                 dev_warn(cs->dev, "%s: application %u not connected\n",
 762                          __func__, ap->id);
 763                 return;
 764         }
 765         spin_unlock_irqrestore(&bcs->aplock, flags);
 766         while (ap->bcnext) {
 767                 /* this should never happen */
 768                 dev_warn(cs->dev, "%s: dropping extra application %u\n",
 769                          __func__, ap->bcnext->id);
 770                 send_disconnect_ind(bcs, ap->bcnext,
 771                                     CapiCallGivenToOtherApplication);
 772                 ap->bcnext = ap->bcnext->bcnext;
 773         }
 774
 775         /* prepare CONNECT_ACTIVE_IND message
 776          * Note: LLC not supported by device
 777          */
 778         capi_cmsg_header(&iif->hcmsg, ap->id, CAPI_CONNECT_ACTIVE, CAPI_IND,
 779                          ap->nextMessageNumber++,
 780                          iif->ctr.cnr | ((bcs->channel + 1) << 8));
 781
 782         /* minimum size, all structs empty */
 783         msgsize = CAPI_CONNECT_ACTIVE_IND_BASELEN;
 784
 785         /* ToDo: set parameter: Connected number
 786          * (requires ev-layer state machine extension to collect
 787          * ZCON device reply)
 788          */
 789
 790         /* build and emit CONNECT_ACTIVE_IND message */
 791         skb = alloc_skb(msgsize, GFP_ATOMIC);
 792         if (!skb) {
 793                 dev_err(cs->dev, "%s: out of memory\n", __func__);
 794                 return;
 795         }
 796         capi_cmsg2message(&iif->hcmsg, __skb_put(skb, msgsize));
 797         dump_cmsg(DEBUG_CMD, __func__, &iif->hcmsg);
 798         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
 799 }
 800
 801 /**
 802  * gigaset_isdn_hupD() - signal D channel hangup
 803  * @bcs:        B channel descriptor structure.
 804  *
 805  * Called by main module at tasklet level to notify the LL that the D channel
 806  * connection has been shut down.
 807  */
 808 void gigaset_isdn_hupD(struct bc_state *bcs)
 809 {
 810         struct gigaset_capi_appl *ap;
 811         unsigned long flags;
 812
 813         /*
 814          * ToDo: pass on reason code reported by device
 815          * (requires ev-layer state machine extension to collect
 816          * ZCAU device reply)
 817          */
 818         spin_lock_irqsave(&bcs->aplock, flags);
 819         while (bcs->ap != NULL) {
 820                 ap = bcs->ap;
 821                 bcs->ap = ap->bcnext;
 822                 spin_unlock_irqrestore(&bcs->aplock, flags);
 823                 send_disconnect_b3_ind(bcs, ap);
 824                 send_disconnect_ind(bcs, ap, 0);
 825                 spin_lock_irqsave(&bcs->aplock, flags);
 826         }
 827         bcs->apconnstate = APCONN_NONE;
 828         spin_unlock_irqrestore(&bcs->aplock, flags);
 829 }
 830
 831 /**
 832  * gigaset_isdn_connB() - signal B channel connect
 833  * @bcs:        B channel descriptor structure.
 834  *
 835  * Called by main module at tasklet level to notify the LL that the B channel
 836  * connection has been established.
 837  */
 838 void gigaset_isdn_connB(struct bc_state *bcs)
 839 {
 840         struct cardstate *cs = bcs->cs;
 841         struct gigaset_capi_ctr *iif = cs->iif;
 842         struct gigaset_capi_appl *ap;
 843         struct sk_buff *skb;
 844         unsigned long flags;
 845         unsigned int msgsize;
 846         u8 command;
 847
 848         spin_lock_irqsave(&bcs->aplock, flags);
 849         ap = bcs->ap;
 850         if (!ap) {
 851                 spin_unlock_irqrestore(&bcs->aplock, flags);
 852                 gig_dbg(DEBUG_CMD, "%s: application gone", __func__);
 853                 return;
 854         }
 855         if (!bcs->apconnstate) {
 856                 spin_unlock_irqrestore(&bcs->aplock, flags);
 857                 dev_warn(cs->dev, "%s: application %u not connected\n",
 858                          __func__, ap->id);
 859                 return;
 860         }
 861
 862         /*
 863          * emit CONNECT_B3_ACTIVE_IND if we already got CONNECT_B3_REQ;
 864          * otherwise we have to emit CONNECT_B3_IND first, and follow up with
 865          * CONNECT_B3_ACTIVE_IND in reply to CONNECT_B3_RESP
 866          * Parameters in both cases always: NCCI = 1, NCPI empty
 867          */
 868         if (bcs->apconnstate >= APCONN_ACTIVE) {
 869                 command = CAPI_CONNECT_B3_ACTIVE;
 870                 msgsize = CAPI_CONNECT_B3_ACTIVE_IND_BASELEN;
 871         } else {
 872                 command = CAPI_CONNECT_B3;
 873                 msgsize = CAPI_CONNECT_B3_IND_BASELEN;
 874         }
 875         bcs->apconnstate = APCONN_ACTIVE;
 876
 877         spin_unlock_irqrestore(&bcs->aplock, flags);
 878
 879         while (ap->bcnext) {
 880                 /* this should never happen */
 881                 dev_warn(cs->dev, "%s: dropping extra application %u\n",
 882                          __func__, ap->bcnext->id);
 883                 send_disconnect_ind(bcs, ap->bcnext,
 884                                     CapiCallGivenToOtherApplication);
 885                 ap->bcnext = ap->bcnext->bcnext;
 886         }
 887
 888         capi_cmsg_header(&iif->hcmsg, ap->id, command, CAPI_IND,
 889                          ap->nextMessageNumber++,
 890                          iif->ctr.cnr | ((bcs->channel + 1) << 8) | (1 << 16));
 891         skb = alloc_skb(msgsize, GFP_ATOMIC);
 892         if (!skb) {
 893                 dev_err(cs->dev, "%s: out of memory\n", __func__);
 894                 return;
 895         }
 896         capi_cmsg2message(&iif->hcmsg, __skb_put(skb, msgsize));
 897         dump_cmsg(DEBUG_CMD, __func__, &iif->hcmsg);
 898         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
 899 }
 900
 901 /**
 902  * gigaset_isdn_hupB() - signal B channel hangup
 903  * @bcs:        B channel descriptor structure.
 904  *
 905  * Called by main module to notify the LL that the B channel connection has
 906  * been shut down.
 907  */
 908 void gigaset_isdn_hupB(struct bc_state *bcs)
 909 {
 910         struct gigaset_capi_appl *ap = bcs->ap;
 911
 912         /* ToDo: assure order of DISCONNECT_B3_IND and DISCONNECT_IND ? */
 913
 914         if (!ap) {
 915                 gig_dbg(DEBUG_CMD, "%s: application gone", __func__);
 916                 return;
 917         }
 918
 919         send_disconnect_b3_ind(bcs, ap);
 920 }
 921
 922 /**
 923  * gigaset_isdn_start() - signal device availability
 924  * @cs:         device descriptor structure.
 925  *
 926  * Called by main module to notify the LL that the device is available for
 927  * use.
 928  */
 929 void gigaset_isdn_start(struct cardstate *cs)
 930 {
 931         struct gigaset_capi_ctr *iif = cs->iif;
 932
 933         /* fill profile data: manufacturer name */
 934         strcpy(iif->ctr.manu, "Siemens");
 935         /* CAPI and device version */
 936         iif->ctr.version.majorversion = 2;              /* CAPI 2.0 */
 937         iif->ctr.version.minorversion = 0;
 938         /* ToDo: check/assert cs->gotfwver? */
 939         iif->ctr.version.majormanuversion = cs->fwver[0];
 940         iif->ctr.version.minormanuversion = cs->fwver[1];
 941         /* number of B channels supported */
 942         iif->ctr.profile.nbchannel = cs->channels;
 943         /* global options: internal controller, supplementary services */
 944         iif->ctr.profile.goptions = 0x11;
 945         /* B1 protocols: 64 kbit/s HDLC or transparent */
 946         iif->ctr.profile.support1 =  0x03;
 947         /* B2 protocols: transparent only */
 948         /* ToDo: X.75 SLP ? */
 949         iif->ctr.profile.support2 =  0x02;
 950         /* B3 protocols: transparent only */
 951         iif->ctr.profile.support3 =  0x01;
 952         /* no serial number */
 953         strcpy(iif->ctr.serial, "0");
 954         capi_ctr_ready(&iif->ctr);
 955 }
 956
 957 /**
 958  * gigaset_isdn_stop() - signal device unavailability
 959  * @cs:         device descriptor structure.
 960  *
 961  * Called by main module to notify the LL that the device is no longer
 962  * available for use.
 963  */
 964 void gigaset_isdn_stop(struct cardstate *cs)
 965 {
 966         struct gigaset_capi_ctr *iif = cs->iif;
 967         capi_ctr_down(&iif->ctr);
 968 }
 969
 970 /*
 971  * kernel CAPI callback methods
 972  * ============================
 973  */
 974
 975 /*
 976  * register CAPI application
 977  */
 978 static void gigaset_register_appl(struct capi_ctr *ctr, u16 appl,
 979                            capi_register_params *rp)
 980 {
 981         struct gigaset_capi_ctr *iif
 982                 = container_of(ctr, struct gigaset_capi_ctr, ctr);
 983         struct cardstate *cs = ctr->driverdata;
 984         struct gigaset_capi_appl *ap;
 985
 986         gig_dbg(DEBUG_CMD, "%s [%u] l3cnt=%u blkcnt=%u blklen=%u",
 987                 __func__, appl, rp->level3cnt, rp->datablkcnt, rp->datablklen);
 988
 989         list_for_each_entry(ap, &iif->appls, ctrlist)
 990                 if (ap->id == appl) {
 991                         dev_notice(cs->dev,
 992                                    "application %u already registered\n", appl);
 993                         return;
 994                 }
 995
 996         ap = kzalloc(sizeof(*ap), GFP_KERNEL);
 997         if (!ap) {
 998                 dev_err(cs->dev, "%s: out of memory\n", __func__);
 999                 return;
1000         }
1001         ap->id = appl;
1002         ap->rp = *rp;
1003
1004         list_add(&ap->ctrlist, &iif->appls);
1005         dev_info(cs->dev, "application %u registered\n", ap->id);
1006 }
1007
1008 /*
1009  * remove CAPI application from channel
1010  * helper function to keep indentation levels down and stay in 80 columns
1011  */
1012
1013 static inline void remove_appl_from_channel(struct bc_state *bcs,
1014                                             struct gigaset_capi_appl *ap)
1015 {
1016         struct cardstate *cs = bcs->cs;
1017         struct gigaset_capi_appl *bcap;
1018         unsigned long flags;
1019         int prevconnstate;
1020
1021         spin_lock_irqsave(&bcs->aplock, flags);
1022         bcap = bcs->ap;
1023         if (bcap == NULL) {
1024                 spin_unlock_irqrestore(&bcs->aplock, flags);
1025                 return;
1026         }
1027
1028         /* check first application on channel */
1029         if (bcap == ap) {
1030                 bcs->ap = ap->bcnext;
1031                 if (bcs->ap != NULL) {
1032                         spin_unlock_irqrestore(&bcs->aplock, flags);
1033                         return;
1034                 }
1035
1036                 /* none left, clear channel state */
1037                 prevconnstate = bcs->apconnstate;
1038                 bcs->apconnstate = APCONN_NONE;
1039                 spin_unlock_irqrestore(&bcs->aplock, flags);
1040
1041                 if (prevconnstate == APCONN_ACTIVE) {
1042                         dev_notice(cs->dev, "%s: hanging up channel %u\n",
1043                                    __func__, bcs->channel);
1044                         gigaset_add_event(cs, &bcs->at_state,
1045                                           EV_HUP, NULL, 0, NULL);
1046                         gigaset_schedule_event(cs);
1047                 }
1048                 return;
1049         }
1050
1051         /* check remaining list */
1052         do {
1053                 if (bcap->bcnext == ap) {
1054                         bcap->bcnext = bcap->bcnext->bcnext;
1055                         spin_unlock_irqrestore(&bcs->aplock, flags);
1056                         return;
1057                 }
1058                 bcap = bcap->bcnext;
1059         } while (bcap != NULL);
1060         spin_unlock_irqrestore(&bcs->aplock, flags);
1061 }
1062
1063 /*
1064  * release CAPI application
1065  */
1066 static void gigaset_release_appl(struct capi_ctr *ctr, u16 appl)
1067 {
1068         struct gigaset_capi_ctr *iif
1069                 = container_of(ctr, struct gigaset_capi_ctr, ctr);
1070         struct cardstate *cs = iif->ctr.driverdata;
1071         struct gigaset_capi_appl *ap, *tmp;
1072         unsigned ch;
1073
1074         gig_dbg(DEBUG_CMD, "%s [%u]", __func__, appl);
1075
1076         list_for_each_entry_safe(ap, tmp, &iif->appls, ctrlist)
1077                 if (ap->id == appl) {
1078                         /* remove from any channels */
1079                         for (ch = 0; ch < cs->channels; ch++)
1080                                 remove_appl_from_channel(&cs->bcs[ch], ap);
1081
1082                         /* remove from registration list */
1083                         list_del(&ap->ctrlist);
1084                         kfree(ap);
1085                         dev_info(cs->dev, "application %u released\n", appl);
1086                 }
1087 }
1088
1089 /*
1090  * =====================================================================
1091  * outgoing CAPI message handler
1092  * =====================================================================
1093  */
1094
1095 /*
1096  * helper function: emit reply message with given Info value
1097  */
1098 static void send_conf(struct gigaset_capi_ctr *iif,
1099                       struct gigaset_capi_appl *ap,
1100                       struct sk_buff *skb,
1101                       u16 info)
1102 {
1103         /*
1104          * _CONF replies always only have NCCI and Info parameters
1105          * so they'll fit into the _REQ message skb
1106          */
1107         capi_cmsg_answer(&iif->acmsg);
1108         iif->acmsg.Info = info;
1109         capi_cmsg2message(&iif->acmsg, skb->data);
1110         __skb_trim(skb, CAPI_STDCONF_LEN);
1111         dump_cmsg(DEBUG_CMD, __func__, &iif->acmsg);
1112         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
1113 }
1114
1115 /*
1116  * process FACILITY_REQ message
1117  */
1118 static void do_facility_req(struct gigaset_capi_ctr *iif,
1119                             struct gigaset_capi_appl *ap,
1120                             struct sk_buff *skb)
1121 {
1122         struct cardstate *cs = iif->ctr.driverdata;
1123         _cmsg *cmsg = &iif->acmsg;
1124         struct sk_buff *cskb;
1125         u8 *pparam;
1126         unsigned int msgsize = CAPI_FACILITY_CONF_BASELEN;
1127         u16 function, info;
1128         static u8 confparam[10];        /* max. 9 octets + length byte */
1129
1130         /* decode message */
1131         capi_message2cmsg(cmsg, skb->data);
1132         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1133
1134         /*
1135          * Facility Request Parameter is not decoded by capi_message2cmsg()
1136          * encoding depends on Facility Selector
1137          */
1138         switch (cmsg->FacilitySelector) {
1139         case CAPI_FACILITY_DTMF:        /* ToDo */
1140                 info = CapiFacilityNotSupported;
1141                 confparam[0] = 2;       /* length */
1142                 /* DTMF information: Unknown DTMF request */
1143                 capimsg_setu16(confparam, 1, 2);
1144                 break;
1145
1146         case CAPI_FACILITY_V42BIS:      /* not supported */
1147                 info = CapiFacilityNotSupported;
1148                 confparam[0] = 2;       /* length */
1149                 /* V.42 bis information: not available */
1150                 capimsg_setu16(confparam, 1, 1);
1151                 break;
1152
1153         case CAPI_FACILITY_SUPPSVC:
1154                 /* decode Function parameter */
1155                 pparam = cmsg->FacilityRequestParameter;
1156                 if (pparam == NULL || pparam[0] < 2) {
1157                         dev_notice(cs->dev, "%s: %s missing\n", "FACILITY_REQ",
1158                                    "Facility Request Parameter");
1159                         send_conf(iif, ap, skb, CapiIllMessageParmCoding);
1160                         return;
1161                 }
1162                 function = CAPIMSG_U16(pparam, 1);
1163                 switch (function) {
1164                 case CAPI_SUPPSVC_GETSUPPORTED:
1165                         info = CapiSuccess;
1166                         /* Supplementary Service specific parameter */
1167                         confparam[3] = 6;       /* length */
1168                         /* Supplementary services info: Success */
1169                         capimsg_setu16(confparam, 4, CapiSuccess);
1170                         /* Supported Services: none */
1171                         capimsg_setu32(confparam, 6, 0);
1172                         break;
1173                 case CAPI_SUPPSVC_LISTEN:
1174                         if (pparam[0] < 7 || pparam[3] < 4) {
1175                                 dev_notice(cs->dev, "%s: %s missing\n",
1176                                            "FACILITY_REQ", "Notification Mask");
1177                                 send_conf(iif, ap, skb,
1178                                           CapiIllMessageParmCoding);
1179                                 return;
1180                         }
1181                         if (CAPIMSG_U32(pparam, 4) != 0) {
1182                                 dev_notice(cs->dev,
1183         "%s: unsupported supplementary service notification mask 0x%x\n",
1184                                    "FACILITY_REQ", CAPIMSG_U32(pparam, 4));
1185                                 info = CapiFacilitySpecificFunctionNotSupported;
1186                                 confparam[3] = 2;       /* length */
1187                                 capimsg_setu16(confparam, 4,
1188                                         CapiSupplementaryServiceNotSupported);
1189                         }
1190                         info = CapiSuccess;
1191                         confparam[3] = 2;       /* length */
1192                         capimsg_setu16(confparam, 4, CapiSuccess);
1193                         break;
1194                 /* ToDo: add supported services */
1195                 default:
1196                         dev_notice(cs->dev,
1197                 "%s: unsupported supplementary service function 0x%04x\n",
1198                                    "FACILITY_REQ", function);
1199                         info = CapiFacilitySpecificFunctionNotSupported;
1200                         /* Supplementary Service specific parameter */
1201                         confparam[3] = 2;       /* length */
1202                         /* Supplementary services info: not supported */
1203                         capimsg_setu16(confparam, 4,
1204                                        CapiSupplementaryServiceNotSupported);
1205                 }
1206
1207                 /* Facility confirmation parameter */
1208                 confparam[0] = confparam[3] + 3;        /* total length */
1209                 /* Function: copy from _REQ message */
1210                 capimsg_setu16(confparam, 1, function);
1211                 /* Supplementary Service specific parameter already set above */
1212                 break;
1213
1214         case CAPI_FACILITY_WAKEUP:      /* ToDo */
1215                 info = CapiFacilityNotSupported;
1216                 confparam[0] = 2;       /* length */
1217                 /* Number of accepted awake request parameters: 0 */
1218                 capimsg_setu16(confparam, 1, 0);
1219                 break;
1220
1221         default:
1222                 info = CapiFacilityNotSupported;
1223                 confparam[0] = 0;       /* empty struct */
1224         }
1225
1226         /* send FACILITY_CONF with given Info and confirmation parameter */
1227         capi_cmsg_answer(cmsg);
1228         cmsg->Info = info;
1229         cmsg->FacilityConfirmationParameter = confparam;
1230         msgsize += confparam[0];        /* length */
1231         cskb = alloc_skb(msgsize, GFP_ATOMIC);
1232         if (!cskb) {
1233                 dev_err(cs->dev, "%s: out of memory\n", __func__);
1234                 return;
1235         }
1236         capi_cmsg2message(cmsg, __skb_put(cskb, msgsize));
1237         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1238         capi_ctr_handle_message(&iif->ctr, ap->id, cskb);
1239 }
1240
1241
1242 /*
1243  * process LISTEN_REQ message
1244  * just store the masks in the application data structure
1245  */
1246 static void do_listen_req(struct gigaset_capi_ctr *iif,
1247                           struct gigaset_capi_appl *ap,
1248                           struct sk_buff *skb)
1249 {
1250         /* decode message */
1251         capi_message2cmsg(&iif->acmsg, skb->data);
1252         dump_cmsg(DEBUG_CMD, __func__, &iif->acmsg);
1253
1254         /* store listening parameters */
1255         ap->listenInfoMask = iif->acmsg.InfoMask;
1256         ap->listenCIPmask = iif->acmsg.CIPmask;
1257         send_conf(iif, ap, skb, CapiSuccess);
1258 }
1259
1260 /*
1261  * process ALERT_REQ message
1262  * nothing to do, Gigaset always alerts anyway
1263  */
1264 static void do_alert_req(struct gigaset_capi_ctr *iif,
1265                          struct gigaset_capi_appl *ap,
1266                          struct sk_buff *skb)
1267 {
1268         /* decode message */
1269         capi_message2cmsg(&iif->acmsg, skb->data);
1270         dump_cmsg(DEBUG_CMD, __func__, &iif->acmsg);
1271         send_conf(iif, ap, skb, CapiAlertAlreadySent);
1272 }
1273
1274 /*
1275  * process CONNECT_REQ message
1276  * allocate a B channel, prepare dial commands, queue a DIAL event,
1277  * emit CONNECT_CONF reply
1278  */
1279 static void do_connect_req(struct gigaset_capi_ctr *iif,
1280                            struct gigaset_capi_appl *ap,
1281                            struct sk_buff *skb)
1282 {
1283         struct cardstate *cs = iif->ctr.driverdata;
1284         _cmsg *cmsg = &iif->acmsg;
1285         struct bc_state *bcs;
1286         char **commands;
1287         char *s;
1288         u8 *pp;
1289         unsigned long flags;
1290         int i, l, lbc, lhlc;
1291         u16 info;
1292
1293         /* decode message */
1294         capi_message2cmsg(cmsg, skb->data);
1295         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1296
1297         /* get free B channel & construct PLCI */
1298         bcs = gigaset_get_free_channel(cs);
1299         if (!bcs) {
1300                 dev_notice(cs->dev, "%s: no B channel available\n",
1301                            "CONNECT_REQ");
1302                 send_conf(iif, ap, skb, CapiNoPlciAvailable);
1303                 return;
1304         }
1305         spin_lock_irqsave(&bcs->aplock, flags);
1306         if (bcs->ap != NULL || bcs->apconnstate != APCONN_NONE)
1307                 dev_warn(cs->dev, "%s: channel not properly cleared (%p/%d)\n",
1308                          __func__, bcs->ap, bcs->apconnstate);
1309         ap->bcnext = NULL;
1310         bcs->ap = ap;
1311         bcs->apconnstate = APCONN_SETUP;
1312         spin_unlock_irqrestore(&bcs->aplock, flags);
1313
1314         bcs->rx_bufsize = ap->rp.datablklen;
1315         dev_kfree_skb(bcs->rx_skb);
1316         gigaset_new_rx_skb(bcs);
1317         cmsg->adr.adrPLCI |= (bcs->channel + 1) << 8;
1318
1319         /* build command table */
1320         commands = kzalloc(AT_NUM*(sizeof *commands), GFP_KERNEL);
1321         if (!commands)
1322                 goto oom;
1323
1324         /* encode parameter: Called party number */
1325         pp = cmsg->CalledPartyNumber;
1326         if (pp == NULL || *pp == 0) {
1327                 dev_notice(cs->dev, "%s: %s missing\n",
1328                            "CONNECT_REQ", "Called party number");
1329                 info = CapiIllMessageParmCoding;
1330                 goto error;
1331         }
1332         l = *pp++;
1333         /* check type of number/numbering plan byte */
1334         switch (*pp) {
1335         case 0x80:      /* unknown type / unknown numbering plan */
1336         case 0x81:      /* unknown type / ISDN/Telephony numbering plan */
1337                 break;
1338         default:        /* others: warn about potential misinterpretation */
1339                 dev_notice(cs->dev, "%s: %s type/plan 0x%02x unsupported\n",
1340                            "CONNECT_REQ", "Called party number", *pp);
1341         }
1342         pp++;
1343         l--;
1344         /* translate "**" internal call prefix to CTP value */
1345         if (l >= 2 && pp[0] == '*' && pp[1] == '*') {
1346                 s = "^SCTP=0\r";
1347                 pp += 2;
1348                 l -= 2;
1349         } else {
1350                 s = "^SCTP=1\r";
1351         }
1352         commands[AT_TYPE] = kstrdup(s, GFP_KERNEL);
1353         if (!commands[AT_TYPE])
1354                 goto oom;
1355         commands[AT_DIAL] = kmalloc(l+3, GFP_KERNEL);
1356         if (!commands[AT_DIAL])
1357                 goto oom;
1358         snprintf(commands[AT_DIAL], l+3, "D%.*s\r", l, pp);
1359
1360         /* encode parameter: Calling party number */
1361         pp = cmsg->CallingPartyNumber;
1362         if (pp != NULL && *pp > 0) {
1363                 l = *pp++;
1364
1365                 /* check type of number/numbering plan byte */
1366                 /* ToDo: allow for/handle Ext=1? */
1367                 switch (*pp) {
1368                 case 0x00:      /* unknown type / unknown numbering plan */
1369                 case 0x01:      /* unknown type / ISDN/Telephony num. plan */
1370                         break;
1371                 default:
1372                         dev_notice(cs->dev,
1373                                    "%s: %s type/plan 0x%02x unsupported\n",
1374                                    "CONNECT_REQ", "Calling party number", *pp);
1375                 }
1376                 pp++;
1377                 l--;
1378
1379                 /* check presentation indicator */
1380                 if (!l) {
1381                         dev_notice(cs->dev, "%s: %s IE truncated\n",
1382                                    "CONNECT_REQ", "Calling party number");
1383                         info = CapiIllMessageParmCoding;
1384                         goto error;
1385                 }
1386                 switch (*pp & 0xfc) { /* ignore Screening indicator */
1387                 case 0x80:      /* Presentation allowed */
1388                         s = "^SCLIP=1\r";
1389                         break;
1390                 case 0xa0:      /* Presentation restricted */
1391                         s = "^SCLIP=0\r";
1392                         break;
1393                 default:
1394                         dev_notice(cs->dev, "%s: invalid %s 0x%02x\n",
1395                                    "CONNECT_REQ",
1396                                    "Presentation/Screening indicator",
1397                                    *pp);
1398                         s = "^SCLIP=1\r";
1399                 }
1400                 commands[AT_CLIP] = kstrdup(s, GFP_KERNEL);
1401                 if (!commands[AT_CLIP])
1402                         goto oom;
1403                 pp++;
1404                 l--;
1405
1406                 if (l) {
1407                         /* number */
1408                         commands[AT_MSN] = kmalloc(l+8, GFP_KERNEL);
1409                         if (!commands[AT_MSN])
1410                                 goto oom;
1411                         snprintf(commands[AT_MSN], l+8, "^SMSN=%*s\r", l, pp);
1412                 }
1413         }
1414
1415         /* check parameter: CIP Value */
1416         if (cmsg->CIPValue >= ARRAY_SIZE(cip2bchlc) ||
1417             (cmsg->CIPValue > 0 && cip2bchlc[cmsg->CIPValue].bc == NULL)) {
1418                 dev_notice(cs->dev, "%s: unknown CIP value %d\n",
1419                            "CONNECT_REQ", cmsg->CIPValue);
1420                 info = CapiCipValueUnknown;
1421                 goto error;
1422         }
1423
1424         /*
1425          * check/encode parameters: BC & HLC
1426          * must be encoded together as device doesn't accept HLC separately
1427          * explicit parameters override values derived from CIP
1428          */
1429
1430         /* determine lengths */
1431         if (cmsg->BC && cmsg->BC[0])            /* BC specified explicitly */
1432                 lbc = 2*cmsg->BC[0];
1433         else if (cip2bchlc[cmsg->CIPValue].bc)  /* BC derived from CIP */
1434                 lbc = strlen(cip2bchlc[cmsg->CIPValue].bc);
1435         else                                    /* no BC */
1436                 lbc = 0;
1437         if (cmsg->HLC && cmsg->HLC[0])          /* HLC specified explicitly */
1438                 lhlc = 2*cmsg->HLC[0];
1439         else if (cip2bchlc[cmsg->CIPValue].hlc) /* HLC derived from CIP */
1440                 lhlc = strlen(cip2bchlc[cmsg->CIPValue].hlc);
1441         else                                    /* no HLC */
1442                 lhlc = 0;
1443
1444         if (lbc) {
1445                 /* have BC: allocate and assemble command string */
1446                 l = lbc + 7;            /* "^SBC=" + value + "\r" + null byte */
1447                 if (lhlc)
1448                         l += lhlc + 7;  /* ";^SHLC=" + value */
1449                 commands[AT_BC] = kmalloc(l, GFP_KERNEL);
1450                 if (!commands[AT_BC])
1451                         goto oom;
1452                 strcpy(commands[AT_BC], "^SBC=");
1453                 if (cmsg->BC && cmsg->BC[0])    /* BC specified explicitly */
1454                         decode_ie(cmsg->BC, commands[AT_BC] + 5);
1455                 else                            /* BC derived from CIP */
1456                         strcpy(commands[AT_BC] + 5,
1457                                cip2bchlc[cmsg->CIPValue].bc);
1458                 if (lhlc) {
1459                         strcpy(commands[AT_BC] + lbc + 5, ";^SHLC=");
1460                         if (cmsg->HLC && cmsg->HLC[0])
1461                                 /* HLC specified explicitly */
1462                                 decode_ie(cmsg->HLC,
1463                                           commands[AT_BC] + lbc + 12);
1464                         else    /* HLC derived from CIP */
1465                                 strcpy(commands[AT_BC] + lbc + 12,
1466                                        cip2bchlc[cmsg->CIPValue].hlc);
1467                 }
1468                 strcpy(commands[AT_BC] + l - 2, "\r");
1469         } else {
1470                 /* no BC */
1471                 if (lhlc) {
1472                         dev_notice(cs->dev, "%s: cannot set HLC without BC\n",
1473                                    "CONNECT_REQ");
1474                         info = CapiIllMessageParmCoding; /* ? */
1475                         goto error;
1476                 }
1477         }
1478
1479         /* check/encode parameter: B Protocol */
1480         if (cmsg->BProtocol == CAPI_DEFAULT) {
1481                 bcs->proto2 = L2_HDLC;
1482                 dev_warn(cs->dev,
1483                     "B2 Protocol X.75 SLP unsupported, using Transparent\n");
1484         } else {
1485                 switch (cmsg->B1protocol) {
1486                 case 0:
1487                         bcs->proto2 = L2_HDLC;
1488                         break;
1489                 case 1:
1490                         bcs->proto2 = L2_VOICE;
1491                         break;
1492                 default:
1493                         dev_warn(cs->dev,
1494                             "B1 Protocol %u unsupported, using Transparent\n",
1495                                  cmsg->B1protocol);
1496                         bcs->proto2 = L2_VOICE;
1497                 }
1498                 if (cmsg->B2protocol != 1)
1499                         dev_warn(cs->dev,
1500                             "B2 Protocol %u unsupported, using Transparent\n",
1501                                  cmsg->B2protocol);
1502                 if (cmsg->B3protocol != 0)
1503                         dev_warn(cs->dev,
1504                             "B3 Protocol %u unsupported, using Transparent\n",
1505                                  cmsg->B3protocol);
1506                 ignore_cstruct_param(cs, cmsg->B1configuration,
1507                                         "CONNECT_REQ", "B1 Configuration");
1508                 ignore_cstruct_param(cs, cmsg->B2configuration,
1509                                         "CONNECT_REQ", "B2 Configuration");
1510                 ignore_cstruct_param(cs, cmsg->B3configuration,
1511                                         "CONNECT_REQ", "B3 Configuration");
1512         }
1513         commands[AT_PROTO] = kmalloc(9, GFP_KERNEL);
1514         if (!commands[AT_PROTO])
1515                 goto oom;
1516         snprintf(commands[AT_PROTO], 9, "^SBPR=%u\r", bcs->proto2);
1517
1518         /* ToDo: check/encode remaining parameters */
1519         ignore_cstruct_param(cs, cmsg->CalledPartySubaddress,
1520                                         "CONNECT_REQ", "Called pty subaddr");
1521         ignore_cstruct_param(cs, cmsg->CallingPartySubaddress,
1522                                         "CONNECT_REQ", "Calling pty subaddr");
1523         ignore_cstruct_param(cs, cmsg->LLC,
1524                                         "CONNECT_REQ", "LLC");
1525         if (cmsg->AdditionalInfo != CAPI_DEFAULT) {
1526                 ignore_cstruct_param(cs, cmsg->BChannelinformation,
1527                                         "CONNECT_REQ", "B Channel Information");
1528                 ignore_cstruct_param(cs, cmsg->Keypadfacility,
1529                                         "CONNECT_REQ", "Keypad Facility");
1530                 ignore_cstruct_param(cs, cmsg->Useruserdata,
1531                                         "CONNECT_REQ", "User-User Data");
1532                 ignore_cstruct_param(cs, cmsg->Facilitydataarray,
1533                                         "CONNECT_REQ", "Facility Data Array");
1534         }
1535
1536         /* encode parameter: B channel to use */
1537         commands[AT_ISO] = kmalloc(9, GFP_KERNEL);
1538         if (!commands[AT_ISO])
1539                 goto oom;
1540         snprintf(commands[AT_ISO], 9, "^SISO=%u\r",
1541                  (unsigned) bcs->channel + 1);
1542
1543         /* queue & schedule EV_DIAL event */
1544         if (!gigaset_add_event(cs, &bcs->at_state, EV_DIAL, commands,
1545                                bcs->at_state.seq_index, NULL)) {
1546                 info = CAPI_MSGOSRESOURCEERR;
1547                 goto error;
1548         }
1549         gigaset_schedule_event(cs);
1550         send_conf(iif, ap, skb, CapiSuccess);
1551         return;
1552
1553 oom:
1554         dev_err(cs->dev, "%s: out of memory\n", __func__);
1555         info = CAPI_MSGOSRESOURCEERR;
1556 error:
1557         if (commands)
1558                 for (i = 0; i < AT_NUM; i++)
1559                         kfree(commands[i]);
1560         kfree(commands);
1561         gigaset_free_channel(bcs);
1562         send_conf(iif, ap, skb, info);
1563 }
1564
1565 /*
1566  * process CONNECT_RESP message
1567  * checks protocol parameters and queues an ACCEPT or HUP event
1568  */
1569 static void do_connect_resp(struct gigaset_capi_ctr *iif,
1570                             struct gigaset_capi_appl *ap,
1571                             struct sk_buff *skb)
1572 {
1573         struct cardstate *cs = iif->ctr.driverdata;
1574         _cmsg *cmsg = &iif->acmsg;
1575         struct bc_state *bcs;
1576         struct gigaset_capi_appl *oap;
1577         unsigned long flags;
1578         int channel;
1579
1580         /* decode message */
1581         capi_message2cmsg(cmsg, skb->data);
1582         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1583         dev_kfree_skb_any(skb);
1584
1585         /* extract and check channel number from PLCI */
1586         channel = (cmsg->adr.adrPLCI >> 8) & 0xff;
1587         if (!channel || channel > cs->channels) {
1588                 dev_notice(cs->dev, "%s: invalid %s 0x%02x\n",
1589                            "CONNECT_RESP", "PLCI", cmsg->adr.adrPLCI);
1590                 return;
1591         }
1592         bcs = cs->bcs + channel - 1;
1593
1594         switch (cmsg->Reject) {
1595         case 0:         /* Accept */
1596                 /* drop all competing applications, keep only this one */
1597                 spin_lock_irqsave(&bcs->aplock, flags);
1598                 while (bcs->ap != NULL) {
1599                         oap = bcs->ap;
1600                         bcs->ap = oap->bcnext;
1601                         if (oap != ap) {
1602                                 spin_unlock_irqrestore(&bcs->aplock, flags);
1603                                 send_disconnect_ind(bcs, oap,
1604                                         CapiCallGivenToOtherApplication);
1605                                 spin_lock_irqsave(&bcs->aplock, flags);
1606                         }
1607                 }
1608                 ap->bcnext = NULL;
1609                 bcs->ap = ap;
1610                 spin_unlock_irqrestore(&bcs->aplock, flags);
1611
1612                 bcs->rx_bufsize = ap->rp.datablklen;
1613                 dev_kfree_skb(bcs->rx_skb);
1614                 gigaset_new_rx_skb(bcs);
1615                 bcs->chstate |= CHS_NOTIFY_LL;
1616
1617                 /* check/encode B channel protocol */
1618                 if (cmsg->BProtocol == CAPI_DEFAULT) {
1619                         bcs->proto2 = L2_HDLC;
1620                         dev_warn(cs->dev,
1621                 "B2 Protocol X.75 SLP unsupported, using Transparent\n");
1622                 } else {
1623                         switch (cmsg->B1protocol) {
1624                         case 0:
1625                                 bcs->proto2 = L2_HDLC;
1626                                 break;
1627                         case 1:
1628                                 bcs->proto2 = L2_VOICE;
1629                                 break;
1630                         default:
1631                                 dev_warn(cs->dev,
1632                         "B1 Protocol %u unsupported, using Transparent\n",
1633                                          cmsg->B1protocol);
1634                                 bcs->proto2 = L2_VOICE;
1635                         }
1636                         if (cmsg->B2protocol != 1)
1637                                 dev_warn(cs->dev,
1638                         "B2 Protocol %u unsupported, using Transparent\n",
1639                                          cmsg->B2protocol);
1640                         if (cmsg->B3protocol != 0)
1641                                 dev_warn(cs->dev,
1642                         "B3 Protocol %u unsupported, using Transparent\n",
1643                                          cmsg->B3protocol);
1644                         ignore_cstruct_param(cs, cmsg->B1configuration,
1645                                         "CONNECT_RESP", "B1 Configuration");
1646                         ignore_cstruct_param(cs, cmsg->B2configuration,
1647                                         "CONNECT_RESP", "B2 Configuration");
1648                         ignore_cstruct_param(cs, cmsg->B3configuration,
1649                                         "CONNECT_RESP", "B3 Configuration");
1650                 }
1651
1652                 /* ToDo: check/encode remaining parameters */
1653                 ignore_cstruct_param(cs, cmsg->ConnectedNumber,
1654                                         "CONNECT_RESP", "Connected Number");
1655                 ignore_cstruct_param(cs, cmsg->ConnectedSubaddress,
1656                                         "CONNECT_RESP", "Connected Subaddress");
1657                 ignore_cstruct_param(cs, cmsg->LLC,
1658                                         "CONNECT_RESP", "LLC");
1659                 if (cmsg->AdditionalInfo != CAPI_DEFAULT) {
1660                         ignore_cstruct_param(cs, cmsg->BChannelinformation,
1661                                         "CONNECT_RESP", "BChannel Information");
1662                         ignore_cstruct_param(cs, cmsg->Keypadfacility,
1663                                         "CONNECT_RESP", "Keypad Facility");
1664                         ignore_cstruct_param(cs, cmsg->Useruserdata,
1665                                         "CONNECT_RESP", "User-User Data");
1666                         ignore_cstruct_param(cs, cmsg->Facilitydataarray,
1667                                         "CONNECT_RESP", "Facility Data Array");
1668                 }
1669
1670                 /* Accept call */
1671                 if (!gigaset_add_event(cs, &cs->bcs[channel-1].at_state,
1672                                        EV_ACCEPT, NULL, 0, NULL))
1673                         return;
1674                 gigaset_schedule_event(cs);
1675                 return;
1676
1677         case 1:                 /* Ignore */
1678                 /* send DISCONNECT_IND to this application */
1679                 send_disconnect_ind(bcs, ap, 0);
1680
1681                 /* remove it from the list of listening apps */
1682                 spin_lock_irqsave(&bcs->aplock, flags);
1683                 if (bcs->ap == ap) {
1684                         bcs->ap = ap->bcnext;
1685                         if (bcs->ap == NULL) {
1686                                 /* last one: stop ev-layer hupD notifications */
1687                                 bcs->apconnstate = APCONN_NONE;
1688                                 bcs->chstate &= ~CHS_NOTIFY_LL;
1689                         }
1690                         spin_unlock_irqrestore(&bcs->aplock, flags);
1691                         return;
1692                 }
1693                 for (oap = bcs->ap; oap != NULL; oap = oap->bcnext) {
1694                         if (oap->bcnext == ap) {
1695                                 oap->bcnext = oap->bcnext->bcnext;
1696                                 spin_unlock_irqrestore(&bcs->aplock, flags);
1697                                 return;
1698                         }
1699                 }
1700                 spin_unlock_irqrestore(&bcs->aplock, flags);
1701                 dev_err(cs->dev, "%s: application %u not found\n",
1702                         __func__, ap->id);
1703                 return;
1704
1705         default:                /* Reject */
1706                 /* drop all competing applications, keep only this one */
1707                 spin_lock_irqsave(&bcs->aplock, flags);
1708                 while (bcs->ap != NULL) {
1709                         oap = bcs->ap;
1710                         bcs->ap = oap->bcnext;
1711                         if (oap != ap) {
1712                                 spin_unlock_irqrestore(&bcs->aplock, flags);
1713                                 send_disconnect_ind(bcs, oap,
1714                                         CapiCallGivenToOtherApplication);
1715                                 spin_lock_irqsave(&bcs->aplock, flags);
1716                         }
1717                 }
1718                 ap->bcnext = NULL;
1719                 bcs->ap = ap;
1720                 spin_unlock_irqrestore(&bcs->aplock, flags);
1721
1722                 /* reject call - will trigger DISCONNECT_IND for this app */
1723                 dev_info(cs->dev, "%s: Reject=%x\n",
1724                          "CONNECT_RESP", cmsg->Reject);
1725                 if (!gigaset_add_event(cs, &cs->bcs[channel-1].at_state,
1726                                        EV_HUP, NULL, 0, NULL))
1727                         return;
1728                 gigaset_schedule_event(cs);
1729                 return;
1730         }
1731 }
1732
1733 /*
1734  * process CONNECT_B3_REQ message
1735  * build NCCI and emit CONNECT_B3_CONF reply
1736  */
1737 static void do_connect_b3_req(struct gigaset_capi_ctr *iif,
1738                               struct gigaset_capi_appl *ap,
1739                               struct sk_buff *skb)
1740 {
1741         struct cardstate *cs = iif->ctr.driverdata;
1742         _cmsg *cmsg = &iif->acmsg;
1743         struct bc_state *bcs;
1744         int channel;
1745
1746         /* decode message */
1747         capi_message2cmsg(cmsg, skb->data);
1748         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1749
1750         /* extract and check channel number from PLCI */
1751         channel = (cmsg->adr.adrPLCI >> 8) & 0xff;
1752         if (!channel || channel > cs->channels) {
1753                 dev_notice(cs->dev, "%s: invalid %s 0x%02x\n",
1754                            "CONNECT_B3_REQ", "PLCI", cmsg->adr.adrPLCI);
1755                 send_conf(iif, ap, skb, CapiIllContrPlciNcci);
1756                 return;
1757         }
1758         bcs = &cs->bcs[channel-1];
1759
1760         /* mark logical connection active */
1761         bcs->apconnstate = APCONN_ACTIVE;
1762
1763         /* build NCCI: always 1 (one B3 connection only) */
1764         cmsg->adr.adrNCCI |= 1 << 16;
1765
1766         /* NCPI parameter: not applicable for B3 Transparent */
1767         ignore_cstruct_param(cs, cmsg->NCPI, "CONNECT_B3_REQ", "NCPI");
1768         send_conf(iif, ap, skb, (cmsg->NCPI && cmsg->NCPI[0]) ?
1769                                 CapiNcpiNotSupportedByProtocol : CapiSuccess);
1770 }
1771
1772 /*
1773  * process CONNECT_B3_RESP message
1774  * Depending on the Reject parameter, either emit CONNECT_B3_ACTIVE_IND
1775  * or queue EV_HUP and emit DISCONNECT_B3_IND.
1776  * The emitted message is always shorter than the received one,
1777  * allowing to reuse the skb.
1778  */
1779 static void do_connect_b3_resp(struct gigaset_capi_ctr *iif,
1780                                struct gigaset_capi_appl *ap,
1781                                struct sk_buff *skb)
1782 {
1783         struct cardstate *cs = iif->ctr.driverdata;
1784         _cmsg *cmsg = &iif->acmsg;
1785         struct bc_state *bcs;
1786         int channel;
1787         unsigned int msgsize;
1788         u8 command;
1789
1790         /* decode message */
1791         capi_message2cmsg(cmsg, skb->data);
1792         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1793
1794         /* extract and check channel number and NCCI */
1795         channel = (cmsg->adr.adrNCCI >> 8) & 0xff;
1796         if (!channel || channel > cs->channels ||
1797             ((cmsg->adr.adrNCCI >> 16) & 0xffff) != 1) {
1798                 dev_notice(cs->dev, "%s: invalid %s 0x%02x\n",
1799                            "CONNECT_B3_RESP", "NCCI", cmsg->adr.adrNCCI);
1800                 dev_kfree_skb_any(skb);
1801                 return;
1802         }
1803         bcs = &cs->bcs[channel-1];
1804
1805         if (cmsg->Reject) {
1806                 /* Reject: clear B3 connect received flag */
1807                 bcs->apconnstate = APCONN_SETUP;
1808
1809                 /* trigger hangup, causing eventual DISCONNECT_IND */
1810                 if (!gigaset_add_event(cs, &bcs->at_state,
1811                                        EV_HUP, NULL, 0, NULL)) {
1812                         dev_kfree_skb_any(skb);
1813                         return;
1814                 }
1815                 gigaset_schedule_event(cs);
1816
1817                 /* emit DISCONNECT_B3_IND */
1818                 command = CAPI_DISCONNECT_B3;
1819                 msgsize = CAPI_DISCONNECT_B3_IND_BASELEN;
1820         } else {
1821                 /*
1822                  * Accept: emit CONNECT_B3_ACTIVE_IND immediately, as
1823                  * we only send CONNECT_B3_IND if the B channel is up
1824                  */
1825                 command = CAPI_CONNECT_B3_ACTIVE;
1826                 msgsize = CAPI_CONNECT_B3_ACTIVE_IND_BASELEN;
1827         }
1828         capi_cmsg_header(cmsg, ap->id, command, CAPI_IND,
1829                          ap->nextMessageNumber++, cmsg->adr.adrNCCI);
1830         __skb_trim(skb, msgsize);
1831         capi_cmsg2message(cmsg, skb->data);
1832         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1833         capi_ctr_handle_message(&iif->ctr, ap->id, skb);
1834 }
1835
1836 /*
1837  * process DISCONNECT_REQ message
1838  * schedule EV_HUP and emit DISCONNECT_B3_IND if necessary,
1839  * emit DISCONNECT_CONF reply
1840  */
1841 static void do_disconnect_req(struct gigaset_capi_ctr *iif,
1842                               struct gigaset_capi_appl *ap,
1843                               struct sk_buff *skb)
1844 {
1845         struct cardstate *cs = iif->ctr.driverdata;
1846         _cmsg *cmsg = &iif->acmsg;
1847         struct bc_state *bcs;
1848         _cmsg *b3cmsg;
1849         struct sk_buff *b3skb;
1850         int channel;
1851
1852         /* decode message */
1853         capi_message2cmsg(cmsg, skb->data);
1854         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1855
1856         /* extract and check channel number from PLCI */
1857         channel = (cmsg->adr.adrPLCI >> 8) & 0xff;
1858         if (!channel || channel > cs->channels) {
1859                 dev_notice(cs->dev, "%s: invalid %s 0x%02x\n",
1860                            "DISCONNECT_REQ", "PLCI", cmsg->adr.adrPLCI);
1861                 send_conf(iif, ap, skb, CapiIllContrPlciNcci);
1862                 return;
1863         }
1864         bcs = cs->bcs + channel - 1;
1865
1866         /* ToDo: process parameter: Additional info */
1867         if (cmsg->AdditionalInfo != CAPI_DEFAULT) {
1868                 ignore_cstruct_param(cs, cmsg->BChannelinformation,
1869                                      "DISCONNECT_REQ", "B Channel Information");
1870                 ignore_cstruct_param(cs, cmsg->Keypadfacility,
1871                                      "DISCONNECT_REQ", "Keypad Facility");
1872                 ignore_cstruct_param(cs, cmsg->Useruserdata,
1873                                      "DISCONNECT_REQ", "User-User Data");
1874                 ignore_cstruct_param(cs, cmsg->Facilitydataarray,
1875                                      "DISCONNECT_REQ", "Facility Data Array");
1876         }
1877
1878         /* skip if DISCONNECT_IND already sent */
1879         if (!bcs->apconnstate)
1880                 return;
1881
1882         /* check for active logical connection */
1883         if (bcs->apconnstate >= APCONN_ACTIVE) {
1884                 /*
1885                  * emit DISCONNECT_B3_IND with cause 0x3301
1886                  * use separate cmsg structure, as the content of iif->acmsg
1887                  * is still needed for creating the _CONF message
1888                  */
1889                 b3cmsg = kmalloc(sizeof(*b3cmsg), GFP_KERNEL);
1890                 if (!b3cmsg) {
1891                         dev_err(cs->dev, "%s: out of memory\n", __func__);
1892                         send_conf(iif, ap, skb, CAPI_MSGOSRESOURCEERR);
1893                         return;
1894                 }
1895                 capi_cmsg_header(b3cmsg, ap->id, CAPI_DISCONNECT_B3, CAPI_IND,
1896                                  ap->nextMessageNumber++,
1897                                  cmsg->adr.adrPLCI | (1 << 16));
1898                 b3cmsg->Reason_B3 = CapiProtocolErrorLayer1;
1899                 b3skb = alloc_skb(CAPI_DISCONNECT_B3_IND_BASELEN, GFP_KERNEL);
1900                 if (b3skb == NULL) {
1901                         dev_err(cs->dev, "%s: out of memory\n", __func__);
1902                         send_conf(iif, ap, skb, CAPI_MSGOSRESOURCEERR);
1903                         kfree(b3cmsg);
1904                         return;
1905                 }
1906                 capi_cmsg2message(b3cmsg,
1907                         __skb_put(b3skb, CAPI_DISCONNECT_B3_IND_BASELEN));
1908                 kfree(b3cmsg);
1909                 capi_ctr_handle_message(&iif->ctr, ap->id, b3skb);
1910         }
1911
1912         /* trigger hangup, causing eventual DISCONNECT_IND */
1913         if (!gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL)) {
1914                 send_conf(iif, ap, skb, CAPI_MSGOSRESOURCEERR);
1915                 return;
1916         }
1917         gigaset_schedule_event(cs);
1918
1919         /* emit reply */
1920         send_conf(iif, ap, skb, CapiSuccess);
1921 }
1922
1923 /*
1924  * process DISCONNECT_B3_REQ message
1925  * schedule EV_HUP and emit DISCONNECT_B3_CONF reply
1926  */
1927 static void do_disconnect_b3_req(struct gigaset_capi_ctr *iif,
1928                                  struct gigaset_capi_appl *ap,
1929                                  struct sk_buff *skb)
1930 {
1931         struct cardstate *cs = iif->ctr.driverdata;
1932         _cmsg *cmsg = &iif->acmsg;
1933         struct bc_state *bcs;
1934         int channel;
1935
1936         /* decode message */
1937         capi_message2cmsg(cmsg, skb->data);
1938         dump_cmsg(DEBUG_CMD, __func__, cmsg);
1939
1940         /* extract and check channel number and NCCI */
1941         channel = (cmsg->adr.adrNCCI >> 8) & 0xff;
1942         if (!channel || channel > cs->channels ||
1943             ((cmsg->adr.adrNCCI >> 16) & 0xffff) != 1) {
1944                 dev_notice(cs->dev, "%s: invalid %s 0x%02x\n",
1945                            "DISCONNECT_B3_REQ", "NCCI", cmsg->adr.adrNCCI);
1946                 send_conf(iif, ap, skb, CapiIllContrPlciNcci);
1947                 return;
1948         }
1949         bcs = &cs->bcs[channel-1];
1950
1951         /* reject if logical connection not active */
1952         if (bcs->apconnstate < APCONN_ACTIVE) {
1953                 send_conf(iif, ap, skb,
1954                           CapiMessageNotSupportedInCurrentState);
1955                 return;
1956         }
1957
1958         /* trigger hangup, causing eventual DISCONNECT_B3_IND */
1959         if (!gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL)) {
1960                 send_conf(iif, ap, skb, CAPI_MSGOSRESOURCEERR);
1961                 return;
1962         }
1963         gigaset_schedule_event(cs);
1964
1965         /* NCPI parameter: not applicable for B3 Transparent */
1966         ignore_cstruct_param(cs, cmsg->NCPI,
1967                                 "DISCONNECT_B3_REQ", "NCPI");
1968         send_conf(iif, ap, skb, (cmsg->NCPI && cmsg->NCPI[0]) ?
1969                                 CapiNcpiNotSupportedByProtocol : CapiSuccess);
1970 }
1971
1972 /*
1973  * process DATA_B3_REQ message
1974  */
1975 static void do_data_b3_req(struct gigaset_capi_ctr *iif,
1976                            struct gigaset_capi_appl *ap,
1977                            struct sk_buff *skb)
1978 {
1979         struct cardstate *cs = iif->ctr.driverdata;
1980         struct bc_state *bcs;
1981         int channel = CAPIMSG_PLCI_PART(skb->data);
1982         u16 ncci = CAPIMSG_NCCI_PART(skb->data);
1983         u16 msglen = CAPIMSG_LEN(skb->data);
1984         u16 datalen = CAPIMSG_DATALEN(skb->data);
1985         u16 flags = CAPIMSG_FLAGS(skb->data);
1986         u16 msgid = CAPIMSG_MSGID(skb->data);
1987         u16 handle = CAPIMSG_HANDLE_REQ(skb->data);
1988
1989         /* frequent message, avoid _cmsg overhead */
1990         dump_rawmsg(DEBUG_MCMD, __func__, skb->data);
1991
1992         /* check parameters */
1993         if (channel == 0 || channel > cs->channels || ncci != 1) {
1994                 dev_notice(cs->dev, "%s: invalid %s 0x%02x\n",
1995                            "DATA_B3_REQ", "NCCI", CAPIMSG_NCCI(skb->data));
1996                 send_conf(iif, ap, skb, CapiIllContrPlciNcci);
1997                 return;
1998         }
1999         bcs = &cs->bcs[channel-1];
2000         if (msglen != CAPI_DATA_B3_REQ_LEN && msglen != CAPI_DATA_B3_REQ_LEN64)
2001                 dev_notice(cs->dev, "%s: unexpected length %d\n",
2002                            "DATA_B3_REQ", msglen);
2003         if (msglen + datalen != skb->len)
2004                 dev_notice(cs->dev, "%s: length mismatch (%d+%d!=%d)\n",
2005                            "DATA_B3_REQ", msglen, datalen, skb->len);
2006         if (msglen + datalen > skb->len) {
2007                 /* message too short for announced data length */
2008                 send_conf(iif, ap, skb, CapiIllMessageParmCoding); /* ? */
2009                 return;
2010         }
2011         if (flags & CAPI_FLAGS_RESERVED) {
2012                 dev_notice(cs->dev, "%s: reserved flags set (%x)\n",
2013                            "DATA_B3_REQ", flags);
2014                 send_conf(iif, ap, skb, CapiIllMessageParmCoding);
2015                 return;
2016         }
2017
2018         /* reject if logical connection not active */
2019         if (bcs->apconnstate < APCONN_ACTIVE) {
2020                 send_conf(iif, ap, skb, CapiMessageNotSupportedInCurrentState);
2021                 return;
2022         }
2023
2024         /* pull CAPI message into link layer header */
2025         skb_reset_mac_header(skb);
2026         skb->mac_len = msglen;
2027         skb_pull(skb, msglen);
2028
2029         /* pass to device-specific module */
2030         if (cs->ops->send_skb(bcs, skb) < 0) {
2031                 send_conf(iif, ap, skb, CAPI_MSGOSRESOURCEERR);
2032                 return;
2033         }
2034
2035         /*
2036          * DATA_B3_CONF will be sent by gigaset_skb_sent() only if "delivery
2037          * confirmation" bit is set; otherwise we have to send it now
2038          */
2039         if (!(flags & CAPI_FLAGS_DELIVERY_CONFIRMATION))
2040                 send_data_b3_conf(cs, &iif->ctr, ap->id, msgid, channel, handle,
2041                                   flags ? CapiFlagsNotSupportedByProtocol
2042                                         : CAPI_NOERROR);
2043 }
2044
2045 /*
2046  * process RESET_B3_REQ message
2047  * just always reply "not supported by current protocol"
2048  */
2049 static void do_reset_b3_req(struct gigaset_capi_ctr *iif,
2050                             struct gigaset_capi_appl *ap,
2051                             struct sk_buff *skb)
2052 {
2053         /* decode message */
2054         capi_message2cmsg(&iif->acmsg, skb->data);
2055         dump_cmsg(DEBUG_CMD, __func__, &iif->acmsg);
2056         send_conf(iif, ap, skb,
2057                   CapiResetProcedureNotSupportedByCurrentProtocol);
2058 }
2059
2060 /*
2061  * dump unsupported/ignored messages at most twice per minute,
2062  * some apps send those very frequently
2063  */
2064 static unsigned long ignored_msg_dump_time;
2065
2066 /*
2067  * unsupported CAPI message handler
2068  */
2069 static void do_unsupported(struct gigaset_capi_ctr *iif,
2070                            struct gigaset_capi_appl *ap,
2071                            struct sk_buff *skb)
2072 {
2073         /* decode message */
2074         capi_message2cmsg(&iif->acmsg, skb->data);
2075         if (printk_timed_ratelimit(&ignored_msg_dump_time, 30 * 1000))
2076                 dump_cmsg(DEBUG_CMD, __func__, &iif->acmsg);
2077         send_conf(iif, ap, skb, CapiMessageNotSupportedInCurrentState);
2078 }
2079
2080 /*
2081  * CAPI message handler: no-op
2082  */
2083 static void do_nothing(struct gigaset_capi_ctr *iif,
2084                        struct gigaset_capi_appl *ap,
2085                        struct sk_buff *skb)
2086 {
2087         if (printk_timed_ratelimit(&ignored_msg_dump_time, 30 * 1000)) {
2088                 /* decode message */
2089                 capi_message2cmsg(&iif->acmsg, skb->data);
2090                 dump_cmsg(DEBUG_CMD, __func__, &iif->acmsg);
2091         }
2092         dev_kfree_skb_any(skb);
2093 }
2094
2095 static void do_data_b3_resp(struct gigaset_capi_ctr *iif,
2096                             struct gigaset_capi_appl *ap,
2097                             struct sk_buff *skb)
2098 {
2099         dump_rawmsg(DEBUG_MCMD, __func__, skb->data);
2100         dev_kfree_skb_any(skb);
2101 }
2102
2103 /* table of outgoing CAPI message handlers with lookup function */
2104 typedef void (*capi_send_handler_t)(struct gigaset_capi_ctr *,
2105                                     struct gigaset_capi_appl *,
2106                                     struct sk_buff *);
2107
2108 static struct {
2109         u16 cmd;
2110         capi_send_handler_t handler;
2111 } capi_send_handler_table[] = {
2112         /* most frequent messages first for faster lookup */
2113         { CAPI_DATA_B3_REQ, do_data_b3_req },
2114         { CAPI_DATA_B3_RESP, do_data_b3_resp },
2115
2116         { CAPI_ALERT_REQ, do_alert_req },
2117         { CAPI_CONNECT_ACTIVE_RESP, do_nothing },
2118         { CAPI_CONNECT_B3_ACTIVE_RESP, do_nothing },
2119         { CAPI_CONNECT_B3_REQ, do_connect_b3_req },
2120         { CAPI_CONNECT_B3_RESP, do_connect_b3_resp },
2121         { CAPI_CONNECT_B3_T90_ACTIVE_RESP, do_nothing },
2122         { CAPI_CONNECT_REQ, do_connect_req },
2123         { CAPI_CONNECT_RESP, do_connect_resp },
2124         { CAPI_DISCONNECT_B3_REQ, do_disconnect_b3_req },
2125         { CAPI_DISCONNECT_B3_RESP, do_nothing },
2126         { CAPI_DISCONNECT_REQ, do_disconnect_req },
2127         { CAPI_DISCONNECT_RESP, do_nothing },
2128         { CAPI_FACILITY_REQ, do_facility_req },
2129         { CAPI_FACILITY_RESP, do_nothing },
2130         { CAPI_LISTEN_REQ, do_listen_req },
2131         { CAPI_SELECT_B_PROTOCOL_REQ, do_unsupported },
2132         { CAPI_RESET_B3_REQ, do_reset_b3_req },
2133         { CAPI_RESET_B3_RESP, do_nothing },
2134
2135         /*
2136          * ToDo: support overlap sending (requires ev-layer state
2137          * machine extension to generate additional ATD commands)
2138          */
2139         { CAPI_INFO_REQ, do_unsupported },
2140         { CAPI_INFO_RESP, do_nothing },
2141
2142         /*
2143          * ToDo: what's the proper response for these?
2144          */
2145         { CAPI_MANUFACTURER_REQ, do_nothing },
2146         { CAPI_MANUFACTURER_RESP, do_nothing },
2147 };
2148
2149 /* look up handler */
2150 static inline capi_send_handler_t lookup_capi_send_handler(const u16 cmd)
2151 {
2152         size_t i;
2153
2154         for (i = 0; i < ARRAY_SIZE(capi_send_handler_table); i++)
2155                 if (capi_send_handler_table[i].cmd == cmd)
2156                         return capi_send_handler_table[i].handler;
2157         return NULL;
2158 }
2159
2160
2161 /**
2162  * gigaset_send_message() - accept a CAPI message from an application
2163  * @ctr:        controller descriptor structure.
2164  * @skb:        CAPI message.
2165  *
2166  * Return value: CAPI error code
2167  * Note: capidrv (and probably others, too) only uses the return value to
2168  * decide whether it has to free the skb (only if result != CAPI_NOERROR (0))
2169  */
2170 static u16 gigaset_send_message(struct capi_ctr *ctr, struct sk_buff *skb)
2171 {
2172         struct gigaset_capi_ctr *iif
2173                 = container_of(ctr, struct gigaset_capi_ctr, ctr);
2174         struct cardstate *cs = ctr->driverdata;
2175         struct gigaset_capi_appl *ap;
2176         capi_send_handler_t handler;
2177
2178         /* can only handle linear sk_buffs */
2179         if (skb_linearize(skb) < 0) {
2180                 dev_warn(cs->dev, "%s: skb_linearize failed\n", __func__);
2181                 return CAPI_MSGOSRESOURCEERR;
2182         }
2183
2184         /* retrieve application data structure */
2185         ap = get_appl(iif, CAPIMSG_APPID(skb->data));
2186         if (!ap) {
2187                 dev_notice(cs->dev, "%s: application %u not registered\n",
2188                            __func__, CAPIMSG_APPID(skb->data));
2189                 return CAPI_ILLAPPNR;
2190         }
2191
2192         /* look up command */
2193         handler = lookup_capi_send_handler(CAPIMSG_CMD(skb->data));
2194         if (!handler) {
2195                 /* unknown/unsupported message type */
2196                 if (printk_ratelimit())
2197                         dev_notice(cs->dev, "%s: unsupported message %u\n",
2198                                    __func__, CAPIMSG_CMD(skb->data));
2199                 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
2200         }
2201
2202         /* serialize */
2203         if (atomic_add_return(1, &iif->sendqlen) > 1) {
2204                 /* queue behind other messages */
2205                 skb_queue_tail(&iif->sendqueue, skb);
2206                 return CAPI_NOERROR;
2207         }
2208
2209         /* process message */
2210         handler(iif, ap, skb);
2211
2212         /* process other messages arrived in the meantime */
2213         while (atomic_sub_return(1, &iif->sendqlen) > 0) {
2214                 skb = skb_dequeue(&iif->sendqueue);
2215                 if (!skb) {
2216                         /* should never happen */
2217                         dev_err(cs->dev, "%s: send queue empty\n", __func__);
2218                         continue;
2219                 }
2220                 ap = get_appl(iif, CAPIMSG_APPID(skb->data));
2221                 if (!ap) {
2222                         /* could that happen? */
2223                         dev_warn(cs->dev, "%s: application %u vanished\n",
2224                                  __func__, CAPIMSG_APPID(skb->data));
2225                         continue;
2226                 }
2227                 handler = lookup_capi_send_handler(CAPIMSG_CMD(skb->data));
2228                 if (!handler) {
2229                         /* should never happen */
2230                         dev_err(cs->dev, "%s: handler %x vanished\n",
2231                                 __func__, CAPIMSG_CMD(skb->data));
2232                         continue;
2233                 }
2234                 handler(iif, ap, skb);
2235         }
2236
2237         return CAPI_NOERROR;
2238 }
2239
2240 /**
2241  * gigaset_procinfo() - build single line description for controller
2242  * @ctr:        controller descriptor structure.
2243  *
2244  * Return value: pointer to generated string (null terminated)
2245  */
2246 static char *gigaset_procinfo(struct capi_ctr *ctr)
2247 {
2248         return ctr->name;       /* ToDo: more? */
2249 }
2250
2251 static int gigaset_proc_show(struct seq_file *m, void *v)
2252 {
2253         struct capi_ctr *ctr = m->private;
2254         struct cardstate *cs = ctr->driverdata;
2255         char *s;
2256         int i;
2257
2258         seq_printf(m, "%-16s %s\n", "name", ctr->name);
2259         seq_printf(m, "%-16s %s %s\n", "dev",
2260                         dev_driver_string(cs->dev), dev_name(cs->dev));
2261         seq_printf(m, "%-16s %d\n", "id", cs->myid);
2262         if (cs->gotfwver)
2263                 seq_printf(m, "%-16s %d.%d.%d.%d\n", "firmware",
2264                         cs->fwver[0], cs->fwver[1], cs->fwver[2], cs->fwver[3]);
2265         seq_printf(m, "%-16s %d\n", "channels", cs->channels);
2266         seq_printf(m, "%-16s %s\n", "onechannel", cs->onechannel ? "yes" : "no");
2267
2268         switch (cs->mode) {
2269         case M_UNKNOWN:
2270                 s = "unknown";
2271                 break;
2272         case M_CONFIG:
2273                 s = "config";
2274                 break;
2275         case M_UNIMODEM:
2276                 s = "Unimodem";
2277                 break;
2278         case M_CID:
2279                 s = "CID";
2280                 break;
2281         default:
2282                 s = "??";
2283         }
2284         seq_printf(m, "%-16s %s\n", "mode", s);
2285
2286         switch (cs->mstate) {
2287         case MS_UNINITIALIZED:
2288                 s = "uninitialized";
2289                 break;
2290         case MS_INIT:
2291                 s = "init";
2292                 break;
2293         case MS_LOCKED:
2294                 s = "locked";
2295                 break;
2296         case MS_SHUTDOWN:
2297                 s = "shutdown";
2298                 break;
2299         case MS_RECOVER:
2300                 s = "recover";
2301                 break;
2302         case MS_READY:
2303                 s = "ready";
2304                 break;
2305         default:
2306                 s = "??";
2307         }
2308         seq_printf(m, "%-16s %s\n", "mstate", s);
2309
2310         seq_printf(m, "%-16s %s\n", "running", cs->running ? "yes" : "no");
2311         seq_printf(m, "%-16s %s\n", "connected", cs->connected ? "yes" : "no");
2312         seq_printf(m, "%-16s %s\n", "isdn_up", cs->isdn_up ? "yes" : "no");
2313         seq_printf(m, "%-16s %s\n", "cidmode", cs->cidmode ? "yes" : "no");
2314
2315         for (i = 0; i < cs->channels; i++) {
2316                 seq_printf(m, "[%d]%-13s %d\n", i, "corrupted",
2317                                 cs->bcs[i].corrupted);
2318                 seq_printf(m, "[%d]%-13s %d\n", i, "trans_down",
2319                                 cs->bcs[i].trans_down);
2320                 seq_printf(m, "[%d]%-13s %d\n", i, "trans_up",
2321                                 cs->bcs[i].trans_up);
2322                 seq_printf(m, "[%d]%-13s %d\n", i, "chstate",
2323                                 cs->bcs[i].chstate);
2324                 switch (cs->bcs[i].proto2) {
2325                 case L2_BITSYNC:
2326                         s = "bitsync";
2327                         break;
2328                 case L2_HDLC:
2329                         s = "HDLC";
2330                         break;
2331                 case L2_VOICE:
2332                         s = "voice";
2333                         break;
2334                 default:
2335                         s = "??";
2336                 }
2337                 seq_printf(m, "[%d]%-13s %s\n", i, "proto2", s);
2338         }
2339         return 0;
2340 }
2341
2342 static int gigaset_proc_open(struct inode *inode, struct file *file)
2343 {
2344         return single_open(file, gigaset_proc_show, PDE(inode)->data);
2345 }
2346
2347 static const struct file_operations gigaset_proc_fops = {
2348         .owner          = THIS_MODULE,
2349         .open           = gigaset_proc_open,
2350         .read           = seq_read,
2351         .llseek         = seq_lseek,
2352         .release        = single_release,
2353 };
2354
2355 /**
2356  * gigaset_isdn_regdev() - register device to LL
2357  * @cs:         device descriptor structure.
2358  * @isdnid:     device name.
2359  *
2360  * Return value: 1 for success, 0 for failure
2361  */
2362 int gigaset_isdn_regdev(struct cardstate *cs, const char *isdnid)
2363 {
2364         struct gigaset_capi_ctr *iif;
2365         int rc;
2366
2367         iif = kmalloc(sizeof(*iif), GFP_KERNEL);
2368         if (!iif) {
2369                 pr_err("%s: out of memory\n", __func__);
2370                 return 0;
2371         }
2372
2373         /* prepare controller structure */
2374         iif->ctr.owner         = THIS_MODULE;
2375         iif->ctr.driverdata    = cs;
2376         strncpy(iif->ctr.name, isdnid, sizeof(iif->ctr.name));
2377         iif->ctr.driver_name   = "gigaset";
2378         iif->ctr.load_firmware = NULL;
2379         iif->ctr.reset_ctr     = NULL;
2380         iif->ctr.register_appl = gigaset_register_appl;
2381         iif->ctr.release_appl  = gigaset_release_appl;
2382         iif->ctr.send_message  = gigaset_send_message;
2383         iif->ctr.procinfo      = gigaset_procinfo;
2384         iif->ctr.proc_fops = &gigaset_proc_fops;
2385         INIT_LIST_HEAD(&iif->appls);
2386         skb_queue_head_init(&iif->sendqueue);
2387         atomic_set(&iif->sendqlen, 0);
2388
2389         /* register controller with CAPI */
2390         rc = attach_capi_ctr(&iif->ctr);
2391         if (rc) {
2392                 pr_err("attach_capi_ctr failed (%d)\n", rc);
2393                 kfree(iif);
2394                 return 0;
2395         }
2396
2397         cs->iif = iif;
2398         cs->hw_hdr_len = CAPI_DATA_B3_REQ_LEN;
2399         return 1;
2400 }
2401
2402 /**
2403  * gigaset_isdn_unregdev() - unregister device from LL
2404  * @cs:         device descriptor structure.
2405  */
2406 void gigaset_isdn_unregdev(struct cardstate *cs)
2407 {
2408         struct gigaset_capi_ctr *iif = cs->iif;
2409
2410         detach_capi_ctr(&iif->ctr);
2411         kfree(iif);
2412         cs->iif = NULL;
2413 }
2414
2415 static struct capi_driver capi_driver_gigaset = {
2416         .name           = "gigaset",
2417         .revision       = "1.0",
2418 };
2419
2420 /**
2421  * gigaset_isdn_regdrv() - register driver to LL
2422  */
2423 void gigaset_isdn_regdrv(void)
2424 {
2425         pr_info("Kernel CAPI interface\n");
2426         register_capi_driver(&capi_driver_gigaset);
2427 }
2428
2429 /**
2430  * gigaset_isdn_unregdrv() - unregister driver from LL
2431  */
2432 void gigaset_isdn_unregdrv(void)
2433 {
2434         unregister_capi_driver(&capi_driver_gigaset);
2435 }