ISDN, Gigaset: Fix memory leak in do_disconnect_req()
[linux-2.6.git] / 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 }