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