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