Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ev-layer.c
Go to the documentation of this file.
1 /*
2  * Stuff used by all variants of the driver
3  *
4  * Copyright (c) 2001 by Stefan Eilers,
5  * Hansjoerg Lipp <[email protected]>,
6  * Tilman Schmidt <[email protected]>.
7  *
8  * =====================================================================
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License as
11  * published by the Free Software Foundation; either version 2 of
12  * the License, or (at your option) any later version.
13  * =====================================================================
14  */
15 
16 #include <linux/export.h>
17 #include "gigaset.h"
18 
19 /* ========================================================== */
20 /* bit masks for pending commands */
21 #define PC_DIAL 0x001
22 #define PC_HUP 0x002
23 #define PC_INIT 0x004
24 #define PC_DLE0 0x008
25 #define PC_DLE1 0x010
26 #define PC_SHUTDOWN 0x020
27 #define PC_ACCEPT 0x040
28 #define PC_CID 0x080
29 #define PC_NOCID 0x100
30 #define PC_CIDMODE 0x200
31 #define PC_UMMODE 0x400
32 
33 /* types of modem responses */
34 #define RT_NOTHING 0
35 #define RT_ZSAU 1
36 #define RT_RING 2
37 #define RT_NUMBER 3
38 #define RT_STRING 4
39 #define RT_ZCAU 6
40 
41 /* Possible ASCII responses */
42 #define RSP_OK 0
43 #define RSP_ERROR 1
44 #define RSP_ZGCI 3
45 #define RSP_RING 4
46 #define RSP_ZVLS 5
47 #define RSP_ZCAU 6
48 
49 /* responses with values to store in at_state */
50 /* - numeric */
51 #define RSP_VAR 100
52 #define RSP_ZSAU (RSP_VAR + VAR_ZSAU)
53 #define RSP_ZDLE (RSP_VAR + VAR_ZDLE)
54 #define RSP_ZCTP (RSP_VAR + VAR_ZCTP)
55 /* - string */
56 #define RSP_STR (RSP_VAR + VAR_NUM)
57 #define RSP_NMBR (RSP_STR + STR_NMBR)
58 #define RSP_ZCPN (RSP_STR + STR_ZCPN)
59 #define RSP_ZCON (RSP_STR + STR_ZCON)
60 #define RSP_ZBC (RSP_STR + STR_ZBC)
61 #define RSP_ZHLC (RSP_STR + STR_ZHLC)
62 
63 #define RSP_WRONG_CID -2 /* unknown cid in cmd */
64 #define RSP_INVAL -6 /* invalid response */
65 #define RSP_NODEV -9 /* device not connected */
66 
67 #define RSP_NONE -19
68 #define RSP_STRING -20
69 #define RSP_NULL -21
70 #define RSP_INIT -27
71 #define RSP_ANY -26
72 #define RSP_LAST -28
73 
74 /* actions for process_response */
75 #define ACT_NOTHING 0
76 #define ACT_SETDLE1 1
77 #define ACT_SETDLE0 2
78 #define ACT_FAILINIT 3
79 #define ACT_HUPMODEM 4
80 #define ACT_CONFIGMODE 5
81 #define ACT_INIT 6
82 #define ACT_DLE0 7
83 #define ACT_DLE1 8
84 #define ACT_FAILDLE0 9
85 #define ACT_FAILDLE1 10
86 #define ACT_RING 11
87 #define ACT_CID 12
88 #define ACT_FAILCID 13
89 #define ACT_SDOWN 14
90 #define ACT_FAILSDOWN 15
91 #define ACT_DEBUG 16
92 #define ACT_WARN 17
93 #define ACT_DIALING 18
94 #define ACT_ABORTDIAL 19
95 #define ACT_DISCONNECT 20
96 #define ACT_CONNECT 21
97 #define ACT_REMOTEREJECT 22
98 #define ACT_CONNTIMEOUT 23
99 #define ACT_REMOTEHUP 24
100 #define ACT_ABORTHUP 25
101 #define ACT_ICALL 26
102 #define ACT_ACCEPTED 27
103 #define ACT_ABORTACCEPT 28
104 #define ACT_TIMEOUT 29
105 #define ACT_GETSTRING 30
106 #define ACT_SETVER 31
107 #define ACT_FAILVER 32
108 #define ACT_GOTVER 33
109 #define ACT_TEST 34
110 #define ACT_ERROR 35
111 #define ACT_ABORTCID 36
112 #define ACT_ZCAU 37
113 #define ACT_NOTIFY_BC_DOWN 38
114 #define ACT_NOTIFY_BC_UP 39
115 #define ACT_DIAL 40
116 #define ACT_ACCEPT 41
117 #define ACT_HUP 43
118 #define ACT_IF_LOCK 44
119 #define ACT_START 45
120 #define ACT_STOP 46
121 #define ACT_FAKEDLE0 47
122 #define ACT_FAKEHUP 48
123 #define ACT_FAKESDOWN 49
124 #define ACT_SHUTDOWN 50
125 #define ACT_PROC_CIDMODE 51
126 #define ACT_UMODESET 52
127 #define ACT_FAILUMODE 53
128 #define ACT_CMODESET 54
129 #define ACT_FAILCMODE 55
130 #define ACT_IF_VER 56
131 #define ACT_CMD 100
132 
133 /* at command sequences */
134 #define SEQ_NONE 0
135 #define SEQ_INIT 100
136 #define SEQ_DLE0 200
137 #define SEQ_DLE1 250
138 #define SEQ_CID 300
139 #define SEQ_NOCID 350
140 #define SEQ_HUP 400
141 #define SEQ_DIAL 600
142 #define SEQ_ACCEPT 720
143 #define SEQ_SHUTDOWN 500
144 #define SEQ_CIDMODE 10
145 #define SEQ_UMMODE 11
146 
147 
148 /* 100: init, 200: dle0, 250:dle1, 300: get cid (dial), 350: "hup" (no cid),
149  * 400: hup, 500: reset, 600: dial, 700: ring */
150 struct reply_t gigaset_tab_nocid[] =
151 {
152 /* resp_code, min_ConState, max_ConState, parameter, new_ConState, timeout,
153  * action, command */
154 
155 /* initialize device, set cid mode if possible */
156  {RSP_INIT, -1, -1, SEQ_INIT, 100, 1, {ACT_TIMEOUT} },
157 
158  {EV_TIMEOUT, 100, 100, -1, 101, 3, {0}, "Z\r"},
159  {RSP_OK, 101, 103, -1, 120, 5, {ACT_GETSTRING},
160  "+GMR\r"},
161 
162  {EV_TIMEOUT, 101, 101, -1, 102, 5, {0}, "Z\r"},
163  {RSP_ERROR, 101, 101, -1, 102, 5, {0}, "Z\r"},
164 
165  {EV_TIMEOUT, 102, 102, -1, 108, 5, {ACT_SETDLE1},
166  "^SDLE=0\r"},
167  {RSP_OK, 108, 108, -1, 104, -1},
168  {RSP_ZDLE, 104, 104, 0, 103, 5, {0}, "Z\r"},
169  {EV_TIMEOUT, 104, 104, -1, 0, 0, {ACT_FAILINIT} },
170  {RSP_ERROR, 108, 108, -1, 0, 0, {ACT_FAILINIT} },
171 
172  {EV_TIMEOUT, 108, 108, -1, 105, 2, {ACT_SETDLE0,
173  ACT_HUPMODEM,
174  ACT_TIMEOUT} },
175  {EV_TIMEOUT, 105, 105, -1, 103, 5, {0}, "Z\r"},
176 
177  {RSP_ERROR, 102, 102, -1, 107, 5, {0}, "^GETPRE\r"},
178  {RSP_OK, 107, 107, -1, 0, 0, {ACT_CONFIGMODE} },
179  {RSP_ERROR, 107, 107, -1, 0, 0, {ACT_FAILINIT} },
180  {EV_TIMEOUT, 107, 107, -1, 0, 0, {ACT_FAILINIT} },
181 
182  {RSP_ERROR, 103, 103, -1, 0, 0, {ACT_FAILINIT} },
183  {EV_TIMEOUT, 103, 103, -1, 0, 0, {ACT_FAILINIT} },
184 
185  {RSP_STRING, 120, 120, -1, 121, -1, {ACT_SETVER} },
186 
187  {EV_TIMEOUT, 120, 121, -1, 0, 0, {ACT_FAILVER,
188  ACT_INIT} },
189  {RSP_ERROR, 120, 121, -1, 0, 0, {ACT_FAILVER,
190  ACT_INIT} },
191  {RSP_OK, 121, 121, -1, 0, 0, {ACT_GOTVER,
192  ACT_INIT} },
193  {RSP_NONE, 121, 121, -1, 120, 0, {ACT_GETSTRING} },
194 
195 /* leave dle mode */
196  {RSP_INIT, 0, 0, SEQ_DLE0, 201, 5, {0}, "^SDLE=0\r"},
197  {RSP_OK, 201, 201, -1, 202, -1},
198  {RSP_ZDLE, 202, 202, 0, 0, 0, {ACT_DLE0} },
199  {RSP_NODEV, 200, 249, -1, 0, 0, {ACT_FAKEDLE0} },
200  {RSP_ERROR, 200, 249, -1, 0, 0, {ACT_FAILDLE0} },
201  {EV_TIMEOUT, 200, 249, -1, 0, 0, {ACT_FAILDLE0} },
202 
203 /* enter dle mode */
204  {RSP_INIT, 0, 0, SEQ_DLE1, 251, 5, {0}, "^SDLE=1\r"},
205  {RSP_OK, 251, 251, -1, 252, -1},
206  {RSP_ZDLE, 252, 252, 1, 0, 0, {ACT_DLE1} },
207  {RSP_ERROR, 250, 299, -1, 0, 0, {ACT_FAILDLE1} },
208  {EV_TIMEOUT, 250, 299, -1, 0, 0, {ACT_FAILDLE1} },
209 
210 /* incoming call */
211  {RSP_RING, -1, -1, -1, -1, -1, {ACT_RING} },
212 
213 /* get cid */
214  {RSP_INIT, 0, 0, SEQ_CID, 301, 5, {0}, "^SGCI?\r"},
215  {RSP_OK, 301, 301, -1, 302, -1},
216  {RSP_ZGCI, 302, 302, -1, 0, 0, {ACT_CID} },
217  {RSP_ERROR, 301, 349, -1, 0, 0, {ACT_FAILCID} },
218  {EV_TIMEOUT, 301, 349, -1, 0, 0, {ACT_FAILCID} },
219 
220 /* enter cid mode */
221  {RSP_INIT, 0, 0, SEQ_CIDMODE, 150, 5, {0}, "^SGCI=1\r"},
222  {RSP_OK, 150, 150, -1, 0, 0, {ACT_CMODESET} },
223  {RSP_ERROR, 150, 150, -1, 0, 0, {ACT_FAILCMODE} },
224  {EV_TIMEOUT, 150, 150, -1, 0, 0, {ACT_FAILCMODE} },
225 
226 /* leave cid mode */
227  {RSP_INIT, 0, 0, SEQ_UMMODE, 160, 5, {0}, "Z\r"},
228  {RSP_OK, 160, 160, -1, 0, 0, {ACT_UMODESET} },
229  {RSP_ERROR, 160, 160, -1, 0, 0, {ACT_FAILUMODE} },
230  {EV_TIMEOUT, 160, 160, -1, 0, 0, {ACT_FAILUMODE} },
231 
232 /* abort getting cid */
233  {RSP_INIT, 0, 0, SEQ_NOCID, 0, 0, {ACT_ABORTCID} },
234 
235 /* reset */
236  {RSP_INIT, 0, 0, SEQ_SHUTDOWN, 504, 5, {0}, "Z\r"},
237  {RSP_OK, 504, 504, -1, 0, 0, {ACT_SDOWN} },
238  {RSP_ERROR, 501, 599, -1, 0, 0, {ACT_FAILSDOWN} },
239  {EV_TIMEOUT, 501, 599, -1, 0, 0, {ACT_FAILSDOWN} },
240  {RSP_NODEV, 501, 599, -1, 0, 0, {ACT_FAKESDOWN} },
241 
242  {EV_PROC_CIDMODE, -1, -1, -1, -1, -1, {ACT_PROC_CIDMODE} },
243  {EV_IF_LOCK, -1, -1, -1, -1, -1, {ACT_IF_LOCK} },
244  {EV_IF_VER, -1, -1, -1, -1, -1, {ACT_IF_VER} },
245  {EV_START, -1, -1, -1, -1, -1, {ACT_START} },
246  {EV_STOP, -1, -1, -1, -1, -1, {ACT_STOP} },
247  {EV_SHUTDOWN, -1, -1, -1, -1, -1, {ACT_SHUTDOWN} },
248 
249 /* misc. */
250  {RSP_ERROR, -1, -1, -1, -1, -1, {ACT_ERROR} },
251  {RSP_ZCAU, -1, -1, -1, -1, -1, {ACT_ZCAU} },
252  {RSP_NONE, -1, -1, -1, -1, -1, {ACT_DEBUG} },
253  {RSP_ANY, -1, -1, -1, -1, -1, {ACT_WARN} },
254  {RSP_LAST}
255 };
256 
257 /* 600: start dialing, 650: dial in progress, 800: connection is up, 700: ring,
258  * 400: hup, 750: accepted icall */
259 struct reply_t gigaset_tab_cid[] =
260 {
261 /* resp_code, min_ConState, max_ConState, parameter, new_ConState, timeout,
262  * action, command */
263 
264 /* dial */
265  {EV_DIAL, -1, -1, -1, -1, -1, {ACT_DIAL} },
266  {RSP_INIT, 0, 0, SEQ_DIAL, 601, 5, {ACT_CMD + AT_BC} },
267  {RSP_OK, 601, 601, -1, 603, 5, {ACT_CMD + AT_PROTO} },
268  {RSP_OK, 603, 603, -1, 604, 5, {ACT_CMD + AT_TYPE} },
269  {RSP_OK, 604, 604, -1, 605, 5, {ACT_CMD + AT_MSN} },
270  {RSP_NULL, 605, 605, -1, 606, 5, {ACT_CMD + AT_CLIP} },
271  {RSP_OK, 605, 605, -1, 606, 5, {ACT_CMD + AT_CLIP} },
272  {RSP_NULL, 606, 606, -1, 607, 5, {ACT_CMD + AT_ISO} },
273  {RSP_OK, 606, 606, -1, 607, 5, {ACT_CMD + AT_ISO} },
274  {RSP_OK, 607, 607, -1, 608, 5, {0}, "+VLS=17\r"},
275  {RSP_OK, 608, 608, -1, 609, -1},
276  {RSP_ZSAU, 609, 609, ZSAU_PROCEEDING, 610, 5, {ACT_CMD + AT_DIAL} },
277  {RSP_OK, 610, 610, -1, 650, 0, {ACT_DIALING} },
278 
279  {RSP_ERROR, 601, 610, -1, 0, 0, {ACT_ABORTDIAL} },
280  {EV_TIMEOUT, 601, 610, -1, 0, 0, {ACT_ABORTDIAL} },
281 
282 /* optional dialing responses */
283  {EV_BC_OPEN, 650, 650, -1, 651, -1},
284  {RSP_ZVLS, 609, 651, 17, -1, -1, {ACT_DEBUG} },
285  {RSP_ZCTP, 610, 651, -1, -1, -1, {ACT_DEBUG} },
286  {RSP_ZCPN, 610, 651, -1, -1, -1, {ACT_DEBUG} },
287  {RSP_ZSAU, 650, 651, ZSAU_CALL_DELIVERED, -1, -1, {ACT_DEBUG} },
288 
289 /* connect */
290  {RSP_ZSAU, 650, 650, ZSAU_ACTIVE, 800, -1, {ACT_CONNECT} },
291  {RSP_ZSAU, 651, 651, ZSAU_ACTIVE, 800, -1, {ACT_CONNECT,
292  ACT_NOTIFY_BC_UP} },
293  {RSP_ZSAU, 750, 750, ZSAU_ACTIVE, 800, -1, {ACT_CONNECT} },
294  {RSP_ZSAU, 751, 751, ZSAU_ACTIVE, 800, -1, {ACT_CONNECT,
295  ACT_NOTIFY_BC_UP} },
296  {EV_BC_OPEN, 800, 800, -1, 800, -1, {ACT_NOTIFY_BC_UP} },
297 
298 /* remote hangup */
299  {RSP_ZSAU, 650, 651, ZSAU_DISCONNECT_IND, 0, 0, {ACT_REMOTEREJECT} },
300  {RSP_ZSAU, 750, 751, ZSAU_DISCONNECT_IND, 0, 0, {ACT_REMOTEHUP} },
301  {RSP_ZSAU, 800, 800, ZSAU_DISCONNECT_IND, 0, 0, {ACT_REMOTEHUP} },
302 
303 /* hangup */
304  {EV_HUP, -1, -1, -1, -1, -1, {ACT_HUP} },
305  {RSP_INIT, -1, -1, SEQ_HUP, 401, 5, {0}, "+VLS=0\r"},
306  {RSP_OK, 401, 401, -1, 402, 5},
307  {RSP_ZVLS, 402, 402, 0, 403, 5},
308  {RSP_ZSAU, 403, 403, ZSAU_DISCONNECT_REQ, -1, -1, {ACT_DEBUG} },
309  {RSP_ZSAU, 403, 403, ZSAU_NULL, 0, 0, {ACT_DISCONNECT} },
310  {RSP_NODEV, 401, 403, -1, 0, 0, {ACT_FAKEHUP} },
311  {RSP_ERROR, 401, 401, -1, 0, 0, {ACT_ABORTHUP} },
312  {EV_TIMEOUT, 401, 403, -1, 0, 0, {ACT_ABORTHUP} },
313 
314  {EV_BC_CLOSED, 0, 0, -1, 0, -1, {ACT_NOTIFY_BC_DOWN} },
315 
316 /* ring */
317  {RSP_ZBC, 700, 700, -1, -1, -1, {0} },
318  {RSP_ZHLC, 700, 700, -1, -1, -1, {0} },
319  {RSP_NMBR, 700, 700, -1, -1, -1, {0} },
320  {RSP_ZCPN, 700, 700, -1, -1, -1, {0} },
321  {RSP_ZCTP, 700, 700, -1, -1, -1, {0} },
322  {EV_TIMEOUT, 700, 700, -1, 720, 720, {ACT_ICALL} },
323  {EV_BC_CLOSED, 720, 720, -1, 0, -1, {ACT_NOTIFY_BC_DOWN} },
324 
325 /*accept icall*/
326  {EV_ACCEPT, -1, -1, -1, -1, -1, {ACT_ACCEPT} },
327  {RSP_INIT, 720, 720, SEQ_ACCEPT, 721, 5, {ACT_CMD + AT_PROTO} },
328  {RSP_OK, 721, 721, -1, 722, 5, {ACT_CMD + AT_ISO} },
329  {RSP_OK, 722, 722, -1, 723, 5, {0}, "+VLS=17\r"},
330  {RSP_OK, 723, 723, -1, 724, 5, {0} },
331  {RSP_ZVLS, 724, 724, 17, 750, 50, {ACT_ACCEPTED} },
332  {RSP_ERROR, 721, 729, -1, 0, 0, {ACT_ABORTACCEPT} },
333  {EV_TIMEOUT, 721, 729, -1, 0, 0, {ACT_ABORTACCEPT} },
334  {RSP_ZSAU, 700, 729, ZSAU_NULL, 0, 0, {ACT_ABORTACCEPT} },
335  {RSP_ZSAU, 700, 729, ZSAU_ACTIVE, 0, 0, {ACT_ABORTACCEPT} },
336  {RSP_ZSAU, 700, 729, ZSAU_DISCONNECT_IND, 0, 0, {ACT_ABORTACCEPT} },
337 
338  {EV_BC_OPEN, 750, 750, -1, 751, -1},
339  {EV_TIMEOUT, 750, 751, -1, 0, 0, {ACT_CONNTIMEOUT} },
340 
341 /* B channel closed (general case) */
342  {EV_BC_CLOSED, -1, -1, -1, -1, -1, {ACT_NOTIFY_BC_DOWN} },
343 
344 /* misc. */
345  {RSP_ZCON, -1, -1, -1, -1, -1, {ACT_DEBUG} },
346  {RSP_ZCAU, -1, -1, -1, -1, -1, {ACT_ZCAU} },
347  {RSP_NONE, -1, -1, -1, -1, -1, {ACT_DEBUG} },
348  {RSP_ANY, -1, -1, -1, -1, -1, {ACT_WARN} },
349  {RSP_LAST}
350 };
351 
352 
353 static const struct resp_type_t {
354  unsigned char *response;
355  int resp_code;
356  int type;
357 } resp_type[] =
358 {
359  {"OK", RSP_OK, RT_NOTHING},
360  {"ERROR", RSP_ERROR, RT_NOTHING},
361  {"ZSAU", RSP_ZSAU, RT_ZSAU},
362  {"ZCAU", RSP_ZCAU, RT_ZCAU},
363  {"RING", RSP_RING, RT_RING},
364  {"ZGCI", RSP_ZGCI, RT_NUMBER},
365  {"ZVLS", RSP_ZVLS, RT_NUMBER},
366  {"ZCTP", RSP_ZCTP, RT_NUMBER},
367  {"ZDLE", RSP_ZDLE, RT_NUMBER},
368  {"ZHLC", RSP_ZHLC, RT_STRING},
369  {"ZBC", RSP_ZBC, RT_STRING},
370  {"NMBR", RSP_NMBR, RT_STRING},
371  {"ZCPN", RSP_ZCPN, RT_STRING},
372  {"ZCON", RSP_ZCON, RT_STRING},
373  {NULL, 0, 0}
374 };
375 
376 static const struct zsau_resp_t {
377  unsigned char *str;
378  int code;
379 } zsau_resp[] =
380 {
381  {"OUTGOING_CALL_PROCEEDING", ZSAU_OUTGOING_CALL_PROCEEDING},
382  {"CALL_DELIVERED", ZSAU_CALL_DELIVERED},
383  {"ACTIVE", ZSAU_ACTIVE},
384  {"DISCONNECT_IND", ZSAU_DISCONNECT_IND},
385  {"NULL", ZSAU_NULL},
386  {"DISCONNECT_REQ", ZSAU_DISCONNECT_REQ},
387  {NULL, ZSAU_UNKNOWN}
388 };
389 
390 /* retrieve CID from parsed response
391  * returns 0 if no CID, -1 if invalid CID, or CID value 1..65535
392  */
393 static int cid_of_response(char *s)
394 {
395  int cid;
396  int rc;
397 
398  if (s[-1] != ';')
399  return 0; /* no CID separator */
400  rc = kstrtoint(s, 10, &cid);
401  if (rc)
402  return 0; /* CID not numeric */
403  if (cid < 1 || cid > 65535)
404  return -1; /* CID out of range */
405  return cid;
406 }
407 
416 void gigaset_handle_modem_response(struct cardstate *cs)
417 {
418  unsigned char *argv[MAX_REC_PARAMS + 1];
419  int params;
420  int i, j;
421  const struct resp_type_t *rt;
422  const struct zsau_resp_t *zr;
423  int curarg;
424  unsigned long flags;
425  unsigned next, tail, head;
426  struct event_t *event;
427  int resp_code;
428  int param_type;
429  int abort;
430  size_t len;
431  int cid;
432  int rawstring;
433 
434  len = cs->cbytes;
435  if (!len) {
436  /* ignore additional LFs/CRs (M10x config mode or cx100) */
437  gig_dbg(DEBUG_MCMD, "skipped EOL [%02X]", cs->respdata[len]);
438  return;
439  }
440  cs->respdata[len] = 0;
441  argv[0] = cs->respdata;
442  params = 1;
443  if (cs->at_state.getstring) {
444  /* getstring only allowed without cid at the moment */
445  cs->at_state.getstring = 0;
446  rawstring = 1;
447  cid = 0;
448  } else {
449  /* parse line */
450  for (i = 0; i < len; i++)
451  switch (cs->respdata[i]) {
452  case ';':
453  case ',':
454  case '=':
455  if (params > MAX_REC_PARAMS) {
456  dev_warn(cs->dev,
457  "too many parameters in response\n");
458  /* need last parameter (might be CID) */
459  params--;
460  }
461  argv[params++] = cs->respdata + i + 1;
462  }
463 
464  rawstring = 0;
465  cid = params > 1 ? cid_of_response(argv[params - 1]) : 0;
466  if (cid < 0) {
467  gigaset_add_event(cs, &cs->at_state, RSP_INVAL,
468  NULL, 0, NULL);
469  return;
470  }
471 
472  for (j = 1; j < params; ++j)
473  argv[j][-1] = 0;
474 
475  gig_dbg(DEBUG_EVENT, "CMD received: %s", argv[0]);
476  if (cid) {
477  --params;
478  gig_dbg(DEBUG_EVENT, "CID: %s", argv[params]);
479  }
480  gig_dbg(DEBUG_EVENT, "available params: %d", params - 1);
481  for (j = 1; j < params; j++)
482  gig_dbg(DEBUG_EVENT, "param %d: %s", j, argv[j]);
483  }
484 
485  spin_lock_irqsave(&cs->ev_lock, flags);
486  head = cs->ev_head;
487  tail = cs->ev_tail;
488 
489  abort = 1;
490  curarg = 0;
491  while (curarg < params) {
492  next = (tail + 1) % MAX_EVENTS;
493  if (unlikely(next == head)) {
494  dev_err(cs->dev, "event queue full\n");
495  break;
496  }
497 
498  event = cs->events + tail;
499  event->at_state = NULL;
500  event->cid = cid;
501  event->ptr = NULL;
502  event->arg = NULL;
503  tail = next;
504 
505  if (rawstring) {
506  resp_code = RSP_STRING;
507  param_type = RT_STRING;
508  } else {
509  for (rt = resp_type; rt->response; ++rt)
510  if (!strcmp(argv[curarg], rt->response))
511  break;
512 
513  if (!rt->response) {
514  event->type = RSP_NONE;
515  gig_dbg(DEBUG_EVENT,
516  "unknown modem response: '%s'\n",
517  argv[curarg]);
518  break;
519  }
520 
521  resp_code = rt->resp_code;
522  param_type = rt->type;
523  ++curarg;
524  }
525 
526  event->type = resp_code;
527 
528  switch (param_type) {
529  case RT_NOTHING:
530  break;
531  case RT_RING:
532  if (!cid) {
533  dev_err(cs->dev,
534  "received RING without CID!\n");
535  event->type = RSP_INVAL;
536  abort = 1;
537  } else {
538  event->cid = 0;
539  event->parameter = cid;
540  abort = 0;
541  }
542  break;
543  case RT_ZSAU:
544  if (curarg >= params) {
545  event->parameter = ZSAU_NONE;
546  break;
547  }
548  for (zr = zsau_resp; zr->str; ++zr)
549  if (!strcmp(argv[curarg], zr->str))
550  break;
551  event->parameter = zr->code;
552  if (!zr->str)
553  dev_warn(cs->dev,
554  "%s: unknown parameter %s after ZSAU\n",
555  __func__, argv[curarg]);
556  ++curarg;
557  break;
558  case RT_STRING:
559  if (curarg < params) {
560  event->ptr = kstrdup(argv[curarg], GFP_ATOMIC);
561  if (!event->ptr)
562  dev_err(cs->dev, "out of memory\n");
563  ++curarg;
564  }
565  gig_dbg(DEBUG_EVENT, "string==%s",
566  event->ptr ? (char *) event->ptr : "NULL");
567  break;
568  case RT_ZCAU:
569  event->parameter = -1;
570  if (curarg + 1 < params) {
571  u8 type, value;
572 
573  i = kstrtou8(argv[curarg++], 16, &type);
574  j = kstrtou8(argv[curarg++], 16, &value);
575  if (i == 0 && j == 0)
576  event->parameter = (type << 8) | value;
577  } else
578  curarg = params - 1;
579  break;
580  case RT_NUMBER:
581  if (curarg >= params ||
582  kstrtoint(argv[curarg++], 10, &event->parameter))
583  event->parameter = -1;
584  gig_dbg(DEBUG_EVENT, "parameter==%d", event->parameter);
585  break;
586  }
587 
588  if (resp_code == RSP_ZDLE)
589  cs->dle = event->parameter;
590 
591  if (abort)
592  break;
593  }
594 
595  cs->ev_tail = tail;
596  spin_unlock_irqrestore(&cs->ev_lock, flags);
597 
598  if (curarg != params)
599  gig_dbg(DEBUG_EVENT,
600  "invalid number of processed parameters: %d/%d",
601  curarg, params);
602 }
603 EXPORT_SYMBOL_GPL(gigaset_handle_modem_response);
604 
605 /* disconnect
606  * process closing of connection associated with given AT state structure
607  */
608 static void disconnect(struct at_state_t **at_state_p)
609 {
610  unsigned long flags;
611  struct bc_state *bcs = (*at_state_p)->bcs;
612  struct cardstate *cs = (*at_state_p)->cs;
613 
614  spin_lock_irqsave(&cs->lock, flags);
615  ++(*at_state_p)->seq_index;
616 
617  /* revert to selected idle mode */
618  if (!cs->cidmode) {
619  cs->at_state.pending_commands |= PC_UMMODE;
620  gig_dbg(DEBUG_EVENT, "Scheduling PC_UMMODE");
621  cs->commands_pending = 1;
622  }
623  spin_unlock_irqrestore(&cs->lock, flags);
624 
625  if (bcs) {
626  /* B channel assigned: invoke hardware specific handler */
627  cs->ops->close_bchannel(bcs);
628  /* notify LL */
629  if (bcs->chstate & (CHS_D_UP | CHS_NOTIFY_LL)) {
630  bcs->chstate &= ~(CHS_D_UP | CHS_NOTIFY_LL);
631  gigaset_isdn_hupD(bcs);
632  }
633  } else {
634  /* no B channel assigned: just deallocate */
635  spin_lock_irqsave(&cs->lock, flags);
636  list_del(&(*at_state_p)->list);
637  kfree(*at_state_p);
638  *at_state_p = NULL;
639  spin_unlock_irqrestore(&cs->lock, flags);
640  }
641 }
642 
643 /* get_free_channel
644  * get a free AT state structure: either one of those associated with the
645  * B channels of the Gigaset device, or if none of those is available,
646  * a newly allocated one with bcs=NULL
647  * The structure should be freed by calling disconnect() after use.
648  */
649 static inline struct at_state_t *get_free_channel(struct cardstate *cs,
650  int cid)
651 /* cids: >0: siemens-cid
652  * 0: without cid
653  * -1: no cid assigned yet
654  */
655 {
656  unsigned long flags;
657  int i;
658  struct at_state_t *ret;
659 
660  for (i = 0; i < cs->channels; ++i)
661  if (gigaset_get_channel(cs->bcs + i) >= 0) {
662  ret = &cs->bcs[i].at_state;
663  ret->cid = cid;
664  return ret;
665  }
666 
667  spin_lock_irqsave(&cs->lock, flags);
668  ret = kmalloc(sizeof(struct at_state_t), GFP_ATOMIC);
669  if (ret) {
670  gigaset_at_init(ret, NULL, cs, cid);
671  list_add(&ret->list, &cs->temp_at_states);
672  }
673  spin_unlock_irqrestore(&cs->lock, flags);
674  return ret;
675 }
676 
677 static void init_failed(struct cardstate *cs, int mode)
678 {
679  int i;
680  struct at_state_t *at_state;
681 
682  cs->at_state.pending_commands &= ~PC_INIT;
683  cs->mode = mode;
684  cs->mstate = MS_UNINITIALIZED;
685  gigaset_free_channels(cs);
686  for (i = 0; i < cs->channels; ++i) {
687  at_state = &cs->bcs[i].at_state;
688  if (at_state->pending_commands & PC_CID) {
689  at_state->pending_commands &= ~PC_CID;
690  at_state->pending_commands |= PC_NOCID;
691  cs->commands_pending = 1;
692  }
693  }
694 }
695 
696 static void schedule_init(struct cardstate *cs, int state)
697 {
698  if (cs->at_state.pending_commands & PC_INIT) {
699  gig_dbg(DEBUG_EVENT, "not scheduling PC_INIT again");
700  return;
701  }
702  cs->mstate = state;
703  cs->mode = M_UNKNOWN;
704  gigaset_block_channels(cs);
705  cs->at_state.pending_commands |= PC_INIT;
706  gig_dbg(DEBUG_EVENT, "Scheduling PC_INIT");
707  cs->commands_pending = 1;
708 }
709 
710 /* Add "AT" to a command, add the cid, dle encode it, send the result to the
711  hardware. */
712 static void send_command(struct cardstate *cs, const char *cmd, int cid,
713  int dle, gfp_t kmallocflags)
714 {
715  struct cmdbuf_t *cb;
716  size_t buflen;
717 
718  buflen = strlen(cmd) + 12; /* DLE ( A T 1 2 3 4 5 <cmd> DLE ) \0 */
719  cb = kmalloc(sizeof(struct cmdbuf_t) + buflen, kmallocflags);
720  if (!cb) {
721  dev_err(cs->dev, "%s: out of memory\n", __func__);
722  return;
723  }
724  if (cid > 0 && cid <= 65535)
725  cb->len = snprintf(cb->buf, buflen,
726  dle ? "\020(AT%d%s\020)" : "AT%d%s",
727  cid, cmd);
728  else
729  cb->len = snprintf(cb->buf, buflen,
730  dle ? "\020(AT%s\020)" : "AT%s",
731  cmd);
732  cb->offset = 0;
733  cb->next = NULL;
734  cb->wake_tasklet = NULL;
735  cs->ops->write_cmd(cs, cb);
736 }
737 
738 static struct at_state_t *at_state_from_cid(struct cardstate *cs, int cid)
739 {
740  struct at_state_t *at_state;
741  int i;
742  unsigned long flags;
743 
744  if (cid == 0)
745  return &cs->at_state;
746 
747  for (i = 0; i < cs->channels; ++i)
748  if (cid == cs->bcs[i].at_state.cid)
749  return &cs->bcs[i].at_state;
750 
751  spin_lock_irqsave(&cs->lock, flags);
752 
753  list_for_each_entry(at_state, &cs->temp_at_states, list)
754  if (cid == at_state->cid) {
755  spin_unlock_irqrestore(&cs->lock, flags);
756  return at_state;
757  }
758 
759  spin_unlock_irqrestore(&cs->lock, flags);
760 
761  return NULL;
762 }
763 
764 static void bchannel_down(struct bc_state *bcs)
765 {
766  if (bcs->chstate & CHS_B_UP) {
767  bcs->chstate &= ~CHS_B_UP;
768  gigaset_isdn_hupB(bcs);
769  }
770 
771  if (bcs->chstate & (CHS_D_UP | CHS_NOTIFY_LL)) {
772  bcs->chstate &= ~(CHS_D_UP | CHS_NOTIFY_LL);
773  gigaset_isdn_hupD(bcs);
774  }
775 
776  gigaset_free_channel(bcs);
777 
778  gigaset_bcs_reinit(bcs);
779 }
780 
781 static void bchannel_up(struct bc_state *bcs)
782 {
783  if (bcs->chstate & CHS_B_UP) {
784  dev_notice(bcs->cs->dev, "%s: B channel already up\n",
785  __func__);
786  return;
787  }
788 
789  bcs->chstate |= CHS_B_UP;
790  gigaset_isdn_connB(bcs);
791 }
792 
793 static void start_dial(struct at_state_t *at_state, void *data,
794  unsigned seq_index)
795 {
796  struct bc_state *bcs = at_state->bcs;
797  struct cardstate *cs = at_state->cs;
798  char **commands = data;
799  unsigned long flags;
800  int i;
801 
802  bcs->chstate |= CHS_NOTIFY_LL;
803 
804  spin_lock_irqsave(&cs->lock, flags);
805  if (at_state->seq_index != seq_index) {
806  spin_unlock_irqrestore(&cs->lock, flags);
807  goto error;
808  }
809  spin_unlock_irqrestore(&cs->lock, flags);
810 
811  for (i = 0; i < AT_NUM; ++i) {
812  kfree(bcs->commands[i]);
813  bcs->commands[i] = commands[i];
814  }
815 
816  at_state->pending_commands |= PC_CID;
817  gig_dbg(DEBUG_EVENT, "Scheduling PC_CID");
818  cs->commands_pending = 1;
819  return;
820 
821 error:
822  for (i = 0; i < AT_NUM; ++i) {
823  kfree(commands[i]);
824  commands[i] = NULL;
825  }
826  at_state->pending_commands |= PC_NOCID;
827  gig_dbg(DEBUG_EVENT, "Scheduling PC_NOCID");
828  cs->commands_pending = 1;
829  return;
830 }
831 
832 static void start_accept(struct at_state_t *at_state)
833 {
834  struct cardstate *cs = at_state->cs;
835  struct bc_state *bcs = at_state->bcs;
836  int i;
837 
838  for (i = 0; i < AT_NUM; ++i) {
839  kfree(bcs->commands[i]);
840  bcs->commands[i] = NULL;
841  }
842 
843  bcs->commands[AT_PROTO] = kmalloc(9, GFP_ATOMIC);
844  bcs->commands[AT_ISO] = kmalloc(9, GFP_ATOMIC);
845  if (!bcs->commands[AT_PROTO] || !bcs->commands[AT_ISO]) {
846  dev_err(at_state->cs->dev, "out of memory\n");
847  /* error reset */
848  at_state->pending_commands |= PC_HUP;
849  gig_dbg(DEBUG_EVENT, "Scheduling PC_HUP");
850  cs->commands_pending = 1;
851  return;
852  }
853 
854  snprintf(bcs->commands[AT_PROTO], 9, "^SBPR=%u\r", bcs->proto2);
855  snprintf(bcs->commands[AT_ISO], 9, "^SISO=%u\r", bcs->channel + 1);
856 
857  at_state->pending_commands |= PC_ACCEPT;
858  gig_dbg(DEBUG_EVENT, "Scheduling PC_ACCEPT");
859  cs->commands_pending = 1;
860 }
861 
862 static void do_start(struct cardstate *cs)
863 {
864  gigaset_free_channels(cs);
865 
866  if (cs->mstate != MS_LOCKED)
867  schedule_init(cs, MS_INIT);
868 
869  cs->isdn_up = 1;
870  gigaset_isdn_start(cs);
871 
872  cs->waiting = 0;
873  wake_up(&cs->waitqueue);
874 }
875 
876 static void finish_shutdown(struct cardstate *cs)
877 {
878  if (cs->mstate != MS_LOCKED) {
879  cs->mstate = MS_UNINITIALIZED;
880  cs->mode = M_UNKNOWN;
881  }
882 
883  /* Tell the LL that the device is not available .. */
884  if (cs->isdn_up) {
885  cs->isdn_up = 0;
886  gigaset_isdn_stop(cs);
887  }
888 
889  /* The rest is done by cleanup_cs () in user mode. */
890 
891  cs->cmd_result = -ENODEV;
892  cs->waiting = 0;
893  wake_up(&cs->waitqueue);
894 }
895 
896 static void do_shutdown(struct cardstate *cs)
897 {
898  gigaset_block_channels(cs);
899 
900  if (cs->mstate == MS_READY) {
901  cs->mstate = MS_SHUTDOWN;
902  cs->at_state.pending_commands |= PC_SHUTDOWN;
903  gig_dbg(DEBUG_EVENT, "Scheduling PC_SHUTDOWN");
904  cs->commands_pending = 1;
905  } else
906  finish_shutdown(cs);
907 }
908 
909 static void do_stop(struct cardstate *cs)
910 {
911  unsigned long flags;
912 
913  spin_lock_irqsave(&cs->lock, flags);
914  cs->connected = 0;
915  spin_unlock_irqrestore(&cs->lock, flags);
916 
917  do_shutdown(cs);
918 }
919 
920 /* Entering cid mode or getting a cid failed:
921  * try to initialize the device and try again.
922  *
923  * channel >= 0: getting cid for the channel failed
924  * channel < 0: entering cid mode failed
925  *
926  * returns 0 on success, <0 on failure
927  */
928 static int reinit_and_retry(struct cardstate *cs, int channel)
929 {
930  int i;
931 
932  if (--cs->retry_count <= 0)
933  return -EFAULT;
934 
935  for (i = 0; i < cs->channels; ++i)
936  if (cs->bcs[i].at_state.cid > 0)
937  return -EBUSY;
938 
939  if (channel < 0)
940  dev_warn(cs->dev,
941  "Could not enter cid mode. Reinit device and try again.\n");
942  else {
943  dev_warn(cs->dev,
944  "Could not get a call id. Reinit device and try again.\n");
945  cs->bcs[channel].at_state.pending_commands |= PC_CID;
946  }
947  schedule_init(cs, MS_INIT);
948  return 0;
949 }
950 
951 static int at_state_invalid(struct cardstate *cs,
952  struct at_state_t *test_ptr)
953 {
954  unsigned long flags;
955  unsigned channel;
956  struct at_state_t *at_state;
957  int retval = 0;
958 
959  spin_lock_irqsave(&cs->lock, flags);
960 
961  if (test_ptr == &cs->at_state)
962  goto exit;
963 
964  list_for_each_entry(at_state, &cs->temp_at_states, list)
965  if (at_state == test_ptr)
966  goto exit;
967 
968  for (channel = 0; channel < cs->channels; ++channel)
969  if (&cs->bcs[channel].at_state == test_ptr)
970  goto exit;
971 
972  retval = 1;
973 exit:
974  spin_unlock_irqrestore(&cs->lock, flags);
975  return retval;
976 }
977 
978 static void handle_icall(struct cardstate *cs, struct bc_state *bcs,
979  struct at_state_t **p_at_state)
980 {
981  int retval;
982  struct at_state_t *at_state = *p_at_state;
983 
984  retval = gigaset_isdn_icall(at_state);
985  switch (retval) {
986  case ICALL_ACCEPT:
987  break;
988  default:
989  dev_err(cs->dev, "internal error: disposition=%d\n", retval);
990  /* --v-- fall through --v-- */
991  case ICALL_IGNORE:
992  case ICALL_REJECT:
993  /* hang up actively
994  * Device doc says that would reject the call.
995  * In fact it doesn't.
996  */
997  at_state->pending_commands |= PC_HUP;
998  cs->commands_pending = 1;
999  break;
1000  }
1001 }
1002 
1003 static int do_lock(struct cardstate *cs)
1004 {
1005  int mode;
1006  int i;
1007 
1008  switch (cs->mstate) {
1009  case MS_UNINITIALIZED:
1010  case MS_READY:
1011  if (cs->cur_at_seq || !list_empty(&cs->temp_at_states) ||
1012  cs->at_state.pending_commands)
1013  return -EBUSY;
1014 
1015  for (i = 0; i < cs->channels; ++i)
1016  if (cs->bcs[i].at_state.pending_commands)
1017  return -EBUSY;
1018 
1019  if (gigaset_get_channels(cs) < 0)
1020  return -EBUSY;
1021 
1022  break;
1023  case MS_LOCKED:
1024  break;
1025  default:
1026  return -EBUSY;
1027  }
1028 
1029  mode = cs->mode;
1030  cs->mstate = MS_LOCKED;
1031  cs->mode = M_UNKNOWN;
1032 
1033  return mode;
1034 }
1035 
1036 static int do_unlock(struct cardstate *cs)
1037 {
1038  if (cs->mstate != MS_LOCKED)
1039  return -EINVAL;
1040 
1041  cs->mstate = MS_UNINITIALIZED;
1042  cs->mode = M_UNKNOWN;
1043  gigaset_free_channels(cs);
1044  if (cs->connected)
1045  schedule_init(cs, MS_INIT);
1046 
1047  return 0;
1048 }
1049 
1050 static void do_action(int action, struct cardstate *cs,
1051  struct bc_state *bcs,
1052  struct at_state_t **p_at_state, char **pp_command,
1053  int *p_genresp, int *p_resp_code,
1054  struct event_t *ev)
1055 {
1056  struct at_state_t *at_state = *p_at_state;
1057  struct at_state_t *at_state2;
1058  unsigned long flags;
1059 
1060  int channel;
1061 
1062  unsigned char *s, *e;
1063  int i;
1064  unsigned long val;
1065 
1066  switch (action) {
1067  case ACT_NOTHING:
1068  break;
1069  case ACT_TIMEOUT:
1070  at_state->waiting = 1;
1071  break;
1072  case ACT_INIT:
1073  cs->at_state.pending_commands &= ~PC_INIT;
1074  cs->cur_at_seq = SEQ_NONE;
1075  cs->mode = M_UNIMODEM;
1076  spin_lock_irqsave(&cs->lock, flags);
1077  if (!cs->cidmode) {
1078  spin_unlock_irqrestore(&cs->lock, flags);
1079  gigaset_free_channels(cs);
1080  cs->mstate = MS_READY;
1081  break;
1082  }
1083  spin_unlock_irqrestore(&cs->lock, flags);
1084  cs->at_state.pending_commands |= PC_CIDMODE;
1085  gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
1086  cs->commands_pending = 1;
1087  break;
1088  case ACT_FAILINIT:
1089  dev_warn(cs->dev, "Could not initialize the device.\n");
1090  cs->dle = 0;
1091  init_failed(cs, M_UNKNOWN);
1092  cs->cur_at_seq = SEQ_NONE;
1093  break;
1094  case ACT_CONFIGMODE:
1095  init_failed(cs, M_CONFIG);
1096  cs->cur_at_seq = SEQ_NONE;
1097  break;
1098  case ACT_SETDLE1:
1099  cs->dle = 1;
1100  /* cs->inbuf[0].inputstate |= INS_command | INS_DLE_command; */
1101  cs->inbuf[0].inputstate &=
1102  ~(INS_command | INS_DLE_command);
1103  break;
1104  case ACT_SETDLE0:
1105  cs->dle = 0;
1106  cs->inbuf[0].inputstate =
1107  (cs->inbuf[0].inputstate & ~INS_DLE_command)
1108  | INS_command;
1109  break;
1110  case ACT_CMODESET:
1111  if (cs->mstate == MS_INIT || cs->mstate == MS_RECOVER) {
1112  gigaset_free_channels(cs);
1113  cs->mstate = MS_READY;
1114  }
1115  cs->mode = M_CID;
1116  cs->cur_at_seq = SEQ_NONE;
1117  break;
1118  case ACT_UMODESET:
1119  cs->mode = M_UNIMODEM;
1120  cs->cur_at_seq = SEQ_NONE;
1121  break;
1122  case ACT_FAILCMODE:
1123  cs->cur_at_seq = SEQ_NONE;
1124  if (cs->mstate == MS_INIT || cs->mstate == MS_RECOVER) {
1125  init_failed(cs, M_UNKNOWN);
1126  break;
1127  }
1128  if (reinit_and_retry(cs, -1) < 0)
1129  schedule_init(cs, MS_RECOVER);
1130  break;
1131  case ACT_FAILUMODE:
1132  cs->cur_at_seq = SEQ_NONE;
1133  schedule_init(cs, MS_RECOVER);
1134  break;
1135  case ACT_HUPMODEM:
1136  /* send "+++" (hangup in unimodem mode) */
1137  if (cs->connected) {
1138  struct cmdbuf_t *cb;
1139 
1140  cb = kmalloc(sizeof(struct cmdbuf_t) + 3, GFP_ATOMIC);
1141  if (!cb) {
1142  dev_err(cs->dev, "%s: out of memory\n",
1143  __func__);
1144  return;
1145  }
1146  memcpy(cb->buf, "+++", 3);
1147  cb->len = 3;
1148  cb->offset = 0;
1149  cb->next = NULL;
1150  cb->wake_tasklet = NULL;
1151  cs->ops->write_cmd(cs, cb);
1152  }
1153  break;
1154  case ACT_RING:
1155  /* get fresh AT state structure for new CID */
1156  at_state2 = get_free_channel(cs, ev->parameter);
1157  if (!at_state2) {
1158  dev_warn(cs->dev,
1159  "RING ignored: could not allocate channel structure\n");
1160  break;
1161  }
1162 
1163  /* initialize AT state structure
1164  * note that bcs may be NULL if no B channel is free
1165  */
1166  at_state2->ConState = 700;
1167  for (i = 0; i < STR_NUM; ++i) {
1168  kfree(at_state2->str_var[i]);
1169  at_state2->str_var[i] = NULL;
1170  }
1171  at_state2->int_var[VAR_ZCTP] = -1;
1172 
1173  spin_lock_irqsave(&cs->lock, flags);
1174  at_state2->timer_expires = RING_TIMEOUT;
1175  at_state2->timer_active = 1;
1176  spin_unlock_irqrestore(&cs->lock, flags);
1177  break;
1178  case ACT_ICALL:
1179  handle_icall(cs, bcs, p_at_state);
1180  break;
1181  case ACT_FAILSDOWN:
1182  dev_warn(cs->dev, "Could not shut down the device.\n");
1183  /* fall through */
1184  case ACT_FAKESDOWN:
1185  case ACT_SDOWN:
1186  cs->cur_at_seq = SEQ_NONE;
1187  finish_shutdown(cs);
1188  break;
1189  case ACT_CONNECT:
1190  if (cs->onechannel) {
1191  at_state->pending_commands |= PC_DLE1;
1192  cs->commands_pending = 1;
1193  break;
1194  }
1195  bcs->chstate |= CHS_D_UP;
1196  gigaset_isdn_connD(bcs);
1197  cs->ops->init_bchannel(bcs);
1198  break;
1199  case ACT_DLE1:
1200  cs->cur_at_seq = SEQ_NONE;
1201  bcs = cs->bcs + cs->curchannel;
1202 
1203  bcs->chstate |= CHS_D_UP;
1204  gigaset_isdn_connD(bcs);
1205  cs->ops->init_bchannel(bcs);
1206  break;
1207  case ACT_FAKEHUP:
1208  at_state->int_var[VAR_ZSAU] = ZSAU_NULL;
1209  /* fall through */
1210  case ACT_DISCONNECT:
1211  cs->cur_at_seq = SEQ_NONE;
1212  at_state->cid = -1;
1213  if (bcs && cs->onechannel && cs->dle) {
1214  /* Check for other open channels not needed:
1215  * DLE only used for M10x with one B channel.
1216  */
1217  at_state->pending_commands |= PC_DLE0;
1218  cs->commands_pending = 1;
1219  } else
1220  disconnect(p_at_state);
1221  break;
1222  case ACT_FAKEDLE0:
1223  at_state->int_var[VAR_ZDLE] = 0;
1224  cs->dle = 0;
1225  /* fall through */
1226  case ACT_DLE0:
1227  cs->cur_at_seq = SEQ_NONE;
1228  at_state2 = &cs->bcs[cs->curchannel].at_state;
1229  disconnect(&at_state2);
1230  break;
1231  case ACT_ABORTHUP:
1232  cs->cur_at_seq = SEQ_NONE;
1233  dev_warn(cs->dev, "Could not hang up.\n");
1234  at_state->cid = -1;
1235  if (bcs && cs->onechannel)
1236  at_state->pending_commands |= PC_DLE0;
1237  else
1238  disconnect(p_at_state);
1239  schedule_init(cs, MS_RECOVER);
1240  break;
1241  case ACT_FAILDLE0:
1242  cs->cur_at_seq = SEQ_NONE;
1243  dev_warn(cs->dev, "Could not leave DLE mode.\n");
1244  at_state2 = &cs->bcs[cs->curchannel].at_state;
1245  disconnect(&at_state2);
1246  schedule_init(cs, MS_RECOVER);
1247  break;
1248  case ACT_FAILDLE1:
1249  cs->cur_at_seq = SEQ_NONE;
1250  dev_warn(cs->dev,
1251  "Could not enter DLE mode. Trying to hang up.\n");
1252  channel = cs->curchannel;
1253  cs->bcs[channel].at_state.pending_commands |= PC_HUP;
1254  cs->commands_pending = 1;
1255  break;
1256 
1257  case ACT_CID: /* got cid; start dialing */
1258  cs->cur_at_seq = SEQ_NONE;
1259  channel = cs->curchannel;
1260  if (ev->parameter > 0 && ev->parameter <= 65535) {
1261  cs->bcs[channel].at_state.cid = ev->parameter;
1262  cs->bcs[channel].at_state.pending_commands |=
1263  PC_DIAL;
1264  cs->commands_pending = 1;
1265  break;
1266  }
1267  /* fall through */
1268  case ACT_FAILCID:
1269  cs->cur_at_seq = SEQ_NONE;
1270  channel = cs->curchannel;
1271  if (reinit_and_retry(cs, channel) < 0) {
1272  dev_warn(cs->dev,
1273  "Could not get a call ID. Cannot dial.\n");
1274  at_state2 = &cs->bcs[channel].at_state;
1275  disconnect(&at_state2);
1276  }
1277  break;
1278  case ACT_ABORTCID:
1279  cs->cur_at_seq = SEQ_NONE;
1280  at_state2 = &cs->bcs[cs->curchannel].at_state;
1281  disconnect(&at_state2);
1282  break;
1283 
1284  case ACT_DIALING:
1285  case ACT_ACCEPTED:
1286  cs->cur_at_seq = SEQ_NONE;
1287  break;
1288 
1289  case ACT_ABORTACCEPT: /* hangup/error/timeout during ICALL procssng */
1290  disconnect(p_at_state);
1291  break;
1292 
1293  case ACT_ABORTDIAL: /* error/timeout during dial preparation */
1294  cs->cur_at_seq = SEQ_NONE;
1295  at_state->pending_commands |= PC_HUP;
1296  cs->commands_pending = 1;
1297  break;
1298 
1299  case ACT_REMOTEREJECT: /* DISCONNECT_IND after dialling */
1300  case ACT_CONNTIMEOUT: /* timeout waiting for ZSAU=ACTIVE */
1301  case ACT_REMOTEHUP: /* DISCONNECT_IND with established connection */
1302  at_state->pending_commands |= PC_HUP;
1303  cs->commands_pending = 1;
1304  break;
1305  case ACT_GETSTRING: /* warning: RING, ZDLE, ...
1306  are not handled properly anymore */
1307  at_state->getstring = 1;
1308  break;
1309  case ACT_SETVER:
1310  if (!ev->ptr) {
1311  *p_genresp = 1;
1312  *p_resp_code = RSP_ERROR;
1313  break;
1314  }
1315  s = ev->ptr;
1316 
1317  if (!strcmp(s, "OK")) {
1318  /* OK without version string: assume old response */
1319  *p_genresp = 1;
1320  *p_resp_code = RSP_NONE;
1321  break;
1322  }
1323 
1324  for (i = 0; i < 4; ++i) {
1325  val = simple_strtoul(s, (char **) &e, 10);
1326  if (val > INT_MAX || e == s)
1327  break;
1328  if (i == 3) {
1329  if (*e)
1330  break;
1331  } else if (*e != '.')
1332  break;
1333  else
1334  s = e + 1;
1335  cs->fwver[i] = val;
1336  }
1337  if (i != 4) {
1338  *p_genresp = 1;
1339  *p_resp_code = RSP_ERROR;
1340  break;
1341  }
1342  /*at_state->getstring = 1;*/
1343  cs->gotfwver = 0;
1344  break;
1345  case ACT_GOTVER:
1346  if (cs->gotfwver == 0) {
1347  cs->gotfwver = 1;
1348  gig_dbg(DEBUG_EVENT,
1349  "firmware version %02d.%03d.%02d.%02d",
1350  cs->fwver[0], cs->fwver[1],
1351  cs->fwver[2], cs->fwver[3]);
1352  break;
1353  }
1354  /* fall through */
1355  case ACT_FAILVER:
1356  cs->gotfwver = -1;
1357  dev_err(cs->dev, "could not read firmware version.\n");
1358  break;
1359  case ACT_ERROR:
1360  gig_dbg(DEBUG_ANY, "%s: ERROR response in ConState %d",
1361  __func__, at_state->ConState);
1362  cs->cur_at_seq = SEQ_NONE;
1363  break;
1364  case ACT_DEBUG:
1365  gig_dbg(DEBUG_ANY, "%s: resp_code %d in ConState %d",
1366  __func__, ev->type, at_state->ConState);
1367  break;
1368  case ACT_WARN:
1369  dev_warn(cs->dev, "%s: resp_code %d in ConState %d!\n",
1370  __func__, ev->type, at_state->ConState);
1371  break;
1372  case ACT_ZCAU:
1373  dev_warn(cs->dev, "cause code %04x in connection state %d.\n",
1374  ev->parameter, at_state->ConState);
1375  break;
1376 
1377  /* events from the LL */
1378 
1379  case ACT_DIAL:
1380  start_dial(at_state, ev->ptr, ev->parameter);
1381  break;
1382  case ACT_ACCEPT:
1383  start_accept(at_state);
1384  break;
1385  case ACT_HUP:
1386  at_state->pending_commands |= PC_HUP;
1387  gig_dbg(DEBUG_EVENT, "Scheduling PC_HUP");
1388  cs->commands_pending = 1;
1389  break;
1390 
1391  /* hotplug events */
1392 
1393  case ACT_STOP:
1394  do_stop(cs);
1395  break;
1396  case ACT_START:
1397  do_start(cs);
1398  break;
1399 
1400  /* events from the interface */
1401 
1402  case ACT_IF_LOCK:
1403  cs->cmd_result = ev->parameter ? do_lock(cs) : do_unlock(cs);
1404  cs->waiting = 0;
1405  wake_up(&cs->waitqueue);
1406  break;
1407  case ACT_IF_VER:
1408  if (ev->parameter != 0)
1409  cs->cmd_result = -EINVAL;
1410  else if (cs->gotfwver != 1) {
1411  cs->cmd_result = -ENOENT;
1412  } else {
1413  memcpy(ev->arg, cs->fwver, sizeof cs->fwver);
1414  cs->cmd_result = 0;
1415  }
1416  cs->waiting = 0;
1417  wake_up(&cs->waitqueue);
1418  break;
1419 
1420  /* events from the proc file system */
1421 
1422  case ACT_PROC_CIDMODE:
1423  spin_lock_irqsave(&cs->lock, flags);
1424  if (ev->parameter != cs->cidmode) {
1425  cs->cidmode = ev->parameter;
1426  if (ev->parameter) {
1427  cs->at_state.pending_commands |= PC_CIDMODE;
1428  gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
1429  } else {
1430  cs->at_state.pending_commands |= PC_UMMODE;
1431  gig_dbg(DEBUG_EVENT, "Scheduling PC_UMMODE");
1432  }
1433  cs->commands_pending = 1;
1434  }
1435  spin_unlock_irqrestore(&cs->lock, flags);
1436  cs->waiting = 0;
1437  wake_up(&cs->waitqueue);
1438  break;
1439 
1440  /* events from the hardware drivers */
1441 
1442  case ACT_NOTIFY_BC_DOWN:
1443  bchannel_down(bcs);
1444  break;
1445  case ACT_NOTIFY_BC_UP:
1446  bchannel_up(bcs);
1447  break;
1448  case ACT_SHUTDOWN:
1449  do_shutdown(cs);
1450  break;
1451 
1452 
1453  default:
1454  if (action >= ACT_CMD && action < ACT_CMD + AT_NUM) {
1455  *pp_command = at_state->bcs->commands[action - ACT_CMD];
1456  if (!*pp_command) {
1457  *p_genresp = 1;
1458  *p_resp_code = RSP_NULL;
1459  }
1460  } else
1461  dev_err(cs->dev, "%s: action==%d!\n", __func__, action);
1462  }
1463 }
1464 
1465 /* State machine to do the calling and hangup procedure */
1466 static void process_event(struct cardstate *cs, struct event_t *ev)
1467 {
1468  struct bc_state *bcs;
1469  char *p_command = NULL;
1470  struct reply_t *rep;
1471  int rcode;
1472  int genresp = 0;
1473  int resp_code = RSP_ERROR;
1474  int sendcid;
1475  struct at_state_t *at_state;
1476  int index;
1477  int curact;
1478  unsigned long flags;
1479 
1480  if (ev->cid >= 0) {
1481  at_state = at_state_from_cid(cs, ev->cid);
1482  if (!at_state) {
1483  gig_dbg(DEBUG_EVENT, "event %d for invalid cid %d",
1484  ev->type, ev->cid);
1485  gigaset_add_event(cs, &cs->at_state, RSP_WRONG_CID,
1486  NULL, 0, NULL);
1487  return;
1488  }
1489  } else {
1490  at_state = ev->at_state;
1491  if (at_state_invalid(cs, at_state)) {
1492  gig_dbg(DEBUG_EVENT, "event for invalid at_state %p",
1493  at_state);
1494  return;
1495  }
1496  }
1497 
1498  gig_dbg(DEBUG_EVENT, "connection state %d, event %d",
1499  at_state->ConState, ev->type);
1500 
1501  bcs = at_state->bcs;
1502  sendcid = at_state->cid;
1503 
1504  /* Setting the pointer to the dial array */
1505  rep = at_state->replystruct;
1506 
1507  spin_lock_irqsave(&cs->lock, flags);
1508  if (ev->type == EV_TIMEOUT) {
1509  if (ev->parameter != at_state->timer_index
1510  || !at_state->timer_active) {
1511  ev->type = RSP_NONE; /* old timeout */
1512  gig_dbg(DEBUG_EVENT, "old timeout");
1513  } else if (!at_state->waiting)
1514  gig_dbg(DEBUG_EVENT, "timeout occurred");
1515  else
1516  gig_dbg(DEBUG_EVENT, "stopped waiting");
1517  }
1518  spin_unlock_irqrestore(&cs->lock, flags);
1519 
1520  /* if the response belongs to a variable in at_state->int_var[VAR_XXXX]
1521  or at_state->str_var[STR_XXXX], set it */
1522  if (ev->type >= RSP_VAR && ev->type < RSP_VAR + VAR_NUM) {
1523  index = ev->type - RSP_VAR;
1524  at_state->int_var[index] = ev->parameter;
1525  } else if (ev->type >= RSP_STR && ev->type < RSP_STR + STR_NUM) {
1526  index = ev->type - RSP_STR;
1527  kfree(at_state->str_var[index]);
1528  at_state->str_var[index] = ev->ptr;
1529  ev->ptr = NULL; /* prevent process_events() from
1530  deallocating ptr */
1531  }
1532 
1533  if (ev->type == EV_TIMEOUT || ev->type == RSP_STRING)
1534  at_state->getstring = 0;
1535 
1536  /* Search row in dial array which matches modem response and current
1537  constate */
1538  for (;; rep++) {
1539  rcode = rep->resp_code;
1540  if (rcode == RSP_LAST) {
1541  /* found nothing...*/
1542  dev_warn(cs->dev, "%s: rcode=RSP_LAST: "
1543  "resp_code %d in ConState %d!\n",
1544  __func__, ev->type, at_state->ConState);
1545  return;
1546  }
1547  if ((rcode == RSP_ANY || rcode == ev->type)
1548  && ((int) at_state->ConState >= rep->min_ConState)
1549  && (rep->max_ConState < 0
1550  || (int) at_state->ConState <= rep->max_ConState)
1551  && (rep->parameter < 0 || rep->parameter == ev->parameter))
1552  break;
1553  }
1554 
1555  p_command = rep->command;
1556 
1557  at_state->waiting = 0;
1558  for (curact = 0; curact < MAXACT; ++curact) {
1559  /* The row tells us what we should do ..
1560  */
1561  do_action(rep->action[curact], cs, bcs, &at_state, &p_command,
1562  &genresp, &resp_code, ev);
1563  if (!at_state)
1564  break; /* may be freed after disconnect */
1565  }
1566 
1567  if (at_state) {
1568  /* Jump to the next con-state regarding the array */
1569  if (rep->new_ConState >= 0)
1570  at_state->ConState = rep->new_ConState;
1571 
1572  if (genresp) {
1573  spin_lock_irqsave(&cs->lock, flags);
1574  at_state->timer_expires = 0;
1575  at_state->timer_active = 0;
1576  spin_unlock_irqrestore(&cs->lock, flags);
1577  gigaset_add_event(cs, at_state, resp_code,
1578  NULL, 0, NULL);
1579  } else {
1580  /* Send command to modem if not NULL... */
1581  if (p_command) {
1582  if (cs->connected)
1583  send_command(cs, p_command,
1584  sendcid, cs->dle,
1585  GFP_ATOMIC);
1586  else
1587  gigaset_add_event(cs, at_state,
1588  RSP_NODEV,
1589  NULL, 0, NULL);
1590  }
1591 
1592  spin_lock_irqsave(&cs->lock, flags);
1593  if (!rep->timeout) {
1594  at_state->timer_expires = 0;
1595  at_state->timer_active = 0;
1596  } else if (rep->timeout > 0) { /* new timeout */
1597  at_state->timer_expires = rep->timeout * 10;
1598  at_state->timer_active = 1;
1599  ++at_state->timer_index;
1600  }
1601  spin_unlock_irqrestore(&cs->lock, flags);
1602  }
1603  }
1604 }
1605 
1606 static void schedule_sequence(struct cardstate *cs,
1607  struct at_state_t *at_state, int sequence)
1608 {
1609  cs->cur_at_seq = sequence;
1610  gigaset_add_event(cs, at_state, RSP_INIT, NULL, sequence, NULL);
1611 }
1612 
1613 static void process_command_flags(struct cardstate *cs)
1614 {
1615  struct at_state_t *at_state = NULL;
1616  struct bc_state *bcs;
1617  int i;
1618  int sequence;
1619  unsigned long flags;
1620 
1621  cs->commands_pending = 0;
1622 
1623  if (cs->cur_at_seq) {
1624  gig_dbg(DEBUG_EVENT, "not searching scheduled commands: busy");
1625  return;
1626  }
1627 
1628  gig_dbg(DEBUG_EVENT, "searching scheduled commands");
1629 
1630  sequence = SEQ_NONE;
1631 
1632  /* clear pending_commands and hangup channels on shutdown */
1633  if (cs->at_state.pending_commands & PC_SHUTDOWN) {
1634  cs->at_state.pending_commands &= ~PC_CIDMODE;
1635  for (i = 0; i < cs->channels; ++i) {
1636  bcs = cs->bcs + i;
1637  at_state = &bcs->at_state;
1638  at_state->pending_commands &=
1639  ~(PC_DLE1 | PC_ACCEPT | PC_DIAL);
1640  if (at_state->cid > 0)
1641  at_state->pending_commands |= PC_HUP;
1642  if (at_state->pending_commands & PC_CID) {
1643  at_state->pending_commands |= PC_NOCID;
1644  at_state->pending_commands &= ~PC_CID;
1645  }
1646  }
1647  }
1648 
1649  /* clear pending_commands and hangup channels on reset */
1650  if (cs->at_state.pending_commands & PC_INIT) {
1651  cs->at_state.pending_commands &= ~PC_CIDMODE;
1652  for (i = 0; i < cs->channels; ++i) {
1653  bcs = cs->bcs + i;
1654  at_state = &bcs->at_state;
1655  at_state->pending_commands &=
1656  ~(PC_DLE1 | PC_ACCEPT | PC_DIAL);
1657  if (at_state->cid > 0)
1658  at_state->pending_commands |= PC_HUP;
1659  if (cs->mstate == MS_RECOVER) {
1660  if (at_state->pending_commands & PC_CID) {
1661  at_state->pending_commands |= PC_NOCID;
1662  at_state->pending_commands &= ~PC_CID;
1663  }
1664  }
1665  }
1666  }
1667 
1668  /* only switch back to unimodem mode if no commands are pending and
1669  * no channels are up */
1670  spin_lock_irqsave(&cs->lock, flags);
1671  if (cs->at_state.pending_commands == PC_UMMODE
1672  && !cs->cidmode
1673  && list_empty(&cs->temp_at_states)
1674  && cs->mode == M_CID) {
1675  sequence = SEQ_UMMODE;
1676  at_state = &cs->at_state;
1677  for (i = 0; i < cs->channels; ++i) {
1678  bcs = cs->bcs + i;
1679  if (bcs->at_state.pending_commands ||
1680  bcs->at_state.cid > 0) {
1681  sequence = SEQ_NONE;
1682  break;
1683  }
1684  }
1685  }
1686  spin_unlock_irqrestore(&cs->lock, flags);
1687  cs->at_state.pending_commands &= ~PC_UMMODE;
1688  if (sequence != SEQ_NONE) {
1689  schedule_sequence(cs, at_state, sequence);
1690  return;
1691  }
1692 
1693  for (i = 0; i < cs->channels; ++i) {
1694  bcs = cs->bcs + i;
1695  if (bcs->at_state.pending_commands & PC_HUP) {
1696  bcs->at_state.pending_commands &= ~PC_HUP;
1697  if (bcs->at_state.pending_commands & PC_CID) {
1698  /* not yet dialing: PC_NOCID is sufficient */
1699  bcs->at_state.pending_commands |= PC_NOCID;
1700  bcs->at_state.pending_commands &= ~PC_CID;
1701  } else {
1702  schedule_sequence(cs, &bcs->at_state, SEQ_HUP);
1703  return;
1704  }
1705  }
1706  if (bcs->at_state.pending_commands & PC_NOCID) {
1707  bcs->at_state.pending_commands &= ~PC_NOCID;
1708  cs->curchannel = bcs->channel;
1709  schedule_sequence(cs, &cs->at_state, SEQ_NOCID);
1710  return;
1711  } else if (bcs->at_state.pending_commands & PC_DLE0) {
1712  bcs->at_state.pending_commands &= ~PC_DLE0;
1713  cs->curchannel = bcs->channel;
1714  schedule_sequence(cs, &cs->at_state, SEQ_DLE0);
1715  return;
1716  }
1717  }
1718 
1719  list_for_each_entry(at_state, &cs->temp_at_states, list)
1720  if (at_state->pending_commands & PC_HUP) {
1721  at_state->pending_commands &= ~PC_HUP;
1722  schedule_sequence(cs, at_state, SEQ_HUP);
1723  return;
1724  }
1725 
1726  if (cs->at_state.pending_commands & PC_INIT) {
1727  cs->at_state.pending_commands &= ~PC_INIT;
1728  cs->dle = 0;
1729  cs->inbuf->inputstate = INS_command;
1730  schedule_sequence(cs, &cs->at_state, SEQ_INIT);
1731  return;
1732  }
1733  if (cs->at_state.pending_commands & PC_SHUTDOWN) {
1734  cs->at_state.pending_commands &= ~PC_SHUTDOWN;
1735  schedule_sequence(cs, &cs->at_state, SEQ_SHUTDOWN);
1736  return;
1737  }
1738  if (cs->at_state.pending_commands & PC_CIDMODE) {
1739  cs->at_state.pending_commands &= ~PC_CIDMODE;
1740  if (cs->mode == M_UNIMODEM) {
1741  cs->retry_count = 1;
1742  schedule_sequence(cs, &cs->at_state, SEQ_CIDMODE);
1743  return;
1744  }
1745  }
1746 
1747  for (i = 0; i < cs->channels; ++i) {
1748  bcs = cs->bcs + i;
1749  if (bcs->at_state.pending_commands & PC_DLE1) {
1750  bcs->at_state.pending_commands &= ~PC_DLE1;
1751  cs->curchannel = bcs->channel;
1752  schedule_sequence(cs, &cs->at_state, SEQ_DLE1);
1753  return;
1754  }
1755  if (bcs->at_state.pending_commands & PC_ACCEPT) {
1756  bcs->at_state.pending_commands &= ~PC_ACCEPT;
1757  schedule_sequence(cs, &bcs->at_state, SEQ_ACCEPT);
1758  return;
1759  }
1760  if (bcs->at_state.pending_commands & PC_DIAL) {
1761  bcs->at_state.pending_commands &= ~PC_DIAL;
1762  schedule_sequence(cs, &bcs->at_state, SEQ_DIAL);
1763  return;
1764  }
1765  if (bcs->at_state.pending_commands & PC_CID) {
1766  switch (cs->mode) {
1767  case M_UNIMODEM:
1768  cs->at_state.pending_commands |= PC_CIDMODE;
1769  gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE");
1770  cs->commands_pending = 1;
1771  return;
1772  case M_UNKNOWN:
1773  schedule_init(cs, MS_INIT);
1774  return;
1775  }
1776  bcs->at_state.pending_commands &= ~PC_CID;
1777  cs->curchannel = bcs->channel;
1778  cs->retry_count = 2;
1779  schedule_sequence(cs, &cs->at_state, SEQ_CID);
1780  return;
1781  }
1782  }
1783 }
1784 
1785 static void process_events(struct cardstate *cs)
1786 {
1787  struct event_t *ev;
1788  unsigned head, tail;
1789  int i;
1790  int check_flags = 0;
1791  int was_busy;
1792  unsigned long flags;
1793 
1794  spin_lock_irqsave(&cs->ev_lock, flags);
1795  head = cs->ev_head;
1796 
1797  for (i = 0; i < 2 * MAX_EVENTS; ++i) {
1798  tail = cs->ev_tail;
1799  if (tail == head) {
1800  if (!check_flags && !cs->commands_pending)
1801  break;
1802  check_flags = 0;
1803  spin_unlock_irqrestore(&cs->ev_lock, flags);
1804  process_command_flags(cs);
1805  spin_lock_irqsave(&cs->ev_lock, flags);
1806  tail = cs->ev_tail;
1807  if (tail == head) {
1808  if (!cs->commands_pending)
1809  break;
1810  continue;
1811  }
1812  }
1813 
1814  ev = cs->events + head;
1815  was_busy = cs->cur_at_seq != SEQ_NONE;
1816  spin_unlock_irqrestore(&cs->ev_lock, flags);
1817  process_event(cs, ev);
1818  spin_lock_irqsave(&cs->ev_lock, flags);
1819  kfree(ev->ptr);
1820  ev->ptr = NULL;
1821  if (was_busy && cs->cur_at_seq == SEQ_NONE)
1822  check_flags = 1;
1823 
1824  head = (head + 1) % MAX_EVENTS;
1825  cs->ev_head = head;
1826  }
1827 
1828  spin_unlock_irqrestore(&cs->ev_lock, flags);
1829 
1830  if (i == 2 * MAX_EVENTS) {
1831  dev_err(cs->dev,
1832  "infinite loop in process_events; aborting.\n");
1833  }
1834 }
1835 
1836 /* tasklet scheduled on any event received from the Gigaset device
1837  * parameter:
1838  * data ISDN controller state structure
1839  */
1840 void gigaset_handle_event(unsigned long data)
1841 {
1842  struct cardstate *cs = (struct cardstate *) data;
1843 
1844  /* handle incoming data on control/common channel */
1845  if (cs->inbuf->head != cs->inbuf->tail) {
1846  gig_dbg(DEBUG_INTR, "processing new data");
1847  cs->ops->handle_input(cs->inbuf);
1848  }
1849 
1850  process_events(cs);
1851 }
Generated on Thu Jan 10 2013 13:41:05 for Linux Kernel by   doxygen 1.8.2