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