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