|
5
|
1 /*
|
|
|
2 * SpanDSP - a series of DSP components for telephony
|
|
|
3 *
|
|
|
4 * at_interpreter.c - AT command interpreter to V.251, V.252, V.253, T.31 and the 3GPP specs.
|
|
|
5 *
|
|
|
6 * Written by Steve Underwood <steveu@coppice.org>
|
|
|
7 *
|
|
|
8 * Special thanks to Lee Howard <faxguy@howardsilvan.com>
|
|
|
9 * for his great work debugging and polishing this code.
|
|
|
10 *
|
|
|
11 * Copyright (C) 2004, 2005, 2006 Steve Underwood
|
|
|
12 *
|
|
|
13 * All rights reserved.
|
|
|
14 *
|
|
|
15 * This program is free software; you can redistribute it and/or modify
|
|
|
16 * it under the terms of the GNU General Public License version 2, as
|
|
|
17 * published by the Free Software Foundation.
|
|
|
18 *
|
|
|
19 * This program is distributed in the hope that it will be useful,
|
|
|
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
22 * GNU General Public License for more details.
|
|
|
23 *
|
|
|
24 * You should have received a copy of the GNU General Public License
|
|
|
25 * along with this program; if not, write to the Free Software
|
|
|
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
27 *
|
|
|
28 * $Id: at_interpreter.c,v 1.16 2006/11/19 14:07:24 steveu Exp $
|
|
|
29 */
|
|
|
30
|
|
|
31 /*! \file */
|
|
|
32
|
|
|
33 #ifdef HAVE_CONFIG_H
|
|
|
34 #include <config.h>
|
|
|
35 #endif
|
|
|
36
|
|
|
37 #define _GNU_SOURCE
|
|
|
38
|
|
|
39 #include <inttypes.h>
|
|
|
40 #include <stdlib.h>
|
|
|
41 #include <stdio.h>
|
|
|
42 #include <fcntl.h>
|
|
|
43 #include <memory.h>
|
|
|
44 #include <string.h>
|
|
|
45 #include <ctype.h>
|
|
|
46 #include <assert.h>
|
|
|
47
|
|
|
48 #include "spandsp/telephony.h"
|
|
|
49 #include "spandsp/logging.h"
|
|
|
50 #include "spandsp/queue.h"
|
|
|
51 #include "spandsp/power_meter.h"
|
|
|
52 #include "spandsp/complex.h"
|
|
|
53 #include "spandsp/tone_generate.h"
|
|
|
54 #include "spandsp/async.h"
|
|
|
55 #include "spandsp/hdlc.h"
|
|
|
56 #include "spandsp/fsk.h"
|
|
|
57
|
|
|
58 #include "spandsp/at_interpreter.h"
|
|
|
59
|
|
|
60 #define ms_to_samples(t) (((t)*SAMPLE_RATE)/1000)
|
|
|
61
|
|
|
62 #define MANUFACTURER "www.soft-switch.org"
|
|
|
63 #define SERIAL_NUMBER "42"
|
|
|
64 #define GLOBAL_OBJECT_IDENTITY "42"
|
|
|
65
|
|
|
66 enum
|
|
|
67 {
|
|
|
68 ASCII_RESULT_CODES = 1,
|
|
|
69 NUMERIC_RESULT_CODES,
|
|
|
70 NO_RESULT_CODES
|
|
|
71 };
|
|
|
72
|
|
|
73 static at_profile_t profiles[3] =
|
|
|
74 {
|
|
|
75 {
|
|
|
76 #if defined(_MSC_VER)
|
|
|
77 /*.echo =*/ TRUE,
|
|
|
78 /*.verbose =*/ TRUE,
|
|
|
79 /*.result_code_format =*/ ASCII_RESULT_CODES,
|
|
|
80 /*.pulse_dial =*/ FALSE,
|
|
|
81 /*.double_escape =*/ FALSE,
|
|
|
82 /*.adaptive_receive =*/ FALSE,
|
|
|
83 /*.s_regs[100] =*/ {0, 0, 0, '\r', '\n', '\b', 1, 60, 5, 0, 0}
|
|
|
84 #else
|
|
|
85 .echo = TRUE,
|
|
|
86 .verbose = TRUE,
|
|
|
87 .result_code_format = ASCII_RESULT_CODES,
|
|
|
88 .pulse_dial = FALSE,
|
|
|
89 .double_escape = FALSE,
|
|
|
90 .adaptive_receive = FALSE,
|
|
|
91 .s_regs[0] = 0,
|
|
|
92 .s_regs[3] = '\r',
|
|
|
93 .s_regs[4] = '\n',
|
|
|
94 .s_regs[5] = '\b',
|
|
|
95 .s_regs[6] = 1,
|
|
|
96 .s_regs[7] = 60,
|
|
|
97 .s_regs[8] = 5,
|
|
|
98 .s_regs[10] = 0
|
|
|
99 #endif
|
|
|
100 }
|
|
|
101 };
|
|
|
102
|
|
|
103 typedef const char *(*at_cmd_service_t)(at_state_t *s, const char *cmd);
|
|
|
104
|
|
|
105 static const char *manufacturer = MANUFACTURER;
|
|
|
106 static const char *model = PACKAGE;
|
|
|
107 static const char *revision = VERSION;
|
|
|
108
|
|
|
109 #define ETX 0x03
|
|
|
110 #define DLE 0x10
|
|
|
111 #define SUB 0x1A
|
|
|
112
|
|
|
113 enum
|
|
|
114 {
|
|
|
115 T31_FLUSH,
|
|
|
116 T31_SILENCE_TX,
|
|
|
117 T31_SILENCE_RX,
|
|
|
118 T31_CED_TONE,
|
|
|
119 T31_CNG_TONE,
|
|
|
120 T31_NOCNG_TONE,
|
|
|
121 };
|
|
|
122
|
|
|
123 static const char *at_response_codes[] =
|
|
|
124 {
|
|
|
125 "OK",
|
|
|
126 "CONNECT",
|
|
|
127 "RING",
|
|
|
128 "NO CARRIER",
|
|
|
129 "ERROR",
|
|
|
130 "???",
|
|
|
131 "NO DIALTONE",
|
|
|
132 "BUSY",
|
|
|
133 "NO ANSWER",
|
|
|
134 "+FCERROR",
|
|
|
135 "+FRH:3"
|
|
|
136 };
|
|
|
137
|
|
|
138 void at_set_at_rx_mode(at_state_t *s, int new_mode)
|
|
|
139 {
|
|
|
140 /* The use of a DTE timeout is mode dependent. Set the timeout appropriately in
|
|
|
141 the modem. */
|
|
|
142 switch (new_mode)
|
|
|
143 {
|
|
|
144 case AT_MODE_HDLC:
|
|
|
145 case AT_MODE_STUFFED:
|
|
|
146 at_modem_control(s, s->dte_inactivity_timeout*1000, (void *) (intptr_t) s->dte_inactivity_timeout);
|
|
|
147 break;
|
|
|
148 default:
|
|
|
149 at_modem_control(s, AT_MODEM_CONTROL_DTE_TIMEOUT, NULL);
|
|
|
150 break;
|
|
|
151 }
|
|
|
152 s->at_rx_mode = new_mode;
|
|
|
153 }
|
|
|
154 /*- End of function --------------------------------------------------------*/
|
|
|
155
|
|
|
156 void at_put_response(at_state_t *s, const char *t)
|
|
|
157 {
|
|
|
158 uint8_t buf[3];
|
|
|
159
|
|
|
160 buf[0] = s->p.s_regs[3];
|
|
|
161 buf[1] = s->p.s_regs[4];
|
|
|
162 buf[2] = '\0';
|
|
|
163 if (s->p.result_code_format == ASCII_RESULT_CODES)
|
|
|
164 s->at_tx_handler(s, s->at_tx_user_data, buf, 2);
|
|
|
165 s->at_tx_handler(s, s->at_tx_user_data, (uint8_t *) t, strlen(t));
|
|
|
166 s->at_tx_handler(s, s->at_tx_user_data, buf, 2);
|
|
|
167 }
|
|
|
168 /*- End of function --------------------------------------------------------*/
|
|
|
169
|
|
|
170 void at_put_numeric_response(at_state_t *s, int val)
|
|
|
171 {
|
|
|
172 char buf[20];
|
|
|
173
|
|
|
174 snprintf(buf, sizeof(buf), "%d", val);
|
|
|
175 at_put_response(s, buf);
|
|
|
176 }
|
|
|
177 /*- End of function --------------------------------------------------------*/
|
|
|
178
|
|
|
179 void at_put_response_code(at_state_t *s, int code)
|
|
|
180 {
|
|
|
181 uint8_t buf[20];
|
|
|
182
|
|
|
183 switch (s->p.result_code_format)
|
|
|
184 {
|
|
|
185 case ASCII_RESULT_CODES:
|
|
|
186 at_put_response(s, at_response_codes[code]);
|
|
|
187 break;
|
|
|
188 case NUMERIC_RESULT_CODES:
|
|
|
189 snprintf((char *) buf, sizeof(buf), "%d%c", code, s->p.s_regs[3]);
|
|
|
190 s->at_tx_handler(s, s->at_tx_user_data, buf, strlen((char *) buf));
|
|
|
191 break;
|
|
|
192 default:
|
|
|
193 /* No result codes */
|
|
|
194 break;
|
|
|
195 }
|
|
|
196 }
|
|
|
197 /*- End of function --------------------------------------------------------*/
|
|
|
198
|
|
|
199 static int answer_call(at_state_t *s)
|
|
|
200 {
|
|
|
201 if (at_modem_control(s, AT_MODEM_CONTROL_ANSWER, NULL) < 0)
|
|
|
202 return FALSE;
|
|
|
203 /* Answering should now be in progress. No AT response should be
|
|
|
204 issued at this point. */
|
|
|
205 s->do_hangup = FALSE;
|
|
|
206 return TRUE;
|
|
|
207 }
|
|
|
208 /*- End of function --------------------------------------------------------*/
|
|
|
209
|
|
|
210 void at_call_event(at_state_t *s, int event)
|
|
|
211 {
|
|
|
212 span_log(&s->logging, SPAN_LOG_FLOW, "Call event %d received\n", event);
|
|
|
213 switch (event)
|
|
|
214 {
|
|
|
215 case AT_CALL_EVENT_ALERTING:
|
|
|
216 at_modem_control(s, AT_MODEM_CONTROL_RNG, (void *) 1);
|
|
|
217 if (s->display_call_info && !s->call_info_displayed)
|
|
|
218 at_display_call_info(s);
|
|
|
219 at_put_response_code(s, AT_RESPONSE_CODE_RING);
|
|
|
220 if ((++s->rings_indicated) >= s->p.s_regs[0] && s->p.s_regs[0])
|
|
|
221 {
|
|
|
222 /* The modem is set to auto-answer now */
|
|
|
223 answer_call(s);
|
|
|
224 }
|
|
|
225 break;
|
|
|
226 case AT_CALL_EVENT_ANSWERED:
|
|
|
227 at_modem_control(s, AT_MODEM_CONTROL_RNG, (void *) 0);
|
|
|
228 if (s->fclass_mode == 0)
|
|
|
229 {
|
|
|
230 /* Normal data modem connection */
|
|
|
231 at_set_at_rx_mode(s, AT_MODE_CONNECTED);
|
|
|
232 /* TODO: */
|
|
|
233 }
|
|
|
234 else
|
|
|
235 {
|
|
|
236 /* FAX modem connection */
|
|
|
237 at_set_at_rx_mode(s, AT_MODE_DELIVERY);
|
|
|
238 at_modem_control(s, AT_MODEM_CONTROL_RESTART, (void *) T31_CED_TONE);
|
|
|
239 }
|
|
|
240 break;
|
|
|
241 case AT_CALL_EVENT_CONNECTED:
|
|
|
242 span_log(&s->logging, SPAN_LOG_FLOW, "Dial call - connected. fclass=%d\n", s->fclass_mode);
|
|
|
243 at_modem_control(s, AT_MODEM_CONTROL_RNG, (void *) 0);
|
|
|
244 if (s->fclass_mode == 0)
|
|
|
245 {
|
|
|
246 /* Normal data modem connection */
|
|
|
247 at_set_at_rx_mode(s, AT_MODE_CONNECTED);
|
|
|
248 /* TODO: */
|
|
|
249 }
|
|
|
250 else
|
|
|
251 {
|
|
|
252 /* FAX modem connection */
|
|
|
253 at_set_at_rx_mode(s, AT_MODE_DELIVERY);
|
|
|
254 if (s->silent_dial)
|
|
|
255 at_modem_control(s, AT_MODEM_CONTROL_RESTART, (void *) T31_NOCNG_TONE);
|
|
|
256 else
|
|
|
257 at_modem_control(s, AT_MODEM_CONTROL_RESTART, (void *) T31_CNG_TONE);
|
|
|
258 s->dte_is_waiting = TRUE;
|
|
|
259 }
|
|
|
260 break;
|
|
|
261 case AT_CALL_EVENT_BUSY:
|
|
|
262 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
263 at_put_response_code(s, AT_RESPONSE_CODE_BUSY);
|
|
|
264 break;
|
|
|
265 case AT_CALL_EVENT_NO_DIALTONE:
|
|
|
266 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
267 at_put_response_code(s, AT_RESPONSE_CODE_NO_DIALTONE);
|
|
|
268 break;
|
|
|
269 case AT_CALL_EVENT_NO_ANSWER:
|
|
|
270 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
271 at_put_response_code(s, AT_RESPONSE_CODE_NO_ANSWER);
|
|
|
272 break;
|
|
|
273 case AT_CALL_EVENT_HANGUP:
|
|
|
274 span_log(&s->logging, SPAN_LOG_FLOW, "Hangup... at_rx_mode %d\n", s->at_rx_mode);
|
|
|
275 at_modem_control(s, AT_MODEM_CONTROL_ONHOOK, NULL);
|
|
|
276 if (s->dte_is_waiting)
|
|
|
277 {
|
|
|
278 if (s->ok_is_pending)
|
|
|
279 {
|
|
|
280 at_put_response_code(s, AT_RESPONSE_CODE_OK);
|
|
|
281 s->ok_is_pending = FALSE;
|
|
|
282 }
|
|
|
283 else
|
|
|
284 {
|
|
|
285 at_put_response_code(s, AT_RESPONSE_CODE_NO_CARRIER);
|
|
|
286 }
|
|
|
287 s->dte_is_waiting = FALSE;
|
|
|
288 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
289 }
|
|
|
290 else if (s->fclass_mode && s->rx_signal_present)
|
|
|
291 {
|
|
|
292 s->rx_data[s->rx_data_bytes++] = DLE;
|
|
|
293 s->rx_data[s->rx_data_bytes++] = ETX;
|
|
|
294 s->at_tx_handler(s, s->at_tx_user_data, s->rx_data, s->rx_data_bytes);
|
|
|
295 s->rx_data_bytes = 0;
|
|
|
296 }
|
|
|
297 if (s->at_rx_mode != AT_MODE_OFFHOOK_COMMAND && s->at_rx_mode != AT_MODE_ONHOOK_COMMAND)
|
|
|
298 at_put_response_code(s, AT_RESPONSE_CODE_NO_CARRIER);
|
|
|
299 s->rx_signal_present = FALSE;
|
|
|
300 at_modem_control(s, AT_MODEM_CONTROL_RNG, (void *) 0);
|
|
|
301 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
302 break;
|
|
|
303 default:
|
|
|
304 span_log(&s->logging, SPAN_LOG_WARNING, "Invalid call event %d received.\n", event);
|
|
|
305 break;
|
|
|
306 }
|
|
|
307 }
|
|
|
308 /*- End of function --------------------------------------------------------*/
|
|
|
309
|
|
|
310 void at_reset_call_info(at_state_t *s)
|
|
|
311 {
|
|
|
312 s->rings_indicated = 0;
|
|
|
313 s->call_info_displayed = FALSE;
|
|
|
314 if (s->call_date)
|
|
|
315 {
|
|
|
316 free(s->call_date);
|
|
|
317 s->call_date = NULL;
|
|
|
318 }
|
|
|
319 if (s->call_time)
|
|
|
320 {
|
|
|
321 free(s->call_time);
|
|
|
322 s->call_time = NULL;
|
|
|
323 }
|
|
|
324 if (s->originating_name)
|
|
|
325 {
|
|
|
326 free(s->originating_name);
|
|
|
327 s->originating_name = NULL;
|
|
|
328 }
|
|
|
329 if (s->originating_number)
|
|
|
330 {
|
|
|
331 free(s->originating_number);
|
|
|
332 s->originating_number = NULL;
|
|
|
333 }
|
|
|
334 if (s->originating_ani)
|
|
|
335 {
|
|
|
336 free(s->originating_ani);
|
|
|
337 s->originating_ani = NULL;
|
|
|
338 }
|
|
|
339 if (s->destination_number)
|
|
|
340 {
|
|
|
341 free(s->destination_number);
|
|
|
342 s->destination_number = NULL;
|
|
|
343 }
|
|
|
344 }
|
|
|
345 /*- End of function --------------------------------------------------------*/
|
|
|
346
|
|
|
347 void at_set_call_info(at_state_t *s,
|
|
|
348 char const *call_date,
|
|
|
349 char const *call_time,
|
|
|
350 char const *originating_name,
|
|
|
351 char const *originating_number,
|
|
|
352 char const *originating_ani,
|
|
|
353 char const *destination_number)
|
|
|
354 {
|
|
|
355 at_reset_call_info(s);
|
|
|
356 if (call_date)
|
|
|
357 s->call_date = strdup(call_date);
|
|
|
358 if (call_time)
|
|
|
359 s->call_time = strdup(call_time);
|
|
|
360 if (originating_name)
|
|
|
361 s->originating_name = strdup(originating_name);
|
|
|
362 if (originating_number)
|
|
|
363 s->originating_number = strdup(originating_number);
|
|
|
364 if (originating_ani)
|
|
|
365 s->originating_ani = strdup(originating_ani);
|
|
|
366 if (destination_number)
|
|
|
367 s->destination_number = strdup(destination_number);
|
|
|
368 }
|
|
|
369 /*- End of function --------------------------------------------------------*/
|
|
|
370
|
|
|
371 void at_display_call_info(at_state_t *s)
|
|
|
372 {
|
|
|
373 char buf[132 + 1];
|
|
|
374
|
|
|
375 snprintf(buf, sizeof(buf), "DATE=%s", (s->call_date) ? s->call_date : "<NONE>");
|
|
|
376 at_put_response(s, buf);
|
|
|
377 snprintf(buf, sizeof(buf), "TIME=%s", (s->call_time) ? s->call_time : "<NONE>");
|
|
|
378 at_put_response(s, buf);
|
|
|
379 snprintf(buf, sizeof(buf), "NAME=%s", (s->originating_name) ? s->originating_name : "<NONE>");
|
|
|
380 at_put_response(s, buf);
|
|
|
381 snprintf(buf, sizeof(buf), "NMBR=%s", (s->originating_number) ? s->originating_number : "<NONE>");
|
|
|
382 at_put_response(s, buf);
|
|
|
383 snprintf(buf, sizeof(buf), "ANID=%s", (s->originating_ani) ? s->originating_ani : "<NONE>");
|
|
|
384 at_put_response(s, buf);
|
|
|
385 snprintf(buf, sizeof(buf), "NDID=%s", (s->destination_number) ? s->destination_number : "<NONE>");
|
|
|
386 at_put_response(s, buf);
|
|
|
387 s->call_info_displayed = TRUE;
|
|
|
388 }
|
|
|
389 /*- End of function --------------------------------------------------------*/
|
|
|
390
|
|
|
391 static int parse_num(const char **s, int max_value)
|
|
|
392 {
|
|
|
393 int i;
|
|
|
394
|
|
|
395 /* The spec. says no digits is valid, and should be treated as zero. */
|
|
|
396 i = 0;
|
|
|
397 while (isdigit(**s))
|
|
|
398 {
|
|
|
399 i = i*10 + ((**s) - '0');
|
|
|
400 (*s)++;
|
|
|
401 }
|
|
|
402 if (i > max_value)
|
|
|
403 i = -1;
|
|
|
404 return i;
|
|
|
405 }
|
|
|
406 /*- End of function --------------------------------------------------------*/
|
|
|
407
|
|
|
408 static int parse_hex_num(const char **s, int max_value)
|
|
|
409 {
|
|
|
410 int i;
|
|
|
411
|
|
|
412 /* The spec. says a hex value is always 2 digits, and the alpha digits are
|
|
|
413 upper case. */
|
|
|
414 i = 0;
|
|
|
415 if (isdigit(**s))
|
|
|
416 i = **s - '0';
|
|
|
417 else if (**s >= 'A' && **s <= 'F')
|
|
|
418 i = **s - 'A';
|
|
|
419 else
|
|
|
420 return -1;
|
|
|
421 (*s)++;
|
|
|
422
|
|
|
423 if (isdigit(**s))
|
|
|
424 i = (i << 4) | (**s - '0');
|
|
|
425 else if (**s >= 'A' && **s <= 'F')
|
|
|
426 i = (i << 4) | (**s - 'A');
|
|
|
427 else
|
|
|
428 return -1;
|
|
|
429 (*s)++;
|
|
|
430 if (i > max_value)
|
|
|
431 i = -1;
|
|
|
432 return i;
|
|
|
433 }
|
|
|
434 /*- End of function --------------------------------------------------------*/
|
|
|
435
|
|
|
436 static int parse_out(at_state_t *s, const char **t, int *target, int max_value, const char *prefix, const char *def)
|
|
|
437 {
|
|
|
438 char buf[100];
|
|
|
439 int val;
|
|
|
440
|
|
|
441 switch (*(*t)++)
|
|
|
442 {
|
|
|
443 case '=':
|
|
|
444 switch (**t)
|
|
|
445 {
|
|
|
446 case '?':
|
|
|
447 /* Show possible values */
|
|
|
448 (*t)++;
|
|
|
449 snprintf(buf, sizeof(buf), "%s%s", (prefix) ? prefix : "", def);
|
|
|
450 at_put_response(s, buf);
|
|
|
451 break;
|
|
|
452 default:
|
|
|
453 /* Set value */
|
|
|
454 if ((val = parse_num(t, max_value)) < 0)
|
|
|
455 return FALSE;
|
|
|
456 if (target)
|
|
|
457 *target = val;
|
|
|
458 break;
|
|
|
459 }
|
|
|
460 break;
|
|
|
461 case '?':
|
|
|
462 /* Show current value */
|
|
|
463 val = (target) ? *target : 0;
|
|
|
464 snprintf(buf, sizeof(buf), "%s%d", (prefix) ? prefix : "", val);
|
|
|
465 at_put_response(s, buf);
|
|
|
466 break;
|
|
|
467 default:
|
|
|
468 return FALSE;
|
|
|
469 }
|
|
|
470 return TRUE;
|
|
|
471 }
|
|
|
472 /*- End of function --------------------------------------------------------*/
|
|
|
473
|
|
|
474 static int parse_2_out(at_state_t *s, const char **t, int *target1, int max_value1, int *target2, int max_value2, const char *prefix, const char *def)
|
|
|
475 {
|
|
|
476 char buf[100];
|
|
|
477 int val1;
|
|
|
478 int val2;
|
|
|
479
|
|
|
480 switch (*(*t)++)
|
|
|
481 {
|
|
|
482 case '=':
|
|
|
483 switch (**t)
|
|
|
484 {
|
|
|
485 case '?':
|
|
|
486 /* Show possible values */
|
|
|
487 (*t)++;
|
|
|
488 snprintf(buf, sizeof(buf), "%s%s", (prefix) ? prefix : "", def);
|
|
|
489 at_put_response(s, buf);
|
|
|
490 break;
|
|
|
491 default:
|
|
|
492 /* Set value */
|
|
|
493 if ((val1 = parse_num(t, max_value1)) < 0)
|
|
|
494 return FALSE;
|
|
|
495 if (target1)
|
|
|
496 *target1 = val1;
|
|
|
497 if (**t == ',')
|
|
|
498 {
|
|
|
499 (*t)++;
|
|
|
500 if ((val2 = parse_num(t, max_value2)) < 0)
|
|
|
501 return FALSE;
|
|
|
502 if (target2)
|
|
|
503 *target2 = val2;
|
|
|
504 }
|
|
|
505 break;
|
|
|
506 }
|
|
|
507 break;
|
|
|
508 case '?':
|
|
|
509 /* Show current value */
|
|
|
510 val1 = (target1) ? *target1 : 0;
|
|
|
511 val2 = (target2) ? *target2 : 0;
|
|
|
512 snprintf(buf, sizeof(buf), "%s%d,%d", (prefix) ? prefix : "", val1, val2);
|
|
|
513 at_put_response(s, buf);
|
|
|
514 break;
|
|
|
515 default:
|
|
|
516 return FALSE;
|
|
|
517 }
|
|
|
518 return TRUE;
|
|
|
519 }
|
|
|
520 /*- End of function --------------------------------------------------------*/
|
|
|
521
|
|
|
522 static int parse_hex_out(at_state_t *s, const char **t, int *target, int max_value, const char *prefix, const char *def)
|
|
|
523 {
|
|
|
524 char buf[100];
|
|
|
525 int val;
|
|
|
526
|
|
|
527 switch (*(*t)++)
|
|
|
528 {
|
|
|
529 case '=':
|
|
|
530 switch (**t)
|
|
|
531 {
|
|
|
532 case '?':
|
|
|
533 /* Show possible values */
|
|
|
534 (*t)++;
|
|
|
535 snprintf(buf, sizeof(buf), "%s%s", (prefix) ? prefix : "", def);
|
|
|
536 at_put_response(s, buf);
|
|
|
537 break;
|
|
|
538 default:
|
|
|
539 /* Set value */
|
|
|
540 if ((val = parse_hex_num(t, max_value)) < 0)
|
|
|
541 return FALSE;
|
|
|
542 if (target)
|
|
|
543 *target = val;
|
|
|
544 break;
|
|
|
545 }
|
|
|
546 break;
|
|
|
547 case '?':
|
|
|
548 /* Show current value */
|
|
|
549 val = (target) ? *target : 0;
|
|
|
550 snprintf(buf, sizeof(buf), "%s%02X", (prefix) ? prefix : "", val);
|
|
|
551 at_put_response(s, buf);
|
|
|
552 break;
|
|
|
553 default:
|
|
|
554 return FALSE;
|
|
|
555 }
|
|
|
556 return TRUE;
|
|
|
557 }
|
|
|
558 /*- End of function --------------------------------------------------------*/
|
|
|
559
|
|
|
560 static int match_element(const char **variant, const char *variants)
|
|
|
561 {
|
|
|
562 int i;
|
|
|
563 size_t len;
|
|
|
564 char const *s;
|
|
|
565 char const *t;
|
|
|
566
|
|
|
567 s = variants;
|
|
|
568 for (i = 0; *s; i++)
|
|
|
569 {
|
|
|
570 if ((t = strchr(s, ',')))
|
|
|
571 len = t - s;
|
|
|
572 else
|
|
|
573 len = strlen(s);
|
|
|
574 if (len == (int) strlen(*variant) && memcmp(*variant, s, len) == 0)
|
|
|
575 {
|
|
|
576 *variant += len;
|
|
|
577 return i;
|
|
|
578 }
|
|
|
579 s += len;
|
|
|
580 if (*s == ',')
|
|
|
581 s++;
|
|
|
582 }
|
|
|
583 return -1;
|
|
|
584 }
|
|
|
585 /*- End of function --------------------------------------------------------*/
|
|
|
586
|
|
|
587 static int parse_string_out(at_state_t *s, const char **t, int *target, int max_value, const char *prefix, const char *def)
|
|
|
588 {
|
|
|
589 char buf[100];
|
|
|
590 int val;
|
|
|
591 size_t len;
|
|
|
592 char *tmp;
|
|
|
593
|
|
|
594 switch (*(*t)++)
|
|
|
595 {
|
|
|
596 case '=':
|
|
|
597 switch (**t)
|
|
|
598 {
|
|
|
599 case '?':
|
|
|
600 /* Show possible values */
|
|
|
601 (*t)++;
|
|
|
602 snprintf(buf, sizeof(buf), "%s%s", (prefix) ? prefix : "", def);
|
|
|
603 at_put_response(s, buf);
|
|
|
604 break;
|
|
|
605 default:
|
|
|
606 /* Set value */
|
|
|
607 if ((val = match_element(t, def)) < 0)
|
|
|
608 return FALSE;
|
|
|
609 if (target)
|
|
|
610 *target = val;
|
|
|
611 break;
|
|
|
612 }
|
|
|
613 break;
|
|
|
614 case '?':
|
|
|
615 /* Show current index value from def */
|
|
|
616 val = (target) ? *target : 0;
|
|
|
617 while (val-- && (def = strchr(def, ',')))
|
|
|
618 def++;
|
|
|
619 if ((tmp = strchr(def, ',')))
|
|
|
620 len = tmp - def;
|
|
|
621 else
|
|
|
622 len = strlen(def);
|
|
|
623 snprintf(buf, sizeof(buf), "%s%.*s", (prefix) ? prefix : "", (int) len, def);
|
|
|
624 at_put_response(s, buf);
|
|
|
625 break;
|
|
|
626 default:
|
|
|
627 return FALSE;
|
|
|
628 }
|
|
|
629 return TRUE;
|
|
|
630 }
|
|
|
631 /*- End of function --------------------------------------------------------*/
|
|
|
632
|
|
|
633 static int process_class1_cmd(at_state_t *s, const char **t)
|
|
|
634 {
|
|
|
635 int val;
|
|
|
636 int operation;
|
|
|
637 int direction;
|
|
|
638 int result;
|
|
|
639 const char *allowed;
|
|
|
640
|
|
|
641 direction = (*(*t + 2) == 'T');
|
|
|
642 operation = *(*t + 3);
|
|
|
643 /* Step past the "+Fxx" */
|
|
|
644 *t += 4;
|
|
|
645 switch (operation)
|
|
|
646 {
|
|
|
647 case 'S':
|
|
|
648 allowed = "0-255";
|
|
|
649 break;
|
|
|
650 case 'H':
|
|
|
651 allowed = "3";
|
|
|
652 break;
|
|
|
653 default:
|
|
|
654 #if defined(ENABLE_V17)
|
|
|
655 allowed = "24,48,72,73,74,96,97,98,121,122,145,146";
|
|
|
656 #else
|
|
|
657 allowed = "24,48,72,96";
|
|
|
658 #endif
|
|
|
659 break;
|
|
|
660 }
|
|
|
661
|
|
|
662 val = -1;
|
|
|
663 if (!parse_out(s, t, &val, 255, NULL, allowed))
|
|
|
664 return TRUE;
|
|
|
665 if (val < 0)
|
|
|
666 {
|
|
|
667 /* It was just a query */
|
|
|
668 return TRUE;
|
|
|
669 }
|
|
|
670 /* All class 1 FAX commands are supposed to give an ERROR response, if the phone
|
|
|
671 is on-hook. */
|
|
|
672 if (s->at_rx_mode == AT_MODE_ONHOOK_COMMAND)
|
|
|
673 return FALSE;
|
|
|
674
|
|
|
675 result = TRUE;
|
|
|
676 if (s->class1_handler)
|
|
|
677 result = s->class1_handler(s, s->class1_user_data, direction, operation, val);
|
|
|
678 switch (result)
|
|
|
679 {
|
|
|
680 case 0:
|
|
|
681 /* Inhibit an immediate response. (These commands should not be part of a multi-command entry.) */
|
|
|
682 *t = (const char *) -1;
|
|
|
683 return TRUE;
|
|
|
684 case -1:
|
|
|
685 return FALSE;
|
|
|
686 }
|
|
|
687 return TRUE;
|
|
|
688 }
|
|
|
689 /*- End of function --------------------------------------------------------*/
|
|
|
690
|
|
|
691 static const char *s_reg_handler(at_state_t *s, const char *t, int reg)
|
|
|
692 {
|
|
|
693 int val;
|
|
|
694 int b;
|
|
|
695 char buf[4];
|
|
|
696
|
|
|
697 /* Set or get an S register */
|
|
|
698 switch (*t++)
|
|
|
699 {
|
|
|
700 case '=':
|
|
|
701 switch (*t)
|
|
|
702 {
|
|
|
703 case '?':
|
|
|
704 t++;
|
|
|
705 snprintf(buf, sizeof(buf), "%3.3d", 0);
|
|
|
706 at_put_response(s, buf);
|
|
|
707 break;
|
|
|
708 default:
|
|
|
709 if ((val = parse_num(&t, 255)) < 0)
|
|
|
710 return NULL;
|
|
|
711 s->p.s_regs[reg] = (uint8_t) val;
|
|
|
712 break;
|
|
|
713 }
|
|
|
714 break;
|
|
|
715 case '?':
|
|
|
716 snprintf(buf, sizeof(buf), "%3.3d", s->p.s_regs[reg]);
|
|
|
717 at_put_response(s, buf);
|
|
|
718 break;
|
|
|
719 case '.':
|
|
|
720 if ((b = parse_num(&t, 7)) < 0)
|
|
|
721 return NULL;
|
|
|
722 switch (*t++)
|
|
|
723 {
|
|
|
724 case '=':
|
|
|
725 switch (*t)
|
|
|
726 {
|
|
|
727 case '?':
|
|
|
728 t++;
|
|
|
729 at_put_numeric_response(s, 0);
|
|
|
730 break;
|
|
|
731 default:
|
|
|
732 if ((val = parse_num(&t, 1)) < 0)
|
|
|
733 return NULL;
|
|
|
734 if (val)
|
|
|
735 s->p.s_regs[reg] |= (1 << b);
|
|
|
736 else
|
|
|
737 s->p.s_regs[reg] &= ~(1 << b);
|
|
|
738 break;
|
|
|
739 }
|
|
|
740 break;
|
|
|
741 case '?':
|
|
|
742 at_put_numeric_response(s, (int) ((s->p.s_regs[reg] >> b) & 1));
|
|
|
743 break;
|
|
|
744 default:
|
|
|
745 return NULL;
|
|
|
746 }
|
|
|
747 break;
|
|
|
748 default:
|
|
|
749 return NULL;
|
|
|
750 }
|
|
|
751 return t;
|
|
|
752 }
|
|
|
753 /*- End of function --------------------------------------------------------*/
|
|
|
754
|
|
|
755 static const char *at_cmd_dummy(at_state_t *s, const char *t)
|
|
|
756 {
|
|
|
757 /* Dummy routine to absorb delimiting characters from a command string */
|
|
|
758 return t + 1;
|
|
|
759 }
|
|
|
760 /*- End of function --------------------------------------------------------*/
|
|
|
761
|
|
|
762 static const char *at_cmd_A(at_state_t *s, const char *t)
|
|
|
763 {
|
|
|
764 /* V.250 6.3.5 - Answer (abortable) */
|
|
|
765 t += 1;
|
|
|
766 if (!answer_call(s))
|
|
|
767 return NULL;
|
|
|
768 return (const char *) -1;
|
|
|
769 }
|
|
|
770 /*- End of function --------------------------------------------------------*/
|
|
|
771
|
|
|
772 static const char *at_cmd_D(at_state_t *s, const char *t)
|
|
|
773 {
|
|
|
774 int ok;
|
|
|
775 char *u;
|
|
|
776 const char *w;
|
|
|
777 char num[100 + 1];
|
|
|
778 char ch;
|
|
|
779
|
|
|
780 /* V.250 6.3.1 - Dial (abortable) */
|
|
|
781 at_reset_call_info(s);
|
|
|
782 s->do_hangup = FALSE;
|
|
|
783 s->silent_dial = FALSE;
|
|
|
784 t += 1;
|
|
|
785 ok = FALSE;
|
|
|
786 /* There are a numbers of options in a dial command string.
|
|
|
787 Many are completely irrelevant in this application. */
|
|
|
788 w = t;
|
|
|
789 u = num;
|
|
|
790 for ( ; (ch = *t); t++)
|
|
|
791 {
|
|
|
792 if (isdigit(ch))
|
|
|
793 {
|
|
|
794 /* V.250 6.3.1.1 Basic digit set */
|
|
|
795 *u++ = ch;
|
|
|
796 }
|
|
|
797 else
|
|
|
798 {
|
|
|
799 switch (ch)
|
|
|
800 {
|
|
|
801 case 'A':
|
|
|
802 case 'B':
|
|
|
803 case 'C':
|
|
|
804 case 'D':
|
|
|
805 case '*':
|
|
|
806 case '#':
|
|
|
807 /* V.250 6.3.1.1 Full DTMF repertoire */
|
|
|
808 if (!s->p.pulse_dial)
|
|
|
809 *u++ = ch;
|
|
|
810 break;
|
|
|
811 case '+':
|
|
|
812 /* V.250 6.3.1.1 International access code */
|
|
|
813 /* TODO: */
|
|
|
814 break;
|
|
|
815 case ',':
|
|
|
816 /* V.250 6.3.1.2 Pause */
|
|
|
817 /* TODO: */
|
|
|
818 break;
|
|
|
819 case 'T':
|
|
|
820 /* V.250 6.3.1.3 Tone dial */
|
|
|
821 s->p.pulse_dial = FALSE;
|
|
|
822 break;
|
|
|
823 case 'P':
|
|
|
824 /* V.250 6.3.1.4 Pulse dial */
|
|
|
825 s->p.pulse_dial = TRUE;
|
|
|
826 break;
|
|
|
827 case '!':
|
|
|
828 /* V.250 6.3.1.5 Hook flash, register recall */
|
|
|
829 /* TODO: */
|
|
|
830 break;
|
|
|
831 case 'W':
|
|
|
832 /* V.250 6.3.1.6 Wait for dial tone */
|
|
|
833 /* TODO: */
|
|
|
834 break;
|
|
|
835 case '@':
|
|
|
836 /* V.250 6.3.1.7 Wait for quiet answer */
|
|
|
837 s->silent_dial = TRUE;
|
|
|
838 break;
|
|
|
839 case 'S':
|
|
|
840 /* V.250 6.3.1.8 Invoke stored string */
|
|
|
841 /* S=<location> */
|
|
|
842 /* TODO: */
|
|
|
843 break;
|
|
|
844 case 'G':
|
|
|
845 case 'g':
|
|
|
846 /* GSM07.07 6.2 - Control the CUG supplementary service for this call */
|
|
|
847 /* TODO: */
|
|
|
848 break;
|
|
|
849 case 'I':
|
|
|
850 case 'i':
|
|
|
851 /* GSM07.07 6.2 - Override Calling Line Identification Restriction (CLIR) */
|
|
|
852 /* TODO: */
|
|
|
853 break;
|
|
|
854 case ';':
|
|
|
855 /* V.250 6.3.1 - Dial string terminator - make voice call and remain in command mode */
|
|
|
856 /* TODO: */
|
|
|
857 break;
|
|
|
858 case '>':
|
|
|
859 /* GSM07.07 6.2 - Direct dialling from phone book supplementary service subscription
|
|
|
860 default value for this call */
|
|
|
861 /* TODO: */
|
|
|
862 break;
|
|
|
863 default:
|
|
|
864 return NULL;
|
|
|
865 }
|
|
|
866 }
|
|
|
867 }
|
|
|
868 *u = '\0';
|
|
|
869 if ((ok = at_modem_control(s, AT_MODEM_CONTROL_CALL, num)) < 0)
|
|
|
870 return NULL;
|
|
|
871 /* Dialing should now be in progress. No AT response should be
|
|
|
872 issued at this point. */
|
|
|
873 return (const char *) -1;
|
|
|
874 }
|
|
|
875 /*- End of function --------------------------------------------------------*/
|
|
|
876
|
|
|
877 static const char *at_cmd_E(at_state_t *s, const char *t)
|
|
|
878 {
|
|
|
879 int val;
|
|
|
880
|
|
|
881 /* V.250 6.2.4 - Command echo */
|
|
|
882 t += 1;
|
|
|
883 if ((val = parse_num(&t, 1)) < 0)
|
|
|
884 return NULL;
|
|
|
885 s->p.echo = val;
|
|
|
886 return t;
|
|
|
887 }
|
|
|
888 /*- End of function --------------------------------------------------------*/
|
|
|
889
|
|
|
890 static const char *at_cmd_H(at_state_t *s, const char *t)
|
|
|
891 {
|
|
|
892 int val;
|
|
|
893
|
|
|
894 /* V.250 6.3.6 - Hook control */
|
|
|
895 t += 1;
|
|
|
896 if ((val = parse_num(&t, 1)) < 0)
|
|
|
897 return NULL;
|
|
|
898 if (val)
|
|
|
899 {
|
|
|
900 /* Take the receiver off-hook, effectively busying-out the modem. */
|
|
|
901 if (s->at_rx_mode != AT_MODE_ONHOOK_COMMAND && s->at_rx_mode != AT_MODE_OFFHOOK_COMMAND)
|
|
|
902 return NULL;
|
|
|
903 at_modem_control(s, AT_MODEM_CONTROL_OFFHOOK, NULL);
|
|
|
904 at_set_at_rx_mode(s, AT_MODE_OFFHOOK_COMMAND);
|
|
|
905 return t;
|
|
|
906 }
|
|
|
907 at_reset_call_info(s);
|
|
|
908 if (s->at_rx_mode != AT_MODE_ONHOOK_COMMAND && s->at_rx_mode != AT_MODE_OFFHOOK_COMMAND)
|
|
|
909 {
|
|
|
910 /* Push out the last of the audio (probably by sending a short silence). */
|
|
|
911 at_modem_control(s, AT_MODEM_CONTROL_RESTART, (void *) T31_FLUSH);
|
|
|
912 s->do_hangup = TRUE;
|
|
|
913 at_set_at_rx_mode(s, AT_MODE_CONNECTED);
|
|
|
914 return (const char *) -1;
|
|
|
915 }
|
|
|
916 at_modem_control(s, AT_MODEM_CONTROL_HANGUP, NULL);
|
|
|
917 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
918 return t;
|
|
|
919 }
|
|
|
920 /*- End of function --------------------------------------------------------*/
|
|
|
921
|
|
|
922 static const char *at_cmd_I(at_state_t *s, const char *t)
|
|
|
923 {
|
|
|
924 int val;
|
|
|
925
|
|
|
926 /* V.250 6.1.3 - Request identification information */
|
|
|
927 /* N.B. The information supplied in response to an ATIx command is very
|
|
|
928 variable. It was widely used in different ways before the AT command
|
|
|
929 set was standardised by the ITU. */
|
|
|
930 t += 1;
|
|
|
931 switch (val = parse_num(&t, 255))
|
|
|
932 {
|
|
|
933 case 0:
|
|
|
934 at_put_response(s, model);
|
|
|
935 break;
|
|
|
936 case 3:
|
|
|
937 at_put_response(s, manufacturer);
|
|
|
938 break;
|
|
|
939 default:
|
|
|
940 return NULL;
|
|
|
941 }
|
|
|
942 return t;
|
|
|
943 }
|
|
|
944 /*- End of function --------------------------------------------------------*/
|
|
|
945
|
|
|
946 static const char *at_cmd_L(at_state_t *s, const char *t)
|
|
|
947 {
|
|
|
948 int val;
|
|
|
949
|
|
|
950 /* V.250 6.3.13 - Monitor speaker loudness */
|
|
|
951 /* Just absorb this command, as we have no speaker */
|
|
|
952 t += 1;
|
|
|
953 if ((val = parse_num(&t, 255)) < 0)
|
|
|
954 return NULL;
|
|
|
955 s->speaker_volume = val;
|
|
|
956 return t;
|
|
|
957 }
|
|
|
958 /*- End of function --------------------------------------------------------*/
|
|
|
959
|
|
|
960 static const char *at_cmd_M(at_state_t *s, const char *t)
|
|
|
961 {
|
|
|
962 int val;
|
|
|
963
|
|
|
964 /* V.250 6.3.14 - Monitor speaker mode */
|
|
|
965 /* Just absorb this command, as we have no speaker */
|
|
|
966 t += 1;
|
|
|
967 if ((val = parse_num(&t, 255)) < 0)
|
|
|
968 return NULL;
|
|
|
969 s->speaker_mode = val;
|
|
|
970 return t;
|
|
|
971 }
|
|
|
972 /*- End of function --------------------------------------------------------*/
|
|
|
973
|
|
|
974 static const char *at_cmd_O(at_state_t *s, const char *t)
|
|
|
975 {
|
|
|
976 int val;
|
|
|
977
|
|
|
978 /* V.250 6.3.7 - Return to online data state */
|
|
|
979 t += 1;
|
|
|
980 if ((val = parse_num(&t, 1)) < 0)
|
|
|
981 return NULL;
|
|
|
982 if (val == 0)
|
|
|
983 {
|
|
|
984 at_set_at_rx_mode(s, AT_MODE_CONNECTED);
|
|
|
985 at_put_response_code(s, AT_RESPONSE_CODE_CONNECT);
|
|
|
986 }
|
|
|
987 return t;
|
|
|
988 }
|
|
|
989 /*- End of function --------------------------------------------------------*/
|
|
|
990
|
|
|
991 static const char *at_cmd_P(at_state_t *s, const char *t)
|
|
|
992 {
|
|
|
993 /* V.250 6.3.3 - Select pulse dialling (command) */
|
|
|
994 t += 1;
|
|
|
995 s->p.pulse_dial = TRUE;
|
|
|
996 return t;
|
|
|
997 }
|
|
|
998 /*- End of function --------------------------------------------------------*/
|
|
|
999
|
|
|
1000 static const char *at_cmd_Q(at_state_t *s, const char *t)
|
|
|
1001 {
|
|
|
1002 int val;
|
|
|
1003
|
|
|
1004 /* V.250 6.2.5 - Result code suppression */
|
|
|
1005 t += 1;
|
|
|
1006 if ((val = parse_num(&t, 1)) < 0)
|
|
|
1007 return NULL;
|
|
|
1008 switch (val)
|
|
|
1009 {
|
|
|
1010 case 0:
|
|
|
1011 s->p.result_code_format = (s->p.verbose) ? ASCII_RESULT_CODES : NUMERIC_RESULT_CODES;
|
|
|
1012 break;
|
|
|
1013 case 1:
|
|
|
1014 s->p.result_code_format = NO_RESULT_CODES;
|
|
|
1015 break;
|
|
|
1016 }
|
|
|
1017 return t;
|
|
|
1018 }
|
|
|
1019 /*- End of function --------------------------------------------------------*/
|
|
|
1020
|
|
|
1021 static const char *at_cmd_S0(at_state_t *s, const char *t)
|
|
|
1022 {
|
|
|
1023 /* V.250 6.3.8 - Automatic answer */
|
|
|
1024 t += 2;
|
|
|
1025 return s_reg_handler(s, t, 0);
|
|
|
1026 }
|
|
|
1027 /*- End of function --------------------------------------------------------*/
|
|
|
1028
|
|
|
1029 static const char *at_cmd_S10(at_state_t *s, const char *t)
|
|
|
1030 {
|
|
|
1031 /* V.250 6.3.12 - Automatic disconnect delay */
|
|
|
1032 t += 3;
|
|
|
1033 return s_reg_handler(s, t, 10);
|
|
|
1034 }
|
|
|
1035 /*- End of function --------------------------------------------------------*/
|
|
|
1036
|
|
|
1037 static const char *at_cmd_S3(at_state_t *s, const char *t)
|
|
|
1038 {
|
|
|
1039 /* V.250 6.2.1 - Command line termination character */
|
|
|
1040 t += 2;
|
|
|
1041 return s_reg_handler(s, t, 3);
|
|
|
1042 }
|
|
|
1043 /*- End of function --------------------------------------------------------*/
|
|
|
1044
|
|
|
1045 static const char *at_cmd_S4(at_state_t *s, const char *t)
|
|
|
1046 {
|
|
|
1047 /* V.250 6.2.2 - Response formatting character */
|
|
|
1048 t += 2;
|
|
|
1049 return s_reg_handler(s, t, 4);
|
|
|
1050 }
|
|
|
1051 /*- End of function --------------------------------------------------------*/
|
|
|
1052
|
|
|
1053 static const char *at_cmd_S5(at_state_t *s, const char *t)
|
|
|
1054 {
|
|
|
1055 /* V.250 6.2.3 - Command line editing character */
|
|
|
1056 t += 2;
|
|
|
1057 return s_reg_handler(s, t, 5);
|
|
|
1058 }
|
|
|
1059 /*- End of function --------------------------------------------------------*/
|
|
|
1060
|
|
|
1061 static const char *at_cmd_S6(at_state_t *s, const char *t)
|
|
|
1062 {
|
|
|
1063 /* V.250 6.3.9 - Pause before blind dialling */
|
|
|
1064 t += 2;
|
|
|
1065 return s_reg_handler(s, t, 6);
|
|
|
1066 }
|
|
|
1067 /*- End of function --------------------------------------------------------*/
|
|
|
1068
|
|
|
1069 static const char *at_cmd_S7(at_state_t *s, const char *t)
|
|
|
1070 {
|
|
|
1071 /* V.250 6.3.10 - Connection completion timeout */
|
|
|
1072 t += 2;
|
|
|
1073 return s_reg_handler(s, t, 7);
|
|
|
1074 }
|
|
|
1075 /*- End of function --------------------------------------------------------*/
|
|
|
1076
|
|
|
1077 static const char *at_cmd_S8(at_state_t *s, const char *t)
|
|
|
1078 {
|
|
|
1079 /* V.250 6.3.11 - Comma dial modifier time */
|
|
|
1080 t += 2;
|
|
|
1081 return s_reg_handler(s, t, 8);
|
|
|
1082 }
|
|
|
1083 /*- End of function --------------------------------------------------------*/
|
|
|
1084
|
|
|
1085 static const char *at_cmd_T(at_state_t *s, const char *t)
|
|
|
1086 {
|
|
|
1087 /* V.250 6.3.2 - Select tone dialling (command) */
|
|
|
1088 t += 1;
|
|
|
1089 s->p.pulse_dial = FALSE;
|
|
|
1090 return t;
|
|
|
1091 }
|
|
|
1092 /*- End of function --------------------------------------------------------*/
|
|
|
1093
|
|
|
1094 static const char *at_cmd_V(at_state_t *s, const char *t)
|
|
|
1095 {
|
|
|
1096 int val;
|
|
|
1097
|
|
|
1098 /* V.250 6.2.6 - DCE response format */
|
|
|
1099 t += 1;
|
|
|
1100 if ((val = parse_num(&t, 1)) < 0)
|
|
|
1101 return NULL;
|
|
|
1102 s->p.verbose = val;
|
|
|
1103 if (s->p.result_code_format != NO_RESULT_CODES)
|
|
|
1104 s->p.result_code_format = (s->p.verbose) ? ASCII_RESULT_CODES : NUMERIC_RESULT_CODES;
|
|
|
1105 return t;
|
|
|
1106 }
|
|
|
1107 /*- End of function --------------------------------------------------------*/
|
|
|
1108
|
|
|
1109 static const char *at_cmd_X(at_state_t *s, const char *t)
|
|
|
1110 {
|
|
|
1111 int val;
|
|
|
1112
|
|
|
1113 /* V.250 6.2.7 - Result code selection and call progress monitoring control */
|
|
|
1114 /* 0 CONNECT result code is given upon entering online data state.
|
|
|
1115 Dial tone and busy detection are disabled.
|
|
|
1116 1 CONNECT <text> result code is given upon entering online data state.
|
|
|
1117 Dial tone and busy detection are disabled.
|
|
|
1118 2 CONNECT <text> result code is given upon entering online data state.
|
|
|
1119 Dial tone detection is enabled, and busy detection is disabled.
|
|
|
1120 3 CONNECT <text> result code is given upon entering online data state.
|
|
|
1121 Dial tone detection is disabled, and busy detection is enabled.
|
|
|
1122 4 CONNECT <text> result code is given upon entering online data state.
|
|
|
1123 Dial tone and busy detection are both enabled. */
|
|
|
1124 t += 1;
|
|
|
1125 if ((val = parse_num(&t, 4)) < 0)
|
|
|
1126 return NULL;
|
|
|
1127 s->result_code_mode = val;
|
|
|
1128 return t;
|
|
|
1129 }
|
|
|
1130 /*- End of function --------------------------------------------------------*/
|
|
|
1131
|
|
|
1132 static const char *at_cmd_Z(at_state_t *s, const char *t)
|
|
|
1133 {
|
|
|
1134 int val;
|
|
|
1135
|
|
|
1136 /* V.250 6.1.1 - Reset to default configuration */
|
|
|
1137 t += 1;
|
|
|
1138 if ((val = parse_num(&t, sizeof(profiles)/sizeof(profiles[0]) - 1)) < 0)
|
|
|
1139 return NULL;
|
|
|
1140 /* Just make sure we are on hook */
|
|
|
1141 at_modem_control(s, AT_MODEM_CONTROL_HANGUP, NULL);
|
|
|
1142 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
1143 s->p = profiles[val];
|
|
|
1144 at_reset_call_info(s);
|
|
|
1145 return t;
|
|
|
1146 }
|
|
|
1147 /*- End of function --------------------------------------------------------*/
|
|
|
1148
|
|
|
1149 static const char *at_cmd_amp_C(at_state_t *s, const char *t)
|
|
|
1150 {
|
|
|
1151 int val;
|
|
|
1152
|
|
|
1153 /* V.250 6.2.8 - Circuit 109 (received line signal detector) behaviour */
|
|
|
1154 /* We have no RLSD pin, so just absorb this. */
|
|
|
1155 t += 2;
|
|
|
1156 if ((val = parse_num(&t, 1)) < 0)
|
|
|
1157 return NULL;
|
|
|
1158 s->rlsd_behaviour = val;
|
|
|
1159 return t;
|
|
|
1160 }
|
|
|
1161 /*- End of function --------------------------------------------------------*/
|
|
|
1162
|
|
|
1163 static const char *at_cmd_amp_D(at_state_t *s, const char *t)
|
|
|
1164 {
|
|
|
1165 int val;
|
|
|
1166
|
|
|
1167 /* V.250 6.2.9 - Circuit 108 (data terminal ready) behaviour */
|
|
|
1168 t += 2;
|
|
|
1169 if ((val = parse_num(&t, 2)) < 0)
|
|
|
1170 return NULL;
|
|
|
1171 /* TODO: We have no DTR pin, but we need this to get into online
|
|
|
1172 command state. */
|
|
|
1173 s->dtr_behaviour = val;
|
|
|
1174 return t;
|
|
|
1175 }
|
|
|
1176 /*- End of function --------------------------------------------------------*/
|
|
|
1177
|
|
|
1178 static const char *at_cmd_amp_F(at_state_t *s, const char *t)
|
|
|
1179 {
|
|
|
1180 t += 2;
|
|
|
1181
|
|
|
1182 /* V.250 6.1.2 - Set to factory-defined configuration */
|
|
|
1183 /* Just make sure we are on hook */
|
|
|
1184 at_modem_control(s, AT_MODEM_CONTROL_HANGUP, NULL);
|
|
|
1185 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
1186 s->p = profiles[0];
|
|
|
1187 return t;
|
|
|
1188 }
|
|
|
1189 /*- End of function --------------------------------------------------------*/
|
|
|
1190
|
|
|
1191 static const char *at_cmd_plus_A8A(at_state_t *s, const char *t)
|
|
|
1192 {
|
|
|
1193 /* V.251 6.3 - V.8 calling tone indication */
|
|
|
1194 return t;
|
|
|
1195 }
|
|
|
1196 /*- End of function --------------------------------------------------------*/
|
|
|
1197
|
|
|
1198 static const char *at_cmd_plus_A8C(at_state_t *s, const char *t)
|
|
|
1199 {
|
|
|
1200 /* V.251 6.2 - V.8 answer signal indication */
|
|
|
1201 return t;
|
|
|
1202 }
|
|
|
1203 /*- End of function --------------------------------------------------------*/
|
|
|
1204
|
|
|
1205 static const char *at_cmd_plus_A8E(at_state_t *s, const char *t)
|
|
|
1206 {
|
|
|
1207 int val;
|
|
|
1208
|
|
|
1209 /* V.251 5.1 - V.8 and V.8bis operation controls */
|
|
|
1210 /* Syntax: +A8E=<v8o>,<v8a>,<v8cf>[,<v8b>][,<cfrange>][,<protrange>] */
|
|
|
1211 /* <v8o>=0 Disable V.8 origination negotiation
|
|
|
1212 <v8o>=1 Enable DCE-controlled V.8 origination negotiation
|
|
|
1213 <v8o>=2 Enable DTE-controlled V.8 origination negotiation, send V.8 CI only
|
|
|
1214 <v8o>=3 Enable DTE-controlled V.8 origination negotiation, send 1100Hz CNG only
|
|
|
1215 <v8o>=4 Enable DTE-controlled V.8 origination negotiation, send 1300Hz CT only
|
|
|
1216 <v8o>=5 Enable DTE-controlled V.8 origination negotiation, send no tones
|
|
|
1217 <v8o>=6 Enable DCE-controlled V.8 origination negotiation, issue +A8x indications
|
|
|
1218 <v8a>=0 Disable V.8 answer negotiation
|
|
|
1219 <v8a>=1 Enable DCE-controlled V.8 answer negotiation
|
|
|
1220 <v8a>=2 Enable DTE-controlled V.8 answer negotiation, send ANSam
|
|
|
1221 <v8a>=3 Enable DTE-controlled V.8 answer negotiation, send no signal
|
|
|
1222 <v8a>=4 Disable DTE-controlled V.8 answer negotiation, send ANS
|
|
|
1223 <v8a>=5 Enable DCE-controlled V.8 answer negotiation, issue +A8x indications
|
|
|
1224 <v8cf>=X..Y Set the V.8 CI signal call function to the hexadecimal octet value X..Y
|
|
|
1225 <v8b>=0 Disable V.8bis negotiation
|
|
|
1226 <v8b>=1 Enable DCE-controlled V.8bis negotiation
|
|
|
1227 <v8b>=2 Enable DTE-controlled V.8bis negotiation
|
|
|
1228 <cfrange>="<string of values>" Set to alternative list of call function "option bit"
|
|
|
1229 values that the answering DCE shall accept from the caller
|
|
|
1230 <protrange>="<string of values>" Set to alternative list of protocol "option bit" values that
|
|
|
1231 the answering DCE shall accept from the caller
|
|
|
1232 */
|
|
|
1233 /* TODO: */
|
|
|
1234 t += 4;
|
|
|
1235 if (!parse_out(s, &t, &val, 6, "+A8E:", "(0-6),(0-5),(00-FF)"))
|
|
|
1236 return NULL;
|
|
|
1237 if (*t != ',')
|
|
|
1238 return t;
|
|
|
1239 if ((val = parse_num(&t, 5)) < 0)
|
|
|
1240 return NULL;
|
|
|
1241 if (*t != ',')
|
|
|
1242 return t;
|
|
|
1243 return t;
|
|
|
1244 }
|
|
|
1245 /*- End of function --------------------------------------------------------*/
|
|
|
1246
|
|
|
1247 static const char *at_cmd_plus_A8I(at_state_t *s, const char *t)
|
|
|
1248 {
|
|
|
1249 /* V.251 6.1 - V.8 CI signal indication */
|
|
|
1250 return t;
|
|
|
1251 }
|
|
|
1252 /*- End of function --------------------------------------------------------*/
|
|
|
1253
|
|
|
1254 static const char *at_cmd_plus_A8J(at_state_t *s, const char *t)
|
|
|
1255 {
|
|
|
1256 /* V.251 6.4 - V.8 negotiation complete */
|
|
|
1257 return t;
|
|
|
1258 }
|
|
|
1259 /*- End of function --------------------------------------------------------*/
|
|
|
1260
|
|
|
1261 static const char *at_cmd_plus_A8M(at_state_t *s, const char *t)
|
|
|
1262 {
|
|
|
1263 /* V.251 5.2 - Send V.8 menu signals */
|
|
|
1264 /* Syntax: +A8M=<hexadecimal coded CM or JM octet string> */
|
|
|
1265 /* TODO: */
|
|
|
1266 t += 4;
|
|
|
1267 return t;
|
|
|
1268 }
|
|
|
1269 /*- End of function --------------------------------------------------------*/
|
|
|
1270
|
|
|
1271 static const char *at_cmd_plus_A8R(at_state_t *s, const char *t)
|
|
|
1272 {
|
|
|
1273 /* V.251 6.6 - V.8bis signal and message reporting */
|
|
|
1274 return t;
|
|
|
1275 }
|
|
|
1276 /*- End of function --------------------------------------------------------*/
|
|
|
1277
|
|
|
1278 static const char *at_cmd_plus_A8T(at_state_t *s, const char *t)
|
|
|
1279 {
|
|
|
1280 int val;
|
|
|
1281
|
|
|
1282 /* V.251 5.3 - Send V.8bis signal and/or message(s) */
|
|
|
1283 /* Syntax: +A8T=<signal>[,<1st message>][,<2nd message>][,<sig_en>][,<msg_en>][,<supp_delay>] */
|
|
|
1284 /* <signal>=0 None
|
|
|
1285 <signal>=1 Initiating Mre
|
|
|
1286 <signal>=2 Initiating MRd
|
|
|
1287 <signal>=3 Initiating CRe, low power
|
|
|
1288 <signal>=4 Initiating CRe, high power
|
|
|
1289 <signal>=5 Initiating CRd
|
|
|
1290 <signal>=6 Initiating Esi
|
|
|
1291 <signal>=7 Responding MRd, low power
|
|
|
1292 <signal>=8 Responding MRd, high power
|
|
|
1293 <signal>=9 Responding CRd
|
|
|
1294 <signal>=10 Responding Esr
|
|
|
1295 */
|
|
|
1296 /* TODO: */
|
|
|
1297 t += 4;
|
|
|
1298 if (!parse_out(s, &t, &val, 10, "+A8T:", "(0-10)"))
|
|
|
1299 return NULL;
|
|
|
1300 s->v8bis_signal = val;
|
|
|
1301 if (*t != ',')
|
|
|
1302 return t;
|
|
|
1303 if ((val = parse_num(&t, 255)) < 0)
|
|
|
1304 return NULL;
|
|
|
1305 s->v8bis_1st_message = val;
|
|
|
1306 if (*t != ',')
|
|
|
1307 return t;
|
|
|
1308 if ((val = parse_num(&t, 255)) < 0)
|
|
|
1309 return NULL;
|
|
|
1310 s->v8bis_2nd_message = val;
|
|
|
1311 if (*t != ',')
|
|
|
1312 return t;
|
|
|
1313 if ((val = parse_num(&t, 255)) < 0)
|
|
|
1314 return NULL;
|
|
|
1315 s->v8bis_sig_en = val;
|
|
|
1316 if (*t != ',')
|
|
|
1317 return t;
|
|
|
1318 if ((val = parse_num(&t, 255)) < 0)
|
|
|
1319 return NULL;
|
|
|
1320 s->v8bis_msg_en = val;
|
|
|
1321 if (*t != ',')
|
|
|
1322 return t;
|
|
|
1323 if ((val = parse_num(&t, 255)) < 0)
|
|
|
1324 return NULL;
|
|
|
1325 s->v8bis_supp_delay = val;
|
|
|
1326 return t;
|
|
|
1327 }
|
|
|
1328 /*- End of function --------------------------------------------------------*/
|
|
|
1329
|
|
|
1330 static const char *at_cmd_plus_ASTO(at_state_t *s, const char *t)
|
|
|
1331 {
|
|
|
1332 /* V.250 6.3.15 - Store telephone number */
|
|
|
1333 /* TODO: */
|
|
|
1334 t += 5;
|
|
|
1335 if (!parse_out(s, &t, NULL, 1, "+ASTO:", ""))
|
|
|
1336 return NULL;
|
|
|
1337 return t;
|
|
|
1338 }
|
|
|
1339 /*- End of function --------------------------------------------------------*/
|
|
|
1340
|
|
|
1341 static const char *at_cmd_plus_CAAP(at_state_t *s, const char *t)
|
|
|
1342 {
|
|
|
1343 /* 3GPP TS 27.007 7.25 - Automatic answer for eMLPP Service */
|
|
|
1344 /* TODO: */
|
|
|
1345 t += 5;
|
|
|
1346 if (!parse_2_out(s, &t, NULL, 65535, NULL, 65535, "+CAAP:", ""))
|
|
|
1347 return NULL;
|
|
|
1348 return t;
|
|
|
1349 }
|
|
|
1350 /*- End of function --------------------------------------------------------*/
|
|
|
1351
|
|
|
1352 static const char *at_cmd_plus_CACM(at_state_t *s, const char *t)
|
|
|
1353 {
|
|
|
1354 /* 3GPP TS 27.007 8.25 - Accumulated call meter */
|
|
|
1355 /* TODO: */
|
|
|
1356 t += 5;
|
|
|
1357 if (!parse_out(s, &t, NULL, 1, "+CACM:", ""))
|
|
|
1358 return NULL;
|
|
|
1359 return t;
|
|
|
1360 }
|
|
|
1361 /*- End of function --------------------------------------------------------*/
|
|
|
1362
|
|
|
1363 static const char *at_cmd_plus_CACSP(at_state_t *s, const char *t)
|
|
|
1364 {
|
|
|
1365 /* 3GPP TS 27.007 11.1.7 - Voice Group or Voice Broadcast Call State Attribute Presentation */
|
|
|
1366 /* TODO: */
|
|
|
1367 t += 6;
|
|
|
1368 if (!parse_out(s, &t, NULL, 1, "+CACSP:", ""))
|
|
|
1369 return NULL;
|
|
|
1370 return t;
|
|
|
1371 }
|
|
|
1372 /*- End of function --------------------------------------------------------*/
|
|
|
1373
|
|
|
1374 static const char *at_cmd_plus_CAD(at_state_t *s, const char *t)
|
|
|
1375 {
|
|
|
1376 /* IS-99 5.6.3 - Query analogue or digital service */
|
|
|
1377 /* TODO: */
|
|
|
1378 t += 4;
|
|
|
1379 return t;
|
|
|
1380 }
|
|
|
1381 /*- End of function --------------------------------------------------------*/
|
|
|
1382
|
|
|
1383 static const char *at_cmd_plus_CAEMLPP(at_state_t *s, const char *t)
|
|
|
1384 {
|
|
|
1385 /* 3GPP TS 27.007 7.22 - eMLPP Priority Registration and Interrogation */
|
|
|
1386 /* TODO: */
|
|
|
1387 t += 8;
|
|
|
1388 if (!parse_out(s, &t, NULL, 1, "+CAEMLPP:", ""))
|
|
|
1389 return NULL;
|
|
|
1390 return t;
|
|
|
1391 }
|
|
|
1392 /*- End of function --------------------------------------------------------*/
|
|
|
1393
|
|
|
1394 static const char *at_cmd_plus_CAHLD(at_state_t *s, const char *t)
|
|
|
1395 {
|
|
|
1396 /* 3GPP TS 27.007 11.1.3 - Leave an ongoing Voice Group or Voice Broadcast Call */
|
|
|
1397 /* TODO: */
|
|
|
1398 t += 6;
|
|
|
1399 if (!parse_out(s, &t, NULL, 1, "+CAHLD:", ""))
|
|
|
1400 return NULL;
|
|
|
1401 return t;
|
|
|
1402 }
|
|
|
1403 /*- End of function --------------------------------------------------------*/
|
|
|
1404
|
|
|
1405 static const char *at_cmd_plus_CAJOIN(at_state_t *s, const char *t)
|
|
|
1406 {
|
|
|
1407 /* 3GPP TS 27.007 11.1.1 - Accept an incoming Voice Group or Voice Broadcast Call */
|
|
|
1408 /* TODO: */
|
|
|
1409 t += 7;
|
|
|
1410 if (!parse_out(s, &t, NULL, 1, "+CAJOIN:", ""))
|
|
|
1411 return NULL;
|
|
|
1412 return t;
|
|
|
1413 }
|
|
|
1414 /*- End of function --------------------------------------------------------*/
|
|
|
1415
|
|
|
1416 static const char *at_cmd_plus_CALA(at_state_t *s, const char *t)
|
|
|
1417 {
|
|
|
1418 /* 3GPP TS 27.007 8.16 - Alarm */
|
|
|
1419 /* TODO: */
|
|
|
1420 t += 5;
|
|
|
1421 if (!parse_out(s, &t, NULL, 1, "+CALA:", ""))
|
|
|
1422 return NULL;
|
|
|
1423 return t;
|
|
|
1424 }
|
|
|
1425 /*- End of function --------------------------------------------------------*/
|
|
|
1426
|
|
|
1427 static const char *at_cmd_plus_CALCC(at_state_t *s, const char *t)
|
|
|
1428 {
|
|
|
1429 /* 3GPP TS 27.007 11.1.6 - List current Voice Group and Voice Broadcast Calls */
|
|
|
1430 /* TODO: */
|
|
|
1431 t += 6;
|
|
|
1432 if (!parse_out(s, &t, NULL, 1, "+CALCC:", ""))
|
|
|
1433 return NULL;
|
|
|
1434 return t;
|
|
|
1435 }
|
|
|
1436 /*- End of function --------------------------------------------------------*/
|
|
|
1437
|
|
|
1438 static const char *at_cmd_plus_CALD(at_state_t *s, const char *t)
|
|
|
1439 {
|
|
|
1440 /* 3GPP TS 27.007 8.38 - Delete alarm */
|
|
|
1441 /* TODO: */
|
|
|
1442 t += 5;
|
|
|
1443 if (!parse_out(s, &t, NULL, 1, "+CALD:", ""))
|
|
|
1444 return NULL;
|
|
|
1445 return t;
|
|
|
1446 }
|
|
|
1447 /*- End of function --------------------------------------------------------*/
|
|
|
1448
|
|
|
1449 static const char *at_cmd_plus_CALM(at_state_t *s, const char *t)
|
|
|
1450 {
|
|
|
1451 /* 3GPP TS 27.007 8.20 - Alert sound mode */
|
|
|
1452 /* TODO: */
|
|
|
1453 t += 5;
|
|
|
1454 if (!parse_out(s, &t, NULL, 1, "+CALM:", ""))
|
|
|
1455 return NULL;
|
|
|
1456 return t;
|
|
|
1457 }
|
|
|
1458 /*- End of function --------------------------------------------------------*/
|
|
|
1459
|
|
|
1460 static const char *at_cmd_plus_CAMM(at_state_t *s, const char *t)
|
|
|
1461 {
|
|
|
1462 /* 3GPP TS 27.007 8.26 - Accumulated call meter maximum */
|
|
|
1463 /* TODO: */
|
|
|
1464 t += 5;
|
|
|
1465 if (!parse_out(s, &t, NULL, 1, "+CAMM:", ""))
|
|
|
1466 return NULL;
|
|
|
1467 return t;
|
|
|
1468 }
|
|
|
1469 /*- End of function --------------------------------------------------------*/
|
|
|
1470
|
|
|
1471 static const char *at_cmd_plus_CANCHEV(at_state_t *s, const char *t)
|
|
|
1472 {
|
|
|
1473 /* 3GPP TS 27.007 11.1.8 - NCH Support Indication */
|
|
|
1474 /* TODO: */
|
|
|
1475 t += 8;
|
|
|
1476 if (!parse_out(s, &t, NULL, 1, "+CANCHEV:", ""))
|
|
|
1477 return NULL;
|
|
|
1478 return t;
|
|
|
1479 }
|
|
|
1480 /*- End of function --------------------------------------------------------*/
|
|
|
1481
|
|
|
1482 static const char *at_cmd_plus_CAOC(at_state_t *s, const char *t)
|
|
|
1483 {
|
|
|
1484 /* 3GPP TS 27.007 7.16 - Advice of Charge */
|
|
|
1485 /* TODO: */
|
|
|
1486 t += 5;
|
|
|
1487 if (!parse_out(s, &t, NULL, 1, "+CAOC:", ""))
|
|
|
1488 return NULL;
|
|
|
1489 return t;
|
|
|
1490 }
|
|
|
1491 /*- End of function --------------------------------------------------------*/
|
|
|
1492
|
|
|
1493 static const char *at_cmd_plus_CAPD(at_state_t *s, const char *t)
|
|
|
1494 {
|
|
|
1495 /* 3GPP TS 27.007 8.39 - Postpone or dismiss an alarm */
|
|
|
1496 /* TODO: */
|
|
|
1497 t += 5;
|
|
|
1498 if (!parse_out(s, &t, NULL, 1, "+CAPD:", ""))
|
|
|
1499 return NULL;
|
|
|
1500 return t;
|
|
|
1501 }
|
|
|
1502 /*- End of function --------------------------------------------------------*/
|
|
|
1503
|
|
|
1504 static const char *at_cmd_plus_CAPTT(at_state_t *s, const char *t)
|
|
|
1505 {
|
|
|
1506 /* 3GPP TS 27.007 11.1.4 - Talker Access for Voice Group Call */
|
|
|
1507 /* TODO: */
|
|
|
1508 t += 6;
|
|
|
1509 if (!parse_out(s, &t, NULL, 1, "+CAPTT:", ""))
|
|
|
1510 return NULL;
|
|
|
1511 return t;
|
|
|
1512 }
|
|
|
1513 /*- End of function --------------------------------------------------------*/
|
|
|
1514
|
|
|
1515 static const char *at_cmd_plus_CAREJ(at_state_t *s, const char *t)
|
|
|
1516 {
|
|
|
1517 /* 3GPP TS 27.007 11.1.2 - Reject an incoming Voice Group or Voice Broadcast Call */
|
|
|
1518 /* TODO: */
|
|
|
1519 t += 6;
|
|
|
1520 if (!parse_out(s, &t, NULL, 1, "+CAREJ:", ""))
|
|
|
1521 return NULL;
|
|
|
1522 return t;
|
|
|
1523 }
|
|
|
1524 /*- End of function --------------------------------------------------------*/
|
|
|
1525
|
|
|
1526 static const char *at_cmd_plus_CAULEV(at_state_t *s, const char *t)
|
|
|
1527 {
|
|
|
1528 /* 3GPP TS 27.007 11.1.5 - Voice Group Call Uplink Status Presentation */
|
|
|
1529 /* TODO: */
|
|
|
1530 t += 7;
|
|
|
1531 if (!parse_out(s, &t, NULL, 1, "+CAULEV:", ""))
|
|
|
1532 return NULL;
|
|
|
1533 return t;
|
|
|
1534 }
|
|
|
1535 /*- End of function --------------------------------------------------------*/
|
|
|
1536
|
|
|
1537 static const char *at_cmd_plus_CBC(at_state_t *s, const char *t)
|
|
|
1538 {
|
|
|
1539 /* 3GPP TS 27.007 8.4 - Battery charge */
|
|
|
1540 /* TODO: */
|
|
|
1541 t += 4;
|
|
|
1542 if (!parse_out(s, &t, NULL, 1, "+CBC:", ""))
|
|
|
1543 return NULL;
|
|
|
1544 return t;
|
|
|
1545 }
|
|
|
1546 /*- End of function --------------------------------------------------------*/
|
|
|
1547
|
|
|
1548 static const char *at_cmd_plus_CBCS(at_state_t *s, const char *t)
|
|
|
1549 {
|
|
|
1550 /* 3GPP TS 27.007 11.3.2 - VBS subscriptions and GId status */
|
|
|
1551 /* TODO: */
|
|
|
1552 t += 5;
|
|
|
1553 if (!parse_out(s, &t, NULL, 1, "+CBCS:", ""))
|
|
|
1554 return NULL;
|
|
|
1555 return t;
|
|
|
1556 }
|
|
|
1557 /*- End of function --------------------------------------------------------*/
|
|
|
1558
|
|
|
1559 static const char *at_cmd_plus_CBIP(at_state_t *s, const char *t)
|
|
|
1560 {
|
|
|
1561 /* IS-99 5.6 - Base station IP address */
|
|
|
1562 /* TODO: */
|
|
|
1563 t += 5;
|
|
|
1564 return t;
|
|
|
1565 }
|
|
|
1566 /*- End of function --------------------------------------------------------*/
|
|
|
1567
|
|
|
1568 static const char *at_cmd_plus_CBST(at_state_t *s, const char *t)
|
|
|
1569 {
|
|
|
1570 /* 3GPP TS 27.007 6.7 - Select bearer service type */
|
|
|
1571 /* TODO: */
|
|
|
1572 t += 5;
|
|
|
1573 if (!parse_out(s, &t, NULL, 1, "+CBST:", ""))
|
|
|
1574 return NULL;
|
|
|
1575 return t;
|
|
|
1576 }
|
|
|
1577 /*- End of function --------------------------------------------------------*/
|
|
|
1578
|
|
|
1579 static const char *at_cmd_plus_CCFC(at_state_t *s, const char *t)
|
|
|
1580 {
|
|
|
1581 /* 3GPP TS 27.007 7.11 - Call forwarding number and conditions */
|
|
|
1582 /* TODO: */
|
|
|
1583 t += 5;
|
|
|
1584 if (!parse_out(s, &t, NULL, 1, "+CCFC:", ""))
|
|
|
1585 return NULL;
|
|
|
1586 return t;
|
|
|
1587 }
|
|
|
1588 /*- End of function --------------------------------------------------------*/
|
|
|
1589
|
|
|
1590 static const char *at_cmd_plus_CCLK(at_state_t *s, const char *t)
|
|
|
1591 {
|
|
|
1592 /* 3GPP TS 27.007 8.15 - Clock */
|
|
|
1593 /* TODO: */
|
|
|
1594 t += 5;
|
|
|
1595 if (!parse_out(s, &t, NULL, 1, "+CCLK:", ""))
|
|
|
1596 return NULL;
|
|
|
1597 return t;
|
|
|
1598 }
|
|
|
1599 /*- End of function --------------------------------------------------------*/
|
|
|
1600
|
|
|
1601 static const char *at_cmd_plus_CCS(at_state_t *s, const char *t)
|
|
|
1602 {
|
|
|
1603 /* IS-135 4.1.22 - Compression status */
|
|
|
1604 /* TODO: */
|
|
|
1605 t += 4;
|
|
|
1606 return t;
|
|
|
1607 }
|
|
|
1608 /*- End of function --------------------------------------------------------*/
|
|
|
1609
|
|
|
1610 static const char *at_cmd_plus_CCUG(at_state_t *s, const char *t)
|
|
|
1611 {
|
|
|
1612 /* 3GPP TS 27.007 7.10 - Closed user group */
|
|
|
1613 /* TODO: */
|
|
|
1614 t += 5;
|
|
|
1615 if (!parse_out(s, &t, NULL, 1, "+CCUG:", ""))
|
|
|
1616 return NULL;
|
|
|
1617 return t;
|
|
|
1618 }
|
|
|
1619 /*- End of function --------------------------------------------------------*/
|
|
|
1620
|
|
|
1621 static const char *at_cmd_plus_CCWA(at_state_t *s, const char *t)
|
|
|
1622 {
|
|
|
1623 /* 3GPP TS 27.007 7.12 - Call waiting */
|
|
|
1624 /* TODO: */
|
|
|
1625 t += 5;
|
|
|
1626 if (!parse_out(s, &t, NULL, 1, "+CCWA:", ""))
|
|
|
1627 return NULL;
|
|
|
1628 return t;
|
|
|
1629 }
|
|
|
1630 /*- End of function --------------------------------------------------------*/
|
|
|
1631
|
|
|
1632 static const char *at_cmd_plus_CCWE(at_state_t *s, const char *t)
|
|
|
1633 {
|
|
|
1634 /* 3GPP TS 27.007 8.28 - Call Meter maximum event */
|
|
|
1635 /* TODO: */
|
|
|
1636 t += 5;
|
|
|
1637 if (!parse_out(s, &t, NULL, 1, "+CCWE:", ""))
|
|
|
1638 return NULL;
|
|
|
1639 return t;
|
|
|
1640 }
|
|
|
1641 /*- End of function --------------------------------------------------------*/
|
|
|
1642
|
|
|
1643 static const char *at_cmd_plus_CDIP(at_state_t *s, const char *t)
|
|
|
1644 {
|
|
|
1645 /* 3GPP TS 27.007 7.9 - Called line identification presentation */
|
|
|
1646 /* TODO: */
|
|
|
1647 t += 5;
|
|
|
1648 if (!parse_out(s, &t, NULL, 1, "+CDIP:", ""))
|
|
|
1649 return NULL;
|
|
|
1650 return t;
|
|
|
1651 }
|
|
|
1652 /*- End of function --------------------------------------------------------*/
|
|
|
1653
|
|
|
1654 static const char *at_cmd_plus_CDIS(at_state_t *s, const char *t)
|
|
|
1655 {
|
|
|
1656 /* 3GPP TS 27.007 8.8 - Display control */
|
|
|
1657 /* TODO: */
|
|
|
1658 t += 5;
|
|
|
1659 if (!parse_out(s, &t, NULL, 1, "+CDIS:", ""))
|
|
|
1660 return NULL;
|
|
|
1661 return t;
|
|
|
1662 }
|
|
|
1663 /*- End of function --------------------------------------------------------*/
|
|
|
1664
|
|
|
1665 static const char *at_cmd_plus_CDV(at_state_t *s, const char *t)
|
|
|
1666 {
|
|
|
1667 /* IS-99 5.6 - Dial command for voice call */
|
|
|
1668 /* TODO: */
|
|
|
1669 t += 4;
|
|
|
1670 return t;
|
|
|
1671 }
|
|
|
1672 /*- End of function --------------------------------------------------------*/
|
|
|
1673
|
|
|
1674 static const char *at_cmd_plus_CEER(at_state_t *s, const char *t)
|
|
|
1675 {
|
|
|
1676 /* 3GPP TS 27.007 6.10 - Extended error report */
|
|
|
1677 /* TODO: */
|
|
|
1678 t += 5;
|
|
|
1679 if (!parse_out(s, &t, NULL, 1, "+CEER:", ""))
|
|
|
1680 return NULL;
|
|
|
1681 return t;
|
|
|
1682 }
|
|
|
1683 /*- End of function --------------------------------------------------------*/
|
|
|
1684
|
|
|
1685 static const char *at_cmd_plus_CESP(at_state_t *s, const char *t)
|
|
|
1686 {
|
|
|
1687 /* GSM07.05 3.2.4 - Enter SMS block mode protocol */
|
|
|
1688 /* TODO: */
|
|
|
1689 t += 5;
|
|
|
1690 return t;
|
|
|
1691 }
|
|
|
1692 /*- End of function --------------------------------------------------------*/
|
|
|
1693
|
|
|
1694 static const char *at_cmd_plus_CFCS(at_state_t *s, const char *t)
|
|
|
1695 {
|
|
|
1696 /* 3GPP TS 27.007 7.24 - Fast call setup conditions */
|
|
|
1697 /* TODO: */
|
|
|
1698 t += 5;
|
|
|
1699 if (!parse_out(s, &t, NULL, 1, "+CFCS:", ""))
|
|
|
1700 return NULL;
|
|
|
1701 return t;
|
|
|
1702 }
|
|
|
1703 /*- End of function --------------------------------------------------------*/
|
|
|
1704
|
|
|
1705 static const char *at_cmd_plus_CFG(at_state_t *s, const char *t)
|
|
|
1706 {
|
|
|
1707 /* IS-99 5.6 - Configuration string */
|
|
|
1708 /* TODO: */
|
|
|
1709 t += 4;
|
|
|
1710 return t;
|
|
|
1711 }
|
|
|
1712 /*- End of function --------------------------------------------------------*/
|
|
|
1713
|
|
|
1714 static const char *at_cmd_plus_CFUN(at_state_t *s, const char *t)
|
|
|
1715 {
|
|
|
1716 /* 3GPP TS 27.007 8.2 - Set phone functionality */
|
|
|
1717 /* TODO: */
|
|
|
1718 t += 5;
|
|
|
1719 if (!parse_out(s, &t, NULL, 1, "+CFUN:", ""))
|
|
|
1720 return NULL;
|
|
|
1721 return t;
|
|
|
1722 }
|
|
|
1723 /*- End of function --------------------------------------------------------*/
|
|
|
1724
|
|
|
1725 static const char *at_cmd_plus_CGACT(at_state_t *s, const char *t)
|
|
|
1726 {
|
|
|
1727 /* 3GPP TS 27.007 10.1.10 - PDP context activate or deactivate */
|
|
|
1728 /* TODO: */
|
|
|
1729 t += 6;
|
|
|
1730 if (!parse_out(s, &t, NULL, 1, "+CGACT:", ""))
|
|
|
1731 return NULL;
|
|
|
1732 return t;
|
|
|
1733 }
|
|
|
1734 /*- End of function --------------------------------------------------------*/
|
|
|
1735
|
|
|
1736 static const char *at_cmd_plus_CGANS(at_state_t *s, const char *t)
|
|
|
1737 {
|
|
|
1738 /* 3GPP TS 27.007 10.1.16 - Manual response to a network request for PDP context activation */
|
|
|
1739 /* TODO: */
|
|
|
1740 t += 6;
|
|
|
1741 if (!parse_out(s, &t, NULL, 1, "+CGANS:", ""))
|
|
|
1742 return NULL;
|
|
|
1743 return t;
|
|
|
1744 }
|
|
|
1745 /*- End of function --------------------------------------------------------*/
|
|
|
1746
|
|
|
1747 static const char *at_cmd_plus_CGATT(at_state_t *s, const char *t)
|
|
|
1748 {
|
|
|
1749 /* 3GPP TS 27.007 10.1.9 - PS attach or detach */
|
|
|
1750 /* TODO: */
|
|
|
1751 t += 6;
|
|
|
1752 if (!parse_out(s, &t, NULL, 1, "+CGATT:", ""))
|
|
|
1753 return NULL;
|
|
|
1754 return t;
|
|
|
1755 }
|
|
|
1756 /*- End of function --------------------------------------------------------*/
|
|
|
1757
|
|
|
1758 static const char *at_cmd_plus_CGAUTO(at_state_t *s, const char *t)
|
|
|
1759 {
|
|
|
1760 /* 3GPP TS 27.007 10.1.15 - Automatic response to a network request for PDP context activation */
|
|
|
1761 /* TODO: */
|
|
|
1762 t += 7;
|
|
|
1763 if (!parse_out(s, &t, NULL, 1, "+CGAUTO:", ""))
|
|
|
1764 return NULL;
|
|
|
1765 return t;
|
|
|
1766 }
|
|
|
1767 /*- End of function --------------------------------------------------------*/
|
|
|
1768
|
|
|
1769 static const char *at_cmd_plus_CGCAP(at_state_t *s, const char *t)
|
|
|
1770 {
|
|
|
1771 /* IS-99 5.6 - Request complete capabilities list */
|
|
|
1772 /* TODO: */
|
|
|
1773 t += 6;
|
|
|
1774 return t;
|
|
|
1775 }
|
|
|
1776 /*- End of function --------------------------------------------------------*/
|
|
|
1777
|
|
|
1778 static const char *at_cmd_plus_CGCLASS(at_state_t *s, const char *t)
|
|
|
1779 {
|
|
|
1780 /* 3GPP TS 27.007 10.1.17 - GPRS mobile station class (GPRS only) */
|
|
|
1781 /* TODO: */
|
|
|
1782 t += 8;
|
|
|
1783 if (!parse_out(s, &t, NULL, 1, "+CGCLASS:", ""))
|
|
|
1784 return NULL;
|
|
|
1785 return t;
|
|
|
1786 }
|
|
|
1787 /*- End of function --------------------------------------------------------*/
|
|
|
1788
|
|
|
1789 static const char *at_cmd_plus_CGCLOSP(at_state_t *s, const char *t)
|
|
|
1790 {
|
|
|
1791 /* 3GPP TS 27.007 10.1.13 - Configure local Octet Stream PAD parameters (Obsolete) */
|
|
|
1792 /* TODO: */
|
|
|
1793 t += 8;
|
|
|
1794 if (!parse_out(s, &t, NULL, 1, "+CGCLOSP:", ""))
|
|
|
1795 return NULL;
|
|
|
1796 return t;
|
|
|
1797 }
|
|
|
1798 /*- End of function --------------------------------------------------------*/
|
|
|
1799
|
|
|
1800 static const char *at_cmd_plus_CGCLPAD(at_state_t *s, const char *t)
|
|
|
1801 {
|
|
|
1802 /* 3GPP TS 27.007 10.1.12 - Configure local triple-X PAD parameters (GPRS only) (Obsolete) */
|
|
|
1803 /* TODO: */
|
|
|
1804 t += 8;
|
|
|
1805 if (!parse_out(s, &t, NULL, 1, "+CGCLPAD:", ""))
|
|
|
1806 return NULL;
|
|
|
1807 return t;
|
|
|
1808 }
|
|
|
1809 /*- End of function --------------------------------------------------------*/
|
|
|
1810
|
|
|
1811 static const char *at_cmd_plus_CGCMOD(at_state_t *s, const char *t)
|
|
|
1812 {
|
|
|
1813 /* 3GPP TS 27.007 10.1.11 - PDP Context Modify */
|
|
|
1814 /* TODO: */
|
|
|
1815 t += 7;
|
|
|
1816 if (!parse_out(s, &t, NULL, 1, "+CGCMOD:", ""))
|
|
|
1817 return NULL;
|
|
|
1818 return t;
|
|
|
1819 }
|
|
|
1820 /*- End of function --------------------------------------------------------*/
|
|
|
1821
|
|
|
1822 static const char *at_cmd_plus_CGCS(at_state_t *s, const char *t)
|
|
|
1823 {
|
|
|
1824 /* 3GPP TS 27.007 11.3.1 - VGCS subscriptions and GId status */
|
|
|
1825 /* TODO: */
|
|
|
1826 t += 5;
|
|
|
1827 if (!parse_out(s, &t, NULL, 1, "+CGCS:", ""))
|
|
|
1828 return NULL;
|
|
|
1829 return t;
|
|
|
1830 }
|
|
|
1831 /*- End of function --------------------------------------------------------*/
|
|
|
1832
|
|
|
1833 static const char *at_cmd_plus_CGDATA(at_state_t *s, const char *t)
|
|
|
1834 {
|
|
|
1835 /* 3GPP TS 27.007 10.1.12 - Enter data state */
|
|
|
1836 /* TODO: */
|
|
|
1837 t += 7;
|
|
|
1838 if (!parse_out(s, &t, NULL, 1, "+CGDATA:", ""))
|
|
|
1839 return NULL;
|
|
|
1840 return t;
|
|
|
1841 }
|
|
|
1842 /*- End of function --------------------------------------------------------*/
|
|
|
1843
|
|
|
1844 static const char *at_cmd_plus_CGDCONT(at_state_t *s, const char *t)
|
|
|
1845 {
|
|
|
1846 /* 3GPP TS 27.007 10.1.1 - Define PDP Context */
|
|
|
1847 /* TODO: */
|
|
|
1848 t += 8;
|
|
|
1849 if (!parse_out(s, &t, NULL, 1, "+CGDCONT:", ""))
|
|
|
1850 return NULL;
|
|
|
1851 return t;
|
|
|
1852 }
|
|
|
1853 /*- End of function --------------------------------------------------------*/
|
|
|
1854
|
|
|
1855 static const char *at_cmd_plus_CGDSCONT(at_state_t *s, const char *t)
|
|
|
1856 {
|
|
|
1857 /* 3GPP TS 27.007 10.1.2 - Define Secondary PDP Context */
|
|
|
1858 /* TODO: */
|
|
|
1859 t += 9;
|
|
|
1860 if (!parse_out(s, &t, NULL, 1, "+CGDSCONT:", ""))
|
|
|
1861 return NULL;
|
|
|
1862 return t;
|
|
|
1863 }
|
|
|
1864 /*- End of function --------------------------------------------------------*/
|
|
|
1865
|
|
|
1866 static const char *at_cmd_plus_CGEQMIN(at_state_t *s, const char *t)
|
|
|
1867 {
|
|
|
1868 /* 3GPP TS 27.007 10.1.7 - 3G Quality of Service Profile (Minimum acceptable) */
|
|
|
1869 /* TODO: */
|
|
|
1870 t += 8;
|
|
|
1871 if (!parse_out(s, &t, NULL, 1, "+CGEQMIN:", ""))
|
|
|
1872 return NULL;
|
|
|
1873 return t;
|
|
|
1874 }
|
|
|
1875 /*- End of function --------------------------------------------------------*/
|
|
|
1876
|
|
|
1877 static const char *at_cmd_plus_CGEQNEG(at_state_t *s, const char *t)
|
|
|
1878 {
|
|
|
1879 /* 3GPP TS 27.007 10.1.8 - 3G Quality of Service Profile (Negotiated) */
|
|
|
1880 /* TODO: */
|
|
|
1881 t += 8;
|
|
|
1882 if (!parse_out(s, &t, NULL, 1, "+CGEQNEG:", ""))
|
|
|
1883 return NULL;
|
|
|
1884 return t;
|
|
|
1885 }
|
|
|
1886 /*- End of function --------------------------------------------------------*/
|
|
|
1887
|
|
|
1888 static const char *at_cmd_plus_CGEQREQ(at_state_t *s, const char *t)
|
|
|
1889 {
|
|
|
1890 /* 3GPP TS 27.007 10.1.6 - 3G Quality of Service Profile (Requested) */
|
|
|
1891 /* TODO: */
|
|
|
1892 t += 8;
|
|
|
1893 if (!parse_out(s, &t, NULL, 1, "+CGEQREQ:", ""))
|
|
|
1894 return NULL;
|
|
|
1895 return t;
|
|
|
1896 }
|
|
|
1897 /*- End of function --------------------------------------------------------*/
|
|
|
1898
|
|
|
1899 static const char *at_cmd_plus_CGEREP(at_state_t *s, const char *t)
|
|
|
1900 {
|
|
|
1901 /* 3GPP TS 27.007 10.1.18 - Packet Domain event reporting */
|
|
|
1902 /* TODO: */
|
|
|
1903 t += 7;
|
|
|
1904 if (!parse_out(s, &t, NULL, 1, "+CGEREP:", ""))
|
|
|
1905 return NULL;
|
|
|
1906 return t;
|
|
|
1907 }
|
|
|
1908 /*- End of function --------------------------------------------------------*/
|
|
|
1909
|
|
|
1910 static const char *at_cmd_plus_CGMI(at_state_t *s, const char *t)
|
|
|
1911 {
|
|
|
1912 /* 3GPP TS 27.007 5.1 - Request manufacturer identification */
|
|
|
1913 /* TODO: */
|
|
|
1914 t += 5;
|
|
|
1915 if (!parse_out(s, &t, NULL, 1, "+CGMI:", ""))
|
|
|
1916 return NULL;
|
|
|
1917 return t;
|
|
|
1918 }
|
|
|
1919 /*- End of function --------------------------------------------------------*/
|
|
|
1920
|
|
|
1921 static const char *at_cmd_plus_CGMM(at_state_t *s, const char *t)
|
|
|
1922 {
|
|
|
1923 /* 3GPP TS 27.007 5.2 - Request model identification */
|
|
|
1924 /* TODO: */
|
|
|
1925 t += 5;
|
|
|
1926 if (!parse_out(s, &t, NULL, 1, "+CGMM:", ""))
|
|
|
1927 return NULL;
|
|
|
1928 return t;
|
|
|
1929 }
|
|
|
1930 /*- End of function --------------------------------------------------------*/
|
|
|
1931
|
|
|
1932 static const char *at_cmd_plus_CGMR(at_state_t *s, const char *t)
|
|
|
1933 {
|
|
|
1934 /* 3GPP TS 27.007 5.3 - Request revision identification */
|
|
|
1935 /* TODO: */
|
|
|
1936 t += 5;
|
|
|
1937 if (!parse_out(s, &t, NULL, 1, "+CGMR:", ""))
|
|
|
1938 return NULL;
|
|
|
1939 return t;
|
|
|
1940 }
|
|
|
1941 /*- End of function --------------------------------------------------------*/
|
|
|
1942
|
|
|
1943 static const char *at_cmd_plus_CGOI(at_state_t *s, const char *t)
|
|
|
1944 {
|
|
|
1945 /* IS-99 5.6 - Request global object identification */
|
|
|
1946 /* TODO: */
|
|
|
1947 t += 5;
|
|
|
1948 return t;
|
|
|
1949 }
|
|
|
1950 /*- End of function --------------------------------------------------------*/
|
|
|
1951
|
|
|
1952 static const char *at_cmd_plus_CGPADDR(at_state_t *s, const char *t)
|
|
|
1953 {
|
|
|
1954 /* 3GPP TS 27.007 10.1.14 - Show PDP address */
|
|
|
1955 /* TODO: */
|
|
|
1956 t += 8;
|
|
|
1957 if (!parse_out(s, &t, NULL, 1, "+CGPADDR:", ""))
|
|
|
1958 return NULL;
|
|
|
1959 return t;
|
|
|
1960 }
|
|
|
1961 /*- End of function --------------------------------------------------------*/
|
|
|
1962
|
|
|
1963 static const char *at_cmd_plus_CGQMIN(at_state_t *s, const char *t)
|
|
|
1964 {
|
|
|
1965 /* 3GPP TS 27.007 10.1.5 - Quality of Service Profile (Minimum acceptable) */
|
|
|
1966 /* TODO: */
|
|
|
1967 t += 7;
|
|
|
1968 if (!parse_out(s, &t, NULL, 1, "+CGQMIN:", ""))
|
|
|
1969 return NULL;
|
|
|
1970 return t;
|
|
|
1971 }
|
|
|
1972 /*- End of function --------------------------------------------------------*/
|
|
|
1973
|
|
|
1974 static const char *at_cmd_plus_CGQREQ(at_state_t *s, const char *t)
|
|
|
1975 {
|
|
|
1976 /* 3GPP TS 27.007 10.1.4 - Quality of Service Profile (Requested) */
|
|
|
1977 /* TODO: */
|
|
|
1978 t += 7;
|
|
|
1979 if (!parse_out(s, &t, NULL, 1, "+CGQREQ:", ""))
|
|
|
1980 return NULL;
|
|
|
1981 return t;
|
|
|
1982 }
|
|
|
1983 /*- End of function --------------------------------------------------------*/
|
|
|
1984
|
|
|
1985 static const char *at_cmd_plus_CGREG(at_state_t *s, const char *t)
|
|
|
1986 {
|
|
|
1987 /* 3GPP TS 27.007 10.1.19 - GPRS network registration status */
|
|
|
1988 /* TODO: */
|
|
|
1989 t += 6;
|
|
|
1990 if (!parse_out(s, &t, NULL, 1, "+CGREG:", ""))
|
|
|
1991 return NULL;
|
|
|
1992 return t;
|
|
|
1993 }
|
|
|
1994 /*- End of function --------------------------------------------------------*/
|
|
|
1995
|
|
|
1996 static const char *at_cmd_plus_CGSMS(at_state_t *s, const char *t)
|
|
|
1997 {
|
|
|
1998 /* 3GPP TS 27.007 10.1.20 - Select service for MO SMS messages */
|
|
|
1999 /* TODO: */
|
|
|
2000 t += 6;
|
|
|
2001 if (!parse_out(s, &t, NULL, 1, "+CGSMS:", ""))
|
|
|
2002 return NULL;
|
|
|
2003 return t;
|
|
|
2004 }
|
|
|
2005 /*- End of function --------------------------------------------------------*/
|
|
|
2006
|
|
|
2007 static const char *at_cmd_plus_CGSN(at_state_t *s, const char *t)
|
|
|
2008 {
|
|
|
2009 /* 3GPP TS 27.007 5.4 - Request product serial number identification */
|
|
|
2010 /* TODO: */
|
|
|
2011 t += 5;
|
|
|
2012 if (!parse_out(s, &t, NULL, 1, "+CGSN:", ""))
|
|
|
2013 return NULL;
|
|
|
2014 return t;
|
|
|
2015 }
|
|
|
2016 /*- End of function --------------------------------------------------------*/
|
|
|
2017
|
|
|
2018 static const char *at_cmd_plus_CGTFT(at_state_t *s, const char *t)
|
|
|
2019 {
|
|
|
2020 /* 3GPP TS 27.007 10.1.3 - Traffic Flow Template */
|
|
|
2021 /* TODO: */
|
|
|
2022 t += 6;
|
|
|
2023 if (!parse_out(s, &t, NULL, 1, "+CGTFT:", ""))
|
|
|
2024 return NULL;
|
|
|
2025 return t;
|
|
|
2026 }
|
|
|
2027 /*- End of function --------------------------------------------------------*/
|
|
|
2028
|
|
|
2029 static const char *at_cmd_plus_CHLD(at_state_t *s, const char *t)
|
|
|
2030 {
|
|
|
2031 /* 3GPP TS 27.007 7.13 - Call related supplementary services */
|
|
|
2032 /* TODO: */
|
|
|
2033 t += 5;
|
|
|
2034 if (!parse_out(s, &t, NULL, 1, "+CHLD:", ""))
|
|
|
2035 return NULL;
|
|
|
2036 return t;
|
|
|
2037 }
|
|
|
2038 /*- End of function --------------------------------------------------------*/
|
|
|
2039
|
|
|
2040 static const char *at_cmd_plus_CHSA(at_state_t *s, const char *t)
|
|
|
2041 {
|
|
|
2042 /* 3GPP TS 27.007 6.18 - HSCSD non-transparent asymmetry configuration */
|
|
|
2043 /* TODO: */
|
|
|
2044 t += 5;
|
|
|
2045 if (!parse_out(s, &t, NULL, 1, "+CHSA:", ""))
|
|
|
2046 return NULL;
|
|
|
2047 return t;
|
|
|
2048 }
|
|
|
2049 /*- End of function --------------------------------------------------------*/
|
|
|
2050
|
|
|
2051 static const char *at_cmd_plus_CHSC(at_state_t *s, const char *t)
|
|
|
2052 {
|
|
|
2053 /* 3GPP TS 27.007 6.15 - HSCSD current call parameters */
|
|
|
2054 /* TODO: */
|
|
|
2055 t += 5;
|
|
|
2056 if (!parse_out(s, &t, NULL, 1, "+CHSC:", ""))
|
|
|
2057 return NULL;
|
|
|
2058 return t;
|
|
|
2059 }
|
|
|
2060 /*- End of function --------------------------------------------------------*/
|
|
|
2061
|
|
|
2062 static const char *at_cmd_plus_CHSD(at_state_t *s, const char *t)
|
|
|
2063 {
|
|
|
2064 /* 3GPP TS 27.007 6.12 - HSCSD device parameters */
|
|
|
2065 /* TODO: */
|
|
|
2066 t += 5;
|
|
|
2067 if (!parse_out(s, &t, NULL, 1, "+CHSD:", ""))
|
|
|
2068 return NULL;
|
|
|
2069 return t;
|
|
|
2070 }
|
|
|
2071 /*- End of function --------------------------------------------------------*/
|
|
|
2072
|
|
|
2073 static const char *at_cmd_plus_CHSN(at_state_t *s, const char *t)
|
|
|
2074 {
|
|
|
2075 /* 3GPP TS 27.007 6.14 - HSCSD non-transparent call configuration */
|
|
|
2076 /* TODO: */
|
|
|
2077 t += 5;
|
|
|
2078 if (!parse_out(s, &t, NULL, 1, "+CHSN:", ""))
|
|
|
2079 return NULL;
|
|
|
2080 return t;
|
|
|
2081 }
|
|
|
2082 /*- End of function --------------------------------------------------------*/
|
|
|
2083
|
|
|
2084 static const char *at_cmd_plus_CHSR(at_state_t *s, const char *t)
|
|
|
2085 {
|
|
|
2086 /* 3GPP TS 27.007 6.16 - HSCSD parameters report */
|
|
|
2087 /* TODO: */
|
|
|
2088 t += 5;
|
|
|
2089 if (!parse_out(s, &t, NULL, 1, "+CHSR:", ""))
|
|
|
2090 return NULL;
|
|
|
2091 return t;
|
|
|
2092 }
|
|
|
2093 /*- End of function --------------------------------------------------------*/
|
|
|
2094
|
|
|
2095 static const char *at_cmd_plus_CHST(at_state_t *s, const char *t)
|
|
|
2096 {
|
|
|
2097 /* 3GPP TS 27.007 6.13 - HSCSD transparent call configuration */
|
|
|
2098 /* TODO: */
|
|
|
2099 t += 5;
|
|
|
2100 if (!parse_out(s, &t, NULL, 1, "+CHST:", ""))
|
|
|
2101 return NULL;
|
|
|
2102 return t;
|
|
|
2103 }
|
|
|
2104 /*- End of function --------------------------------------------------------*/
|
|
|
2105
|
|
|
2106 static const char *at_cmd_plus_CHSU(at_state_t *s, const char *t)
|
|
|
2107 {
|
|
|
2108 /* 3GPP TS 27.007 6.17 - HSCSD automatic user initiated upgrading */
|
|
|
2109 /* TODO: */
|
|
|
2110 t += 5;
|
|
|
2111 if (!parse_out(s, &t, NULL, 1, "+CHSU:", ""))
|
|
|
2112 return NULL;
|
|
|
2113 return t;
|
|
|
2114 }
|
|
|
2115 /*- End of function --------------------------------------------------------*/
|
|
|
2116
|
|
|
2117 static const char *at_cmd_plus_CHUP(at_state_t *s, const char *t)
|
|
|
2118 {
|
|
|
2119 /* 3GPP TS 27.007 6.5 - Hangup call */
|
|
|
2120 /* TODO: */
|
|
|
2121 t += 5;
|
|
|
2122 if (!parse_out(s, &t, NULL, 1, "+CHUP:", ""))
|
|
|
2123 return NULL;
|
|
|
2124 return t;
|
|
|
2125 }
|
|
|
2126 /*- End of function --------------------------------------------------------*/
|
|
|
2127
|
|
|
2128 static const char *at_cmd_plus_CHV(at_state_t *s, const char *t)
|
|
|
2129 {
|
|
|
2130 /* IS-99 5.6 - Hang-up voice */
|
|
|
2131 /* TODO: */
|
|
|
2132 t += 4;
|
|
|
2133 return t;
|
|
|
2134 }
|
|
|
2135 /*- End of function --------------------------------------------------------*/
|
|
|
2136
|
|
|
2137 static const char *at_cmd_plus_CIMI(at_state_t *s, const char *t)
|
|
|
2138 {
|
|
|
2139 /* 3GPP TS 27.007 5.6 - Request international mobile subscriber identity */
|
|
|
2140 /* TODO: */
|
|
|
2141 t += 5;
|
|
|
2142 if (!parse_out(s, &t, NULL, 1, "+CIMI:", ""))
|
|
|
2143 return NULL;
|
|
|
2144 return t;
|
|
|
2145 }
|
|
|
2146 /*- End of function --------------------------------------------------------*/
|
|
|
2147
|
|
|
2148 static const char *at_cmd_plus_CIND(at_state_t *s, const char *t)
|
|
|
2149 {
|
|
|
2150 /* 3GPP TS 27.007 8.9 - Indicator control */
|
|
|
2151 /* TODO: */
|
|
|
2152 t += 5;
|
|
|
2153 if (!parse_out(s, &t, NULL, 1, "+CIND:", ""))
|
|
|
2154 return NULL;
|
|
|
2155 return t;
|
|
|
2156 }
|
|
|
2157 /*- End of function --------------------------------------------------------*/
|
|
|
2158
|
|
|
2159 static const char *at_cmd_plus_CIT(at_state_t *s, const char *t)
|
|
|
2160 {
|
|
|
2161 /* IS-99 5.6 - Command state inactivity timer */
|
|
|
2162 /* TODO: */
|
|
|
2163 t += 4;
|
|
|
2164 return t;
|
|
|
2165 }
|
|
|
2166 /*- End of function --------------------------------------------------------*/
|
|
|
2167
|
|
|
2168 static const char *at_cmd_plus_CKPD(at_state_t *s, const char *t)
|
|
|
2169 {
|
|
|
2170 /* 3GPP TS 27.007 8.7 - Keypad control */
|
|
|
2171 /* TODO: */
|
|
|
2172 t += 5;
|
|
|
2173 if (!parse_out(s, &t, NULL, 1, "+CKPD:", ""))
|
|
|
2174 return NULL;
|
|
|
2175 return t;
|
|
|
2176 }
|
|
|
2177 /*- End of function --------------------------------------------------------*/
|
|
|
2178
|
|
|
2179 static const char *at_cmd_plus_CLAC(at_state_t *s, const char *t)
|
|
|
2180 {
|
|
|
2181 /* 3GPP TS 27.007 8.37 - List all available AT commands */
|
|
|
2182 /* TODO: */
|
|
|
2183 t += 5;
|
|
|
2184 if (!parse_out(s, &t, NULL, 1, "+CLAC:", ""))
|
|
|
2185 return NULL;
|
|
|
2186 return t;
|
|
|
2187 }
|
|
|
2188 /*- End of function --------------------------------------------------------*/
|
|
|
2189
|
|
|
2190 static const char *at_cmd_plus_CLAE(at_state_t *s, const char *t)
|
|
|
2191 {
|
|
|
2192 /* 3GPP TS 27.007 8.31 - Language Event */
|
|
|
2193 /* TODO: */
|
|
|
2194 t += 5;
|
|
|
2195 if (!parse_out(s, &t, NULL, 1, "+CLAE:", ""))
|
|
|
2196 return NULL;
|
|
|
2197 return t;
|
|
|
2198 }
|
|
|
2199 /*- End of function --------------------------------------------------------*/
|
|
|
2200
|
|
|
2201 static const char *at_cmd_plus_CLAN(at_state_t *s, const char *t)
|
|
|
2202 {
|
|
|
2203 /* 3GPP TS 27.007 8.30 - Set Language */
|
|
|
2204 /* TODO: */
|
|
|
2205 t += 5;
|
|
|
2206 if (!parse_out(s, &t, NULL, 1, "+CLAN:", ""))
|
|
|
2207 return NULL;
|
|
|
2208 return t;
|
|
|
2209 }
|
|
|
2210 /*- End of function --------------------------------------------------------*/
|
|
|
2211
|
|
|
2212 static const char *at_cmd_plus_CLCC(at_state_t *s, const char *t)
|
|
|
2213 {
|
|
|
2214 /* 3GPP TS 27.007 7.18 - List current calls */
|
|
|
2215 /* TODO: */
|
|
|
2216 t += 5;
|
|
|
2217 if (!parse_out(s, &t, NULL, 1, "+CLCC:", ""))
|
|
|
2218 return NULL;
|
|
|
2219 return t;
|
|
|
2220 }
|
|
|
2221 /*- End of function --------------------------------------------------------*/
|
|
|
2222
|
|
|
2223 static const char *at_cmd_plus_CLCK(at_state_t *s, const char *t)
|
|
|
2224 {
|
|
|
2225 /* 3GPP TS 27.007 7.4 - Facility lock */
|
|
|
2226 /* TODO: */
|
|
|
2227 t += 5;
|
|
|
2228 if (!parse_out(s, &t, NULL, 1, "+CLCK:", ""))
|
|
|
2229 return NULL;
|
|
|
2230 return t;
|
|
|
2231 }
|
|
|
2232 /*- End of function --------------------------------------------------------*/
|
|
|
2233
|
|
|
2234 static const char *at_cmd_plus_CLIP(at_state_t *s, const char *t)
|
|
|
2235 {
|
|
|
2236 /* 3GPP TS 27.007 7.6 - Calling line identification presentation */
|
|
|
2237 /* TODO: */
|
|
|
2238 t += 5;
|
|
|
2239 if (!parse_out(s, &t, NULL, 1, "+CLIP:", ""))
|
|
|
2240 return NULL;
|
|
|
2241 return t;
|
|
|
2242 }
|
|
|
2243 /*- End of function --------------------------------------------------------*/
|
|
|
2244
|
|
|
2245 static const char *at_cmd_plus_CLIR(at_state_t *s, const char *t)
|
|
|
2246 {
|
|
|
2247 /* 3GPP TS 27.007 7.7 - Calling line identification restriction */
|
|
|
2248 /* TODO: */
|
|
|
2249 t += 5;
|
|
|
2250 if (!parse_out(s, &t, NULL, 1, "+CLIR:", ""))
|
|
|
2251 return NULL;
|
|
|
2252 return t;
|
|
|
2253 }
|
|
|
2254 /*- End of function --------------------------------------------------------*/
|
|
|
2255
|
|
|
2256 static const char *at_cmd_plus_CLVL(at_state_t *s, const char *t)
|
|
|
2257 {
|
|
|
2258 /* 3GPP TS 27.007 8.23 - Loudspeaker volume level */
|
|
|
2259 /* TODO: */
|
|
|
2260 t += 5;
|
|
|
2261 if (!parse_out(s, &t, NULL, 1, "+CLVL:", ""))
|
|
|
2262 return NULL;
|
|
|
2263 return t;
|
|
|
2264 }
|
|
|
2265 /*- End of function --------------------------------------------------------*/
|
|
|
2266
|
|
|
2267 static const char *at_cmd_plus_CMAR(at_state_t *s, const char *t)
|
|
|
2268 {
|
|
|
2269 /* 3GPP TS 27.007 8.36 - Master Reset */
|
|
|
2270 /* TODO: */
|
|
|
2271 t += 5;
|
|
|
2272 if (!parse_out(s, &t, NULL, 1, "+CMAR:", ""))
|
|
|
2273 return NULL;
|
|
|
2274 return t;
|
|
|
2275 }
|
|
|
2276 /*- End of function --------------------------------------------------------*/
|
|
|
2277
|
|
|
2278 static const char *at_cmd_plus_CMEC(at_state_t *s, const char *t)
|
|
|
2279 {
|
|
|
2280 /* 3GPP TS 27.007 8.6 - Mobile Termination control mode */
|
|
|
2281 /* TODO: */
|
|
|
2282 t += 5;
|
|
|
2283 if (!parse_out(s, &t, NULL, 1, "+CMEC:", ""))
|
|
|
2284 return NULL;
|
|
|
2285 return t;
|
|
|
2286 }
|
|
|
2287 /*- End of function --------------------------------------------------------*/
|
|
|
2288
|
|
|
2289 static const char *at_cmd_plus_CMEE(at_state_t *s, const char *t)
|
|
|
2290 {
|
|
|
2291 /* GSM07.07 9.1 - Report mobile equipment error */
|
|
|
2292 /* TODO: */
|
|
|
2293 t += 5;
|
|
|
2294 return t;
|
|
|
2295 }
|
|
|
2296 /*- End of function --------------------------------------------------------*/
|
|
|
2297
|
|
|
2298 static const char *at_cmd_plus_CMER(at_state_t *s, const char *t)
|
|
|
2299 {
|
|
|
2300 /* 3GPP TS 27.007 8.10 - Mobile Termination event reporting */
|
|
|
2301 /* TODO: */
|
|
|
2302 t += 5;
|
|
|
2303 if (!parse_out(s, &t, NULL, 1, "+CMER:", ""))
|
|
|
2304 return NULL;
|
|
|
2305 return t;
|
|
|
2306 }
|
|
|
2307 /*- End of function --------------------------------------------------------*/
|
|
|
2308
|
|
|
2309 static const char *at_cmd_plus_CMGC(at_state_t *s, const char *t)
|
|
|
2310 {
|
|
|
2311 /* GSM07.05 3.5.5/4.5 - Send command */
|
|
|
2312 /* TODO: */
|
|
|
2313 t += 5;
|
|
|
2314 return t;
|
|
|
2315 }
|
|
|
2316 /*- End of function --------------------------------------------------------*/
|
|
|
2317
|
|
|
2318 static const char *at_cmd_plus_CMGD(at_state_t *s, const char *t)
|
|
|
2319 {
|
|
|
2320 /* GSM07.05 3.5.4 - Delete message */
|
|
|
2321 /* TODO: */
|
|
|
2322 t += 5;
|
|
|
2323 return t;
|
|
|
2324 }
|
|
|
2325 /*- End of function --------------------------------------------------------*/
|
|
|
2326
|
|
|
2327 static const char *at_cmd_plus_CMGF(at_state_t *s, const char *t)
|
|
|
2328 {
|
|
|
2329 /* GSM07.05 3.2.3 - Message Format */
|
|
|
2330 /* TODO: */
|
|
|
2331 t += 5;
|
|
|
2332 return t;
|
|
|
2333 }
|
|
|
2334 /*- End of function --------------------------------------------------------*/
|
|
|
2335
|
|
|
2336 static const char *at_cmd_plus_CMGL(at_state_t *s, const char *t)
|
|
|
2337 {
|
|
|
2338 /* GSM07.05 3.4.2/4.1 - List messages */
|
|
|
2339 /* TODO: */
|
|
|
2340 t += 5;
|
|
|
2341 return t;
|
|
|
2342 }
|
|
|
2343 /*- End of function --------------------------------------------------------*/
|
|
|
2344
|
|
|
2345 static const char *at_cmd_plus_CMGR(at_state_t *s, const char *t)
|
|
|
2346 {
|
|
|
2347 /* GSM07.05 3.4.3/4.2 - Read message */
|
|
|
2348 /* TODO: */
|
|
|
2349 t += 5;
|
|
|
2350 return t;
|
|
|
2351 }
|
|
|
2352 /*- End of function --------------------------------------------------------*/
|
|
|
2353
|
|
|
2354 static const char *at_cmd_plus_CMGS(at_state_t *s, const char *t)
|
|
|
2355 {
|
|
|
2356 /* GSM07.05 3.5.1/4.3 - Send message */
|
|
|
2357 /* TODO: */
|
|
|
2358 t += 5;
|
|
|
2359 return t;
|
|
|
2360 }
|
|
|
2361 /*- End of function --------------------------------------------------------*/
|
|
|
2362
|
|
|
2363 static const char *at_cmd_plus_CMGW(at_state_t *s, const char *t)
|
|
|
2364 {
|
|
|
2365 /* GSM07.05 3.5.3/4.4 - Write message to memory */
|
|
|
2366 /* TODO: */
|
|
|
2367 t += 5;
|
|
|
2368 return t;
|
|
|
2369 }
|
|
|
2370 /*- End of function --------------------------------------------------------*/
|
|
|
2371
|
|
|
2372 static const char *at_cmd_plus_CMIP(at_state_t *s, const char *t)
|
|
|
2373 {
|
|
|
2374 /* IS-99 5.6 - Mobile station IP address */
|
|
|
2375 /* TODO: */
|
|
|
2376 t += 5;
|
|
|
2377 return t;
|
|
|
2378 }
|
|
|
2379 /*- End of function --------------------------------------------------------*/
|
|
|
2380
|
|
|
2381 static const char *at_cmd_plus_CMM(at_state_t *s, const char *t)
|
|
|
2382 {
|
|
|
2383 /* IS-135 4.1.23 - Menu map */
|
|
|
2384 /* TODO: */
|
|
|
2385 t += 4;
|
|
|
2386 return t;
|
|
|
2387 }
|
|
|
2388 /*- End of function --------------------------------------------------------*/
|
|
|
2389
|
|
|
2390 static const char *at_cmd_plus_CMMS(at_state_t *s, const char *t)
|
|
|
2391 {
|
|
|
2392 /* GSM07.05 3.5.6 - More messages to send */
|
|
|
2393 /* TODO: */
|
|
|
2394 t += 5;
|
|
|
2395 return t;
|
|
|
2396 }
|
|
|
2397 /*- End of function --------------------------------------------------------*/
|
|
|
2398
|
|
|
2399 static const char *at_cmd_plus_CMOD(at_state_t *s, const char *t)
|
|
|
2400 {
|
|
|
2401 /* 3GPP TS 27.007 6.4 - Call mode */
|
|
|
2402 /* TODO: */
|
|
|
2403 t += 5;
|
|
|
2404 if (!parse_out(s, &t, NULL, 1, "+CMOD:", ""))
|
|
|
2405 return NULL;
|
|
|
2406 return t;
|
|
|
2407 }
|
|
|
2408 /*- End of function --------------------------------------------------------*/
|
|
|
2409
|
|
|
2410 static const char *at_cmd_plus_CMSS(at_state_t *s, const char *t)
|
|
|
2411 {
|
|
|
2412 /* GSM07.05 3.5.2/4.7 - Send message from storage */
|
|
|
2413 /* TODO: */
|
|
|
2414 t += 5;
|
|
|
2415 return t;
|
|
|
2416 }
|
|
|
2417 /*- End of function --------------------------------------------------------*/
|
|
|
2418
|
|
|
2419 static const char *at_cmd_plus_CMUT(at_state_t *s, const char *t)
|
|
|
2420 {
|
|
|
2421 /* 3GPP TS 27.007 8.24 - Mute control */
|
|
|
2422 /* TODO: */
|
|
|
2423 t += 5;
|
|
|
2424 if (!parse_out(s, &t, NULL, 1, "+CMUT:", ""))
|
|
|
2425 return NULL;
|
|
|
2426 return t;
|
|
|
2427 }
|
|
|
2428 /*- End of function --------------------------------------------------------*/
|
|
|
2429
|
|
|
2430 static const char *at_cmd_plus_CNMA(at_state_t *s, const char *t)
|
|
|
2431 {
|
|
|
2432 /* GSM07.05 3.4.4/4.6 - New message acknowledgement to terminal adapter */
|
|
|
2433 /* TODO: */
|
|
|
2434 t += 5;
|
|
|
2435 return t;
|
|
|
2436 }
|
|
|
2437 /*- End of function --------------------------------------------------------*/
|
|
|
2438
|
|
|
2439 static const char *at_cmd_plus_CNMI(at_state_t *s, const char *t)
|
|
|
2440 {
|
|
|
2441 /* GSM07.05 3.4.1 - New message indications to terminal equipment */
|
|
|
2442 /* TODO: */
|
|
|
2443 t += 5;
|
|
|
2444 return t;
|
|
|
2445 }
|
|
|
2446 /*- End of function --------------------------------------------------------*/
|
|
|
2447
|
|
|
2448 static const char *at_cmd_plus_CMUX(at_state_t *s, const char *t)
|
|
|
2449 {
|
|
|
2450 /* 3GPP TS 27.007 5.7 - Multiplexing mode */
|
|
|
2451 /* TODO: */
|
|
|
2452 t += 5;
|
|
|
2453 if (!parse_out(s, &t, NULL, 1, "+CMUX:", ""))
|
|
|
2454 return NULL;
|
|
|
2455 return t;
|
|
|
2456 }
|
|
|
2457 /*- End of function --------------------------------------------------------*/
|
|
|
2458
|
|
|
2459 static const char *at_cmd_plus_CNUM(at_state_t *s, const char *t)
|
|
|
2460 {
|
|
|
2461 /* 3GPP TS 27.007 7.1 - Subscriber number */
|
|
|
2462 /* TODO: */
|
|
|
2463 t += 5;
|
|
|
2464 if (!parse_out(s, &t, NULL, 1, "+CNUM:", ""))
|
|
|
2465 return NULL;
|
|
|
2466 return t;
|
|
|
2467 }
|
|
|
2468 /*- End of function --------------------------------------------------------*/
|
|
|
2469
|
|
|
2470 static const char *at_cmd_plus_COLP(at_state_t *s, const char *t)
|
|
|
2471 {
|
|
|
2472 /* 3GPP TS 27.007 7.8 - Connected line identification presentation */
|
|
|
2473 /* TODO: */
|
|
|
2474 t += 5;
|
|
|
2475 if (!parse_out(s, &t, NULL, 1, "+COLP:", ""))
|
|
|
2476 return NULL;
|
|
|
2477 return t;
|
|
|
2478 }
|
|
|
2479 /*- End of function --------------------------------------------------------*/
|
|
|
2480
|
|
|
2481 static const char *at_cmd_plus_COPN(at_state_t *s, const char *t)
|
|
|
2482 {
|
|
|
2483 /* 3GPP TS 27.007 7.21 - Read operator names */
|
|
|
2484 /* TODO: */
|
|
|
2485 t += 5;
|
|
|
2486 if (!parse_out(s, &t, NULL, 1, "+COPN:", ""))
|
|
|
2487 return NULL;
|
|
|
2488 return t;
|
|
|
2489 }
|
|
|
2490 /*- End of function --------------------------------------------------------*/
|
|
|
2491
|
|
|
2492 static const char *at_cmd_plus_COPS(at_state_t *s, const char *t)
|
|
|
2493 {
|
|
|
2494 /* 3GPP TS 27.007 7.3 - PLMN selection */
|
|
|
2495 /* TODO: */
|
|
|
2496 t += 5;
|
|
|
2497 if (!parse_out(s, &t, NULL, 1, "+COPS:", ""))
|
|
|
2498 return NULL;
|
|
|
2499 return t;
|
|
|
2500 }
|
|
|
2501 /*- End of function --------------------------------------------------------*/
|
|
|
2502
|
|
|
2503 static const char *at_cmd_plus_COS(at_state_t *s, const char *t)
|
|
|
2504 {
|
|
|
2505 /* IS-135 4.1.24 - Originating service */
|
|
|
2506 /* TODO: */
|
|
|
2507 t += 4;
|
|
|
2508 return t;
|
|
|
2509 }
|
|
|
2510 /*- End of function --------------------------------------------------------*/
|
|
|
2511
|
|
|
2512 static const char *at_cmd_plus_COTDI(at_state_t *s, const char *t)
|
|
|
2513 {
|
|
|
2514 /* 3GPP TS 27.007 11.1.9 - Originator to Dispatcher Information */
|
|
|
2515 /* TODO: */
|
|
|
2516 t += 6;
|
|
|
2517 if (!parse_out(s, &t, NULL, 1, "+COTDI:", ""))
|
|
|
2518 return NULL;
|
|
|
2519 return t;
|
|
|
2520 }
|
|
|
2521 /*- End of function --------------------------------------------------------*/
|
|
|
2522
|
|
|
2523 static const char *at_cmd_plus_CPAS(at_state_t *s, const char *t)
|
|
|
2524 {
|
|
|
2525 /* 3GPP TS 27.007 8.1 - Phone activity status */
|
|
|
2526 /* TODO: */
|
|
|
2527 t += 5;
|
|
|
2528 if (!parse_out(s, &t, NULL, 1, "+CPAS:", ""))
|
|
|
2529 return NULL;
|
|
|
2530 return t;
|
|
|
2531 }
|
|
|
2532 /*- End of function --------------------------------------------------------*/
|
|
|
2533
|
|
|
2534 static const char *at_cmd_plus_CPBF(at_state_t *s, const char *t)
|
|
|
2535 {
|
|
|
2536 /* 3GPP TS 27.007 8.13 - Find phonebook entries */
|
|
|
2537 /* TODO: */
|
|
|
2538 t += 5;
|
|
|
2539 if (!parse_out(s, &t, NULL, 1, "+CPBF:", ""))
|
|
|
2540 return NULL;
|
|
|
2541 return t;
|
|
|
2542 }
|
|
|
2543 /*- End of function --------------------------------------------------------*/
|
|
|
2544
|
|
|
2545 static const char *at_cmd_plus_CPBR(at_state_t *s, const char *t)
|
|
|
2546 {
|
|
|
2547 /* 3GPP TS 27.007 8.12 - Read phonebook entries */
|
|
|
2548 /* TODO: */
|
|
|
2549 t += 5;
|
|
|
2550 if (!parse_out(s, &t, NULL, 1, "+CPBR:", ""))
|
|
|
2551 return NULL;
|
|
|
2552 return t;
|
|
|
2553 }
|
|
|
2554 /*- End of function --------------------------------------------------------*/
|
|
|
2555
|
|
|
2556 static const char *at_cmd_plus_CPBS(at_state_t *s, const char *t)
|
|
|
2557 {
|
|
|
2558 /* 3GPP TS 27.007 8.11 - Select phonebook memory storage */
|
|
|
2559 /* TODO: */
|
|
|
2560 t += 5;
|
|
|
2561 if (!parse_out(s, &t, NULL, 1, "+CPBS:", ""))
|
|
|
2562 return NULL;
|
|
|
2563 return t;
|
|
|
2564 }
|
|
|
2565 /*- End of function --------------------------------------------------------*/
|
|
|
2566
|
|
|
2567 static const char *at_cmd_plus_CPBW(at_state_t *s, const char *t)
|
|
|
2568 {
|
|
|
2569 /* 3GPP TS 27.007 8.14 - Write phonebook entry */
|
|
|
2570 /* TODO: */
|
|
|
2571 t += 5;
|
|
|
2572 if (!parse_out(s, &t, NULL, 1, "+CPBW:", ""))
|
|
|
2573 return NULL;
|
|
|
2574 return t;
|
|
|
2575 }
|
|
|
2576 /*- End of function --------------------------------------------------------*/
|
|
|
2577
|
|
|
2578 static const char *at_cmd_plus_CPIN(at_state_t *s, const char *t)
|
|
|
2579 {
|
|
|
2580 /* 3GPP TS 27.007 8.3 - Enter PIN */
|
|
|
2581 /* TODO: */
|
|
|
2582 t += 5;
|
|
|
2583 if (!parse_out(s, &t, NULL, 1, "+CPIN:", ""))
|
|
|
2584 return NULL;
|
|
|
2585 return t;
|
|
|
2586 }
|
|
|
2587 /*- End of function --------------------------------------------------------*/
|
|
|
2588
|
|
|
2589 static const char *at_cmd_plus_CPLS(at_state_t *s, const char *t)
|
|
|
2590 {
|
|
|
2591 /* 3GPP TS 27.007 7.20 - Selection of preferred PLMN list */
|
|
|
2592 /* TODO: */
|
|
|
2593 t += 5;
|
|
|
2594 if (!parse_out(s, &t, NULL, 1, "+CPLS:", ""))
|
|
|
2595 return NULL;
|
|
|
2596 return t;
|
|
|
2597 }
|
|
|
2598 /*- End of function --------------------------------------------------------*/
|
|
|
2599
|
|
|
2600 static const char *at_cmd_plus_CPMS(at_state_t *s, const char *t)
|
|
|
2601 {
|
|
|
2602 /* GSM07.05 3.2.2 - Preferred message storage */
|
|
|
2603 /* TODO: */
|
|
|
2604 t += 5;
|
|
|
2605 return t;
|
|
|
2606 }
|
|
|
2607 /*- End of function --------------------------------------------------------*/
|
|
|
2608
|
|
|
2609 static const char *at_cmd_plus_CPOL(at_state_t *s, const char *t)
|
|
|
2610 {
|
|
|
2611 /* 3GPP TS 27.007 7.19 - Preferred PLMN list */
|
|
|
2612 /* TODO: */
|
|
|
2613 t += 5;
|
|
|
2614 if (!parse_out(s, &t, NULL, 1, "+CPOL:", ""))
|
|
|
2615 return NULL;
|
|
|
2616 return t;
|
|
|
2617 }
|
|
|
2618 /*- End of function --------------------------------------------------------*/
|
|
|
2619
|
|
|
2620 static const char *at_cmd_plus_CPPS(at_state_t *s, const char *t)
|
|
|
2621 {
|
|
|
2622 /* 3GPP TS 27.007 7.23 - eMLPP subscriptions */
|
|
|
2623 /* TODO: */
|
|
|
2624 t += 5;
|
|
|
2625 if (!parse_out(s, &t, NULL, 1, "+CPPS:", ""))
|
|
|
2626 return NULL;
|
|
|
2627 return t;
|
|
|
2628 }
|
|
|
2629 /*- End of function --------------------------------------------------------*/
|
|
|
2630
|
|
|
2631 static const char *at_cmd_plus_CPROT(at_state_t *s, const char *t)
|
|
|
2632 {
|
|
|
2633 /* 3GPP TS 27.007 8.42 - Enter protocol mode */
|
|
|
2634 /* TODO: */
|
|
|
2635 t += 6;
|
|
|
2636 if (!parse_out(s, &t, NULL, 1, "+CPROT:", ""))
|
|
|
2637 return NULL;
|
|
|
2638 return t;
|
|
|
2639 }
|
|
|
2640 /*- End of function --------------------------------------------------------*/
|
|
|
2641
|
|
|
2642 static const char *at_cmd_plus_CPUC(at_state_t *s, const char *t)
|
|
|
2643 {
|
|
|
2644 /* 3GPP TS 27.007 8.27 - Price per unit and currency table */
|
|
|
2645 /* TODO: */
|
|
|
2646 t += 5;
|
|
|
2647 if (!parse_out(s, &t, NULL, 1, "+CPUC:", ""))
|
|
|
2648 return NULL;
|
|
|
2649 return t;
|
|
|
2650 }
|
|
|
2651 /*- End of function --------------------------------------------------------*/
|
|
|
2652
|
|
|
2653 static const char *at_cmd_plus_CPWC(at_state_t *s, const char *t)
|
|
|
2654 {
|
|
|
2655 /* 3GPP TS 27.007 8.29 - Power class */
|
|
|
2656 /* TODO: */
|
|
|
2657 t += 5;
|
|
|
2658 if (!parse_out(s, &t, NULL, 1, "+CPWC:", ""))
|
|
|
2659 return NULL;
|
|
|
2660 return t;
|
|
|
2661 }
|
|
|
2662 /*- End of function --------------------------------------------------------*/
|
|
|
2663
|
|
|
2664 static const char *at_cmd_plus_CPWD(at_state_t *s, const char *t)
|
|
|
2665 {
|
|
|
2666 /* 3GPP TS 27.007 7.5 - Change password */
|
|
|
2667 /* TODO: */
|
|
|
2668 t += 5;
|
|
|
2669 if (!parse_out(s, &t, NULL, 1, "+CPWD:", ""))
|
|
|
2670 return NULL;
|
|
|
2671 return t;
|
|
|
2672 }
|
|
|
2673 /*- End of function --------------------------------------------------------*/
|
|
|
2674
|
|
|
2675 static const char *at_cmd_plus_CQD(at_state_t *s, const char *t)
|
|
|
2676 {
|
|
|
2677 /* IS-135 4.1.25 - Query disconnect timer */
|
|
|
2678 /* TODO: */
|
|
|
2679 t += 4;
|
|
|
2680 return t;
|
|
|
2681 }
|
|
|
2682 /*- End of function --------------------------------------------------------*/
|
|
|
2683
|
|
|
2684 static const char *at_cmd_plus_CR(at_state_t *s, const char *t)
|
|
|
2685 {
|
|
|
2686 /* 3GPP TS 27.007 6.9 - Service reporting control */
|
|
|
2687 /* TODO: */
|
|
|
2688 t += 3;
|
|
|
2689 if (!parse_out(s, &t, NULL, 1, "+CR:", ""))
|
|
|
2690 return NULL;
|
|
|
2691 return t;
|
|
|
2692 }
|
|
|
2693 /*- End of function --------------------------------------------------------*/
|
|
|
2694
|
|
|
2695 static const char *at_cmd_plus_CRC(at_state_t *s, const char *t)
|
|
|
2696 {
|
|
|
2697 /* 3GPP TS 27.007 6.11 - Cellular result codes */
|
|
|
2698 /* TODO: */
|
|
|
2699 t += 4;
|
|
|
2700 if (!parse_out(s, &t, NULL, 1, "+CRC:", ""))
|
|
|
2701 return NULL;
|
|
|
2702 return t;
|
|
|
2703 }
|
|
|
2704 /*- End of function --------------------------------------------------------*/
|
|
|
2705
|
|
|
2706 static const char *at_cmd_plus_CREG(at_state_t *s, const char *t)
|
|
|
2707 {
|
|
|
2708 /* 3GPP TS 27.007 7.2 - Network registration */
|
|
|
2709 /* TODO: */
|
|
|
2710 t += 5;
|
|
|
2711 if (!parse_out(s, &t, NULL, 1, "+CREG:", ""))
|
|
|
2712 return NULL;
|
|
|
2713 return t;
|
|
|
2714 }
|
|
|
2715 /*- End of function --------------------------------------------------------*/
|
|
|
2716
|
|
|
2717 static const char *at_cmd_plus_CRES(at_state_t *s, const char *t)
|
|
|
2718 {
|
|
|
2719 /* GSM07.05 3.3.6 - Restore Settings */
|
|
|
2720 /* TODO: */
|
|
|
2721 t += 5;
|
|
|
2722 if (!parse_out(s, &t, NULL, 1, "+CRLP:", ""))
|
|
|
2723 return NULL;
|
|
|
2724 return t;
|
|
|
2725 }
|
|
|
2726 /*- End of function --------------------------------------------------------*/
|
|
|
2727
|
|
|
2728 static const char *at_cmd_plus_CRLP(at_state_t *s, const char *t)
|
|
|
2729 {
|
|
|
2730 /* 3GPP TS 27.007 6.8 - Radio link protocol */
|
|
|
2731 /* TODO: */
|
|
|
2732 t += 5;
|
|
|
2733 if (!parse_out(s, &t, NULL, 1, "+CRLP:", ""))
|
|
|
2734 return NULL;
|
|
|
2735 return t;
|
|
|
2736 }
|
|
|
2737 /*- End of function --------------------------------------------------------*/
|
|
|
2738
|
|
|
2739 static const char *at_cmd_plus_CRM(at_state_t *s, const char *t)
|
|
|
2740 {
|
|
|
2741 /* IS-99 5.6 - Set rm interface protocol */
|
|
|
2742 /* TODO: */
|
|
|
2743 t += 4;
|
|
|
2744 return t;
|
|
|
2745 }
|
|
|
2746 /*- End of function --------------------------------------------------------*/
|
|
|
2747
|
|
|
2748 static const char *at_cmd_plus_CRMC(at_state_t *s, const char *t)
|
|
|
2749 {
|
|
|
2750 /* 3GPP TS 27.007 8.34 - Ring Melody Control */
|
|
|
2751 /* TODO: */
|
|
|
2752 t += 5;
|
|
|
2753 if (!parse_out(s, &t, NULL, 1, "+CRMC:", ""))
|
|
|
2754 return NULL;
|
|
|
2755 return t;
|
|
|
2756 }
|
|
|
2757 /*- End of function --------------------------------------------------------*/
|
|
|
2758
|
|
|
2759 static const char *at_cmd_plus_CRMP(at_state_t *s, const char *t)
|
|
|
2760 {
|
|
|
2761 /* 3GPP TS 27.007 8.35 - Ring Melody Playback */
|
|
|
2762 /* TODO: */
|
|
|
2763 t += 5;
|
|
|
2764 if (!parse_out(s, &t, NULL, 1, "+CRMP:", ""))
|
|
|
2765 return NULL;
|
|
|
2766 return t;
|
|
|
2767 }
|
|
|
2768 /*- End of function --------------------------------------------------------*/
|
|
|
2769
|
|
|
2770 static const char *at_cmd_plus_CRSL(at_state_t *s, const char *t)
|
|
|
2771 {
|
|
|
2772 /* 3GPP TS 27.007 8.21 - Ringer sound level */
|
|
|
2773 /* TODO: */
|
|
|
2774 t += 5;
|
|
|
2775 if (!parse_out(s, &t, NULL, 1, "+CRSL:", ""))
|
|
|
2776 return NULL;
|
|
|
2777 return t;
|
|
|
2778 }
|
|
|
2779 /*- End of function --------------------------------------------------------*/
|
|
|
2780
|
|
|
2781 static const char *at_cmd_plus_CRSM(at_state_t *s, const char *t)
|
|
|
2782 {
|
|
|
2783 /* 3GPP TS 27.007 8.18 - Restricted SIM access */
|
|
|
2784 /* TODO: */
|
|
|
2785 t += 5;
|
|
|
2786 if (!parse_out(s, &t, NULL, 1, "+CRSM:", ""))
|
|
|
2787 return NULL;
|
|
|
2788 return t;
|
|
|
2789 }
|
|
|
2790 /*- End of function --------------------------------------------------------*/
|
|
|
2791
|
|
|
2792 static const char *at_cmd_plus_CSAS(at_state_t *s, const char *t)
|
|
|
2793 {
|
|
|
2794 /* GSM07.05 3.3.5 - Save settings */
|
|
|
2795 /* TODO: */
|
|
|
2796 t += 5;
|
|
|
2797 return t;
|
|
|
2798 }
|
|
|
2799 /*- End of function --------------------------------------------------------*/
|
|
|
2800
|
|
|
2801 static const char *at_cmd_plus_CSCA(at_state_t *s, const char *t)
|
|
|
2802 {
|
|
|
2803 /* GSM07.05 3.3.1 - Service centre address */
|
|
|
2804 /* TODO: */
|
|
|
2805 t += 5;
|
|
|
2806 return t;
|
|
|
2807 }
|
|
|
2808 /*- End of function --------------------------------------------------------*/
|
|
|
2809
|
|
|
2810 static const char *at_cmd_plus_CSCB(at_state_t *s, const char *t)
|
|
|
2811 {
|
|
|
2812 /* GSM07.05 3.3.4 - Select cell broadcast message types */
|
|
|
2813 /* TODO: */
|
|
|
2814 t += 5;
|
|
|
2815 return t;
|
|
|
2816 }
|
|
|
2817 /*- End of function --------------------------------------------------------*/
|
|
|
2818
|
|
|
2819 static const char *at_cmd_plus_CSCC(at_state_t *s, const char *t)
|
|
|
2820 {
|
|
|
2821 /* 3GPP TS 27.007 8.19 - Secure control command */
|
|
|
2822 /* TODO: */
|
|
|
2823 t += 5;
|
|
|
2824 if (!parse_out(s, &t, NULL, 1, "+CSCC:", ""))
|
|
|
2825 return NULL;
|
|
|
2826 return t;
|
|
|
2827 }
|
|
|
2828 /*- End of function --------------------------------------------------------*/
|
|
|
2829
|
|
|
2830 static const char *at_cmd_plus_CSCS(at_state_t *s, const char *t)
|
|
|
2831 {
|
|
|
2832 /* 3GPP TS 27.007 5.5 - Select TE character set */
|
|
|
2833 /* TODO: */
|
|
|
2834 t += 5;
|
|
|
2835 if (!parse_out(s, &t, NULL, 1, "+CSCS:", ""))
|
|
|
2836 return NULL;
|
|
|
2837 return t;
|
|
|
2838 }
|
|
|
2839 /*- End of function --------------------------------------------------------*/
|
|
|
2840
|
|
|
2841 static const char *at_cmd_plus_CSDF(at_state_t *s, const char *t)
|
|
|
2842 {
|
|
|
2843 /* 3GPP TS 27.007 6.22 - Settings date format */
|
|
|
2844 /* TODO: */
|
|
|
2845 t += 5;
|
|
|
2846 if (!parse_out(s, &t, NULL, 1, "+CSDF:", ""))
|
|
|
2847 return NULL;
|
|
|
2848 return t;
|
|
|
2849 }
|
|
|
2850 /*- End of function --------------------------------------------------------*/
|
|
|
2851
|
|
|
2852 static const char *at_cmd_plus_CSDH(at_state_t *s, const char *t)
|
|
|
2853 {
|
|
|
2854 /* GSM07.05 3.3.3 - Show text mode parameters */
|
|
|
2855 /* TODO: */
|
|
|
2856 t += 5;
|
|
|
2857 return t;
|
|
|
2858 }
|
|
|
2859 /*- End of function --------------------------------------------------------*/
|
|
|
2860
|
|
|
2861 static const char *at_cmd_plus_CSGT(at_state_t *s, const char *t)
|
|
|
2862 {
|
|
|
2863 /* 3GPP TS 27.007 8.32 - Set Greeting Text */
|
|
|
2864 /* TODO: */
|
|
|
2865 t += 5;
|
|
|
2866 if (!parse_out(s, &t, NULL, 1, "+CSGT:", ""))
|
|
|
2867 return NULL;
|
|
|
2868 return t;
|
|
|
2869 }
|
|
|
2870 /*- End of function --------------------------------------------------------*/
|
|
|
2871
|
|
|
2872 static const char *at_cmd_plus_CSIL(at_state_t *s, const char *t)
|
|
|
2873 {
|
|
|
2874 /* 3GPP TS 27.007 6.23 - Silence Command */
|
|
|
2875 /* TODO: */
|
|
|
2876 t += 5;
|
|
|
2877 if (!parse_out(s, &t, NULL, 1, "+CSIL:", ""))
|
|
|
2878 return NULL;
|
|
|
2879 return t;
|
|
|
2880 }
|
|
|
2881 /*- End of function --------------------------------------------------------*/
|
|
|
2882
|
|
|
2883 static const char *at_cmd_plus_CSIM(at_state_t *s, const char *t)
|
|
|
2884 {
|
|
|
2885 /* 3GPP TS 27.007 8.17 - Generic SIM access */
|
|
|
2886 /* TODO: */
|
|
|
2887 t += 5;
|
|
|
2888 if (!parse_out(s, &t, NULL, 1, "+CSIM:", ""))
|
|
|
2889 return NULL;
|
|
|
2890 return t;
|
|
|
2891 }
|
|
|
2892 /*- End of function --------------------------------------------------------*/
|
|
|
2893
|
|
|
2894 static const char *at_cmd_plus_CSMP(at_state_t *s, const char *t)
|
|
|
2895 {
|
|
|
2896 /* GSM07.05 3.3.2 - Set text mode parameters */
|
|
|
2897 /* TODO: */
|
|
|
2898 t += 5;
|
|
|
2899 return t;
|
|
|
2900 }
|
|
|
2901 /*- End of function --------------------------------------------------------*/
|
|
|
2902
|
|
|
2903 static const char *at_cmd_plus_CSMS(at_state_t *s, const char *t)
|
|
|
2904 {
|
|
|
2905 /* GSM07.05 3.2.1 - Select Message Service */
|
|
|
2906 /* TODO: */
|
|
|
2907 t += 5;
|
|
|
2908 return t;
|
|
|
2909 }
|
|
|
2910 /*- End of function --------------------------------------------------------*/
|
|
|
2911
|
|
|
2912 static const char *at_cmd_plus_CSNS(at_state_t *s, const char *t)
|
|
|
2913 {
|
|
|
2914 /* 3GPP TS 27.007 6.19 - Single numbering scheme */
|
|
|
2915 /* TODO: */
|
|
|
2916 t += 5;
|
|
|
2917 if (!parse_out(s, &t, NULL, 1, "+CSNS:", ""))
|
|
|
2918 return NULL;
|
|
|
2919 return t;
|
|
|
2920 }
|
|
|
2921 /*- End of function --------------------------------------------------------*/
|
|
|
2922
|
|
|
2923 static const char *at_cmd_plus_CSQ(at_state_t *s, const char *t)
|
|
|
2924 {
|
|
|
2925 /* 3GPP TS 27.007 8.5 - Signal quality */
|
|
|
2926 /* TODO: */
|
|
|
2927 t += 4;
|
|
|
2928 if (!parse_out(s, &t, NULL, 1, "+CSQ:", ""))
|
|
|
2929 return NULL;
|
|
|
2930 return t;
|
|
|
2931 }
|
|
|
2932 /*- End of function --------------------------------------------------------*/
|
|
|
2933
|
|
|
2934 static const char *at_cmd_plus_CSS(at_state_t *s, const char *t)
|
|
|
2935 {
|
|
|
2936 /* IS-135 4.1.28 - Serving system identification */
|
|
|
2937 /* TODO: */
|
|
|
2938 t += 4;
|
|
|
2939 return t;
|
|
|
2940 }
|
|
|
2941 /*- End of function --------------------------------------------------------*/
|
|
|
2942
|
|
|
2943 static const char *at_cmd_plus_CSSN(at_state_t *s, const char *t)
|
|
|
2944 {
|
|
|
2945 /* 3GPP TS 27.007 7.17 - Supplementary service notifications */
|
|
|
2946 /* TODO: */
|
|
|
2947 t += 5;
|
|
|
2948 if (!parse_out(s, &t, NULL, 1, "+CSSN:", ""))
|
|
|
2949 return NULL;
|
|
|
2950 return t;
|
|
|
2951 }
|
|
|
2952 /*- End of function --------------------------------------------------------*/
|
|
|
2953
|
|
|
2954 static const char *at_cmd_plus_CSTA(at_state_t *s, const char *t)
|
|
|
2955 {
|
|
|
2956 /* 3GPP TS 27.007 6.1 - Select type of address */
|
|
|
2957 /* TODO: */
|
|
|
2958 t += 5;
|
|
|
2959 if (!parse_out(s, &t, NULL, 1, "+CSTA:", ""))
|
|
|
2960 return NULL;
|
|
|
2961 return t;
|
|
|
2962 }
|
|
|
2963 /*- End of function --------------------------------------------------------*/
|
|
|
2964
|
|
|
2965 static const char *at_cmd_plus_CSTF(at_state_t *s, const char *t)
|
|
|
2966 {
|
|
|
2967 /* 3GPP TS 27.007 6.24 - Settings time format */
|
|
|
2968 /* TODO: */
|
|
|
2969 t += 5;
|
|
|
2970 if (!parse_out(s, &t, NULL, 1, "+CSTF:", ""))
|
|
|
2971 return NULL;
|
|
|
2972 return t;
|
|
|
2973 }
|
|
|
2974 /*- End of function --------------------------------------------------------*/
|
|
|
2975
|
|
|
2976 static const char *at_cmd_plus_CSVM(at_state_t *s, const char *t)
|
|
|
2977 {
|
|
|
2978 /* 3GPP TS 27.007 8.33 - Set Voice Mail Number */
|
|
|
2979 /* TODO: */
|
|
|
2980 t += 5;
|
|
|
2981 if (!parse_out(s, &t, NULL, 1, "+CSVM:", ""))
|
|
|
2982 return NULL;
|
|
|
2983 return t;
|
|
|
2984 }
|
|
|
2985 /*- End of function --------------------------------------------------------*/
|
|
|
2986
|
|
|
2987 static const char *at_cmd_plus_CTA(at_state_t *s, const char *t)
|
|
|
2988 {
|
|
|
2989 /* IS-135 4.1.29 - MT-Terminated async. Data calls */
|
|
|
2990 /* TODO: */
|
|
|
2991 t += 4;
|
|
|
2992 return t;
|
|
|
2993 }
|
|
|
2994 /*- End of function --------------------------------------------------------*/
|
|
|
2995
|
|
|
2996 static const char *at_cmd_plus_CTF(at_state_t *s, const char *t)
|
|
|
2997 {
|
|
|
2998 /* IS-135 4.1.30 - MT-Terminated FAX calls */
|
|
|
2999 /* TODO: */
|
|
|
3000 t += 4;
|
|
|
3001 return t;
|
|
|
3002 }
|
|
|
3003 /*- End of function --------------------------------------------------------*/
|
|
|
3004
|
|
|
3005 static const char *at_cmd_plus_CTFR(at_state_t *s, const char *t)
|
|
|
3006 {
|
|
|
3007 /* 3GPP TS 27.007 7.14 - Call deflection */
|
|
|
3008 /* TODO: */
|
|
|
3009 t += 5;
|
|
|
3010 if (!parse_out(s, &t, NULL, 1, "+CTFR:", ""))
|
|
|
3011 return NULL;
|
|
|
3012 return t;
|
|
|
3013 }
|
|
|
3014 /*- End of function --------------------------------------------------------*/
|
|
|
3015
|
|
|
3016 static const char *at_cmd_plus_CTZR(at_state_t *s, const char *t)
|
|
|
3017 {
|
|
|
3018 /* 3GPP TS 27.007 8.41 - Time Zone Reporting */
|
|
|
3019 /* TODO: */
|
|
|
3020 t += 5;
|
|
|
3021 if (!parse_out(s, &t, NULL, 1, "+CTZR:", ""))
|
|
|
3022 return NULL;
|
|
|
3023 return t;
|
|
|
3024 }
|
|
|
3025 /*- End of function --------------------------------------------------------*/
|
|
|
3026
|
|
|
3027 static const char *at_cmd_plus_CTZU(at_state_t *s, const char *t)
|
|
|
3028 {
|
|
|
3029 /* 3GPP TS 27.007 8.40 - Automatic Time Zone Update */
|
|
|
3030 /* TODO: */
|
|
|
3031 t += 5;
|
|
|
3032 if (!parse_out(s, &t, NULL, 1, "+CTZU:", ""))
|
|
|
3033 return NULL;
|
|
|
3034 return t;
|
|
|
3035 }
|
|
|
3036 /*- End of function --------------------------------------------------------*/
|
|
|
3037
|
|
|
3038 static const char *at_cmd_plus_CUSD(at_state_t *s, const char *t)
|
|
|
3039 {
|
|
|
3040 /* 3GPP TS 27.007 7.15 - Unstructured supplementary service data */
|
|
|
3041 /* TODO: */
|
|
|
3042 t += 5;
|
|
|
3043 if (!parse_out(s, &t, NULL, 1, "+CUSD:", ""))
|
|
|
3044 return NULL;
|
|
|
3045 return t;
|
|
|
3046 }
|
|
|
3047 /*- End of function --------------------------------------------------------*/
|
|
|
3048
|
|
|
3049 static const char *at_cmd_plus_CUUS1(at_state_t *s, const char *t)
|
|
|
3050 {
|
|
|
3051 /* 3GPP TS 27.007 7.26 - User to User Signalling Service 1 */
|
|
|
3052 /* TODO: */
|
|
|
3053 t += 6;
|
|
|
3054 if (!parse_out(s, &t, NULL, 1, "+CUUS1:", ""))
|
|
|
3055 return NULL;
|
|
|
3056 return t;
|
|
|
3057 }
|
|
|
3058 /*- End of function --------------------------------------------------------*/
|
|
|
3059
|
|
|
3060 static const char *at_cmd_plus_CV120(at_state_t *s, const char *t)
|
|
|
3061 {
|
|
|
3062 /* 3GPP TS 27.007 6.21 - V.120 rate adaption protocol */
|
|
|
3063 /* TODO: */
|
|
|
3064 t += 6;
|
|
|
3065 if (!parse_out(s, &t, NULL, 1, "+CV120:", ""))
|
|
|
3066 return NULL;
|
|
|
3067 return t;
|
|
|
3068 }
|
|
|
3069 /*- End of function --------------------------------------------------------*/
|
|
|
3070
|
|
|
3071 static const char *at_cmd_plus_CVHU(at_state_t *s, const char *t)
|
|
|
3072 {
|
|
|
3073 /* 3GPP TS 27.007 6.20 - Voice Hangup Control */
|
|
|
3074 /* TODO: */
|
|
|
3075 t += 5;
|
|
|
3076 if (!parse_out(s, &t, NULL, 1, "+CVHU:", ""))
|
|
|
3077 return NULL;
|
|
|
3078 return t;
|
|
|
3079 }
|
|
|
3080 /*- End of function --------------------------------------------------------*/
|
|
|
3081
|
|
|
3082 static const char *at_cmd_plus_CVIB(at_state_t *s, const char *t)
|
|
|
3083 {
|
|
|
3084 /* 3GPP TS 27.007 8.22 - Vibrator mode */
|
|
|
3085 /* TODO: */
|
|
|
3086 t += 5;
|
|
|
3087 if (!parse_out(s, &t, NULL, 1, "+CVIB:", ""))
|
|
|
3088 return NULL;
|
|
|
3089 return t;
|
|
|
3090 }
|
|
|
3091 /*- End of function --------------------------------------------------------*/
|
|
|
3092
|
|
|
3093 static const char *at_cmd_plus_CXT(at_state_t *s, const char *t)
|
|
|
3094 {
|
|
|
3095 /* IS-99 5.6 - Cellular extension */
|
|
|
3096 /* TODO: */
|
|
|
3097 t += 4;
|
|
|
3098 return t;
|
|
|
3099 }
|
|
|
3100 /*- End of function --------------------------------------------------------*/
|
|
|
3101
|
|
|
3102 static const char *at_cmd_plus_DR(at_state_t *s, const char *t)
|
|
|
3103 {
|
|
|
3104 /* V.250 6.6.2 - Data compression reporting */
|
|
|
3105 /* TODO: */
|
|
|
3106 t += 3;
|
|
|
3107 if (!parse_out(s, &t, NULL, 1, "+DR:", ""))
|
|
|
3108 return NULL;
|
|
|
3109 return t;
|
|
|
3110 }
|
|
|
3111 /*- End of function --------------------------------------------------------*/
|
|
|
3112
|
|
|
3113 static const char *at_cmd_plus_DS(at_state_t *s, const char *t)
|
|
|
3114 {
|
|
|
3115 /* V.250 6.6.1 - Data compression */
|
|
|
3116 /* TODO: */
|
|
|
3117 t += 3;
|
|
|
3118 if (!parse_out(s, &t, NULL, 1, "+DS:", ""))
|
|
|
3119 return NULL;
|
|
|
3120 return t;
|
|
|
3121 }
|
|
|
3122 /*- End of function --------------------------------------------------------*/
|
|
|
3123
|
|
|
3124 static const char *at_cmd_plus_DS44(at_state_t *s, const char *t)
|
|
|
3125 {
|
|
|
3126 /* V.250 6.6.2 - V.44 data compression */
|
|
|
3127 /* TODO: */
|
|
|
3128 t += 5;
|
|
|
3129 return t;
|
|
|
3130 }
|
|
|
3131 /*- End of function --------------------------------------------------------*/
|
|
|
3132
|
|
|
3133 static const char *at_cmd_plus_EB(at_state_t *s, const char *t)
|
|
|
3134 {
|
|
|
3135 /* V.250 6.5.2 - Break handling in error control operation */
|
|
|
3136 /* TODO: */
|
|
|
3137 t += 3;
|
|
|
3138 if (!parse_out(s, &t, NULL, 1, "+EB:", ""))
|
|
|
3139 return NULL;
|
|
|
3140 return t;
|
|
|
3141 }
|
|
|
3142 /*- End of function --------------------------------------------------------*/
|
|
|
3143
|
|
|
3144 static const char *at_cmd_plus_EFCS(at_state_t *s, const char *t)
|
|
|
3145 {
|
|
|
3146 /* V.250 6.5.4 - 32-bit frame check sequence */
|
|
|
3147 /* TODO: */
|
|
|
3148 t += 5;
|
|
|
3149 if (!parse_out(s, &t, NULL, 2, "+EFCS:", "(0-2)"))
|
|
|
3150 return NULL;
|
|
|
3151 return t;
|
|
|
3152 }
|
|
|
3153 /*- End of function --------------------------------------------------------*/
|
|
|
3154
|
|
|
3155 static const char *at_cmd_plus_EFRAM(at_state_t *s, const char *t)
|
|
|
3156 {
|
|
|
3157 /* V.250 6.5.8 - Frame length */
|
|
|
3158 /* TODO: */
|
|
|
3159 t += 6;
|
|
|
3160 if (!parse_2_out(s, &t, NULL, 65535, NULL, 65535, "+EFRAM:", "(1-65535),(1-65535)"))
|
|
|
3161 return NULL;
|
|
|
3162 return t;
|
|
|
3163 }
|
|
|
3164 /*- End of function --------------------------------------------------------*/
|
|
|
3165
|
|
|
3166 static const char *at_cmd_plus_ER(at_state_t *s, const char *t)
|
|
|
3167 {
|
|
|
3168 /* V.250 6.5.5 - Error control reporting */
|
|
|
3169 /* 0 Error control reporting disabled (no +ER intermediate result code transmitted)
|
|
|
3170 1 Error control reporting enabled (+ER intermediate result code transmitted) */
|
|
|
3171 /* TODO: */
|
|
|
3172 t += 3;
|
|
|
3173 if (!parse_out(s, &t, NULL, 1, "+ER:", "(0,1)"))
|
|
|
3174 return NULL;
|
|
|
3175 return t;
|
|
|
3176 }
|
|
|
3177 /*- End of function --------------------------------------------------------*/
|
|
|
3178
|
|
|
3179 static const char *at_cmd_plus_ES(at_state_t *s, const char *t)
|
|
|
3180 {
|
|
|
3181 /* V.250 6.5.1 - Error control selection */
|
|
|
3182 /* TODO: */
|
|
|
3183 t += 3;
|
|
|
3184 return t;
|
|
|
3185 }
|
|
|
3186 /*- End of function --------------------------------------------------------*/
|
|
|
3187
|
|
|
3188 static const char *at_cmd_plus_ESR(at_state_t *s, const char *t)
|
|
|
3189 {
|
|
|
3190 /* V.250 6.5.3 - Selective repeat */
|
|
|
3191 /* TODO: */
|
|
|
3192 t += 4;
|
|
|
3193 return t;
|
|
|
3194 }
|
|
|
3195 /*- End of function --------------------------------------------------------*/
|
|
|
3196
|
|
|
3197 static const char *at_cmd_plus_ETBM(at_state_t *s, const char *t)
|
|
|
3198 {
|
|
|
3199 /* V.250 6.5.6 - Call termination buffer management */
|
|
|
3200 /* TODO: */
|
|
|
3201 t += 5;
|
|
|
3202 if (!parse_2_out(s, &t, NULL, 2, NULL, 2, "+ETBM:", "(0-2),(0-2),(0-30)"))
|
|
|
3203 return NULL;
|
|
|
3204 return t;
|
|
|
3205 }
|
|
|
3206 /*- End of function --------------------------------------------------------*/
|
|
|
3207
|
|
|
3208 static const char *at_cmd_plus_EWIND(at_state_t *s, const char *t)
|
|
|
3209 {
|
|
|
3210 /* V.250 6.5.7 - Window size */
|
|
|
3211 /* TODO: */
|
|
|
3212 t += 6;
|
|
|
3213 if (!parse_2_out(s, &t, &s->rx_window, 127, &s->tx_window, 127, "+EWIND:", "(1-127),(1-127)"))
|
|
|
3214 return NULL;
|
|
|
3215 return t;
|
|
|
3216 }
|
|
|
3217 /*- End of function --------------------------------------------------------*/
|
|
|
3218
|
|
|
3219 static const char *at_cmd_plus_FAA(at_state_t *s, const char *t)
|
|
|
3220 {
|
|
|
3221 /* T.32 8.5.2.5 - Adaptive Answer parameter */
|
|
|
3222 /* TODO */
|
|
|
3223 t += 4;
|
|
|
3224 return t;
|
|
|
3225 }
|
|
|
3226 /*- End of function --------------------------------------------------------*/
|
|
|
3227
|
|
|
3228 static const char *at_cmd_plus_FAP(at_state_t *s, const char *t)
|
|
|
3229 {
|
|
|
3230 /* T.32 8.5.1.12 - Addressing and polling capabilities parameter */
|
|
|
3231 /* TODO */
|
|
|
3232 t += 4;
|
|
|
3233 return t;
|
|
|
3234 }
|
|
|
3235 /*- End of function --------------------------------------------------------*/
|
|
|
3236
|
|
|
3237 static const char *at_cmd_plus_FAR(at_state_t *s, const char *t)
|
|
|
3238 {
|
|
|
3239 /* T.31 8.5.1 - Adaptive reception control */
|
|
|
3240 t += 4;
|
|
|
3241 if (!parse_out(s, &t, &s->p.adaptive_receive, 1, NULL, "0,1"))
|
|
|
3242 return NULL;
|
|
|
3243 return t;
|
|
|
3244 }
|
|
|
3245 /*- End of function --------------------------------------------------------*/
|
|
|
3246
|
|
|
3247 static const char *at_cmd_plus_FBO(at_state_t *s, const char *t)
|
|
|
3248 {
|
|
|
3249 /* T.32 8.5.3.4 - Phase C data bit order */
|
|
|
3250 /* TODO */
|
|
|
3251 t += 4;
|
|
|
3252 return t;
|
|
|
3253 }
|
|
|
3254 /*- End of function --------------------------------------------------------*/
|
|
|
3255
|
|
|
3256 static const char *at_cmd_plus_FBS(at_state_t *s, const char *t)
|
|
|
3257 {
|
|
|
3258 /* T.32 8.5.3.2 - Buffer Size, read only parameter */
|
|
|
3259 /* TODO */
|
|
|
3260 t += 4;
|
|
|
3261 return t;
|
|
|
3262 }
|
|
|
3263 /*- End of function --------------------------------------------------------*/
|
|
|
3264
|
|
|
3265 static const char *at_cmd_plus_FBU(at_state_t *s, const char *t)
|
|
|
3266 {
|
|
|
3267 /* T.32 8.5.1.10 - HDLC Frame Reporting parameter */
|
|
|
3268 /* TODO */
|
|
|
3269 t += 4;
|
|
|
3270 return t;
|
|
|
3271 }
|
|
|
3272 /*- End of function --------------------------------------------------------*/
|
|
|
3273
|
|
|
3274 static const char *at_cmd_plus_FCC(at_state_t *s, const char *t)
|
|
|
3275 {
|
|
|
3276 /* T.32 8.5.1.1 - DCE capabilities parameters */
|
|
|
3277 /* TODO */
|
|
|
3278 t += 4;
|
|
|
3279 return t;
|
|
|
3280 }
|
|
|
3281 /*- End of function --------------------------------------------------------*/
|
|
|
3282
|
|
|
3283 static const char *at_cmd_plus_FCL(at_state_t *s, const char *t)
|
|
|
3284 {
|
|
|
3285 /* T.31 8.5.2 - Carrier loss timeout */
|
|
|
3286 t += 4;
|
|
|
3287 if (!parse_out(s, &t, &s->carrier_loss_timeout, 255, NULL, "(0-255)"))
|
|
|
3288 return NULL;
|
|
|
3289 return t;
|
|
|
3290 }
|
|
|
3291 /*- End of function --------------------------------------------------------*/
|
|
|
3292
|
|
|
3293 static const char *at_cmd_plus_FCLASS(at_state_t *s, const char *t)
|
|
|
3294 {
|
|
|
3295 /* T.31 8.2 - Capabilities identification and control */
|
|
|
3296 t += 7;
|
|
|
3297 /* T.31 says the reply string should be "0,1.0", however making
|
|
|
3298 it "0,1,1.0" makes things compatible with a lot more software
|
|
|
3299 that may be expecting a pre-T.31 modem. */
|
|
|
3300 if (!parse_string_out(s, &t, &s->fclass_mode, 1, NULL, "0,1,1.0"))
|
|
|
3301 return NULL;
|
|
|
3302 return t;
|
|
|
3303 }
|
|
|
3304 /*- End of function --------------------------------------------------------*/
|
|
|
3305
|
|
|
3306 static const char *at_cmd_plus_FCQ(at_state_t *s, const char *t)
|
|
|
3307 {
|
|
|
3308 /* T.32 8.5.2.3 - Copy quality checking parameter */
|
|
|
3309 /* TODO */
|
|
|
3310 t += 4;
|
|
|
3311 return t;
|
|
|
3312 }
|
|
|
3313 /*- End of function --------------------------------------------------------*/
|
|
|
3314
|
|
|
3315 static const char *at_cmd_plus_FCR(at_state_t *s, const char *t)
|
|
|
3316 {
|
|
|
3317 /* T.32 8.5.1.9 - Capability to receive parameter */
|
|
|
3318 /* TODO */
|
|
|
3319 t += 4;
|
|
|
3320 return t;
|
|
|
3321 }
|
|
|
3322 /*- End of function --------------------------------------------------------*/
|
|
|
3323
|
|
|
3324 static const char *at_cmd_plus_FCS(at_state_t *s, const char *t)
|
|
|
3325 {
|
|
|
3326 /* T.32 8.5.1.3 - Current Session Results parameters */
|
|
|
3327 /* TODO */
|
|
|
3328 t += 4;
|
|
|
3329 return t;
|
|
|
3330 }
|
|
|
3331 /*- End of function --------------------------------------------------------*/
|
|
|
3332
|
|
|
3333 static const char *at_cmd_plus_FCT(at_state_t *s, const char *t)
|
|
|
3334 {
|
|
|
3335 /* T.32 8.5.2.6 - DTE phase C timeout parameter */
|
|
|
3336 /* TODO */
|
|
|
3337 t += 4;
|
|
|
3338 return t;
|
|
|
3339 }
|
|
|
3340 /*- End of function --------------------------------------------------------*/
|
|
|
3341
|
|
|
3342 static const char *at_cmd_plus_FDD(at_state_t *s, const char *t)
|
|
|
3343 {
|
|
|
3344 /* T.31 8.5.3 - Double escape character replacement */
|
|
|
3345 t += 4;
|
|
|
3346 if (!parse_out(s, &t, &s->p.double_escape, 1, NULL, "(0,1)"))
|
|
|
3347 return NULL;
|
|
|
3348 return t;
|
|
|
3349 }
|
|
|
3350 /*- End of function --------------------------------------------------------*/
|
|
|
3351
|
|
|
3352 static const char *at_cmd_plus_FDR(at_state_t *s, const char *t)
|
|
|
3353 {
|
|
|
3354 /* T.32 8.3.4 - Data reception command */
|
|
|
3355 /* TODO */
|
|
|
3356 t += 4;
|
|
|
3357 return t;
|
|
|
3358 }
|
|
|
3359 /*- End of function --------------------------------------------------------*/
|
|
|
3360
|
|
|
3361 static const char *at_cmd_plus_FDT(at_state_t *s, const char *t)
|
|
|
3362 {
|
|
|
3363 /* T.32 8.3.3 - Data transmission command */
|
|
|
3364 /* TODO */
|
|
|
3365 t += 4;
|
|
|
3366 return t;
|
|
|
3367 }
|
|
|
3368 /*- End of function --------------------------------------------------------*/
|
|
|
3369
|
|
|
3370 static const char *at_cmd_plus_FEA(at_state_t *s, const char *t)
|
|
|
3371 {
|
|
|
3372 /* T.32 8.5.3.5 - Phase C received EOL alignment parameter */
|
|
|
3373 /* TODO */
|
|
|
3374 t += 4;
|
|
|
3375 return t;
|
|
|
3376 }
|
|
|
3377 /*- End of function --------------------------------------------------------*/
|
|
|
3378
|
|
|
3379 static const char *at_cmd_plus_FFC(at_state_t *s, const char *t)
|
|
|
3380 {
|
|
|
3381 /* T.32 8.5.3.6 - Format conversion parameter */
|
|
|
3382 /* TODO */
|
|
|
3383 t += 4;
|
|
|
3384 return t;
|
|
|
3385 }
|
|
|
3386 /*- End of function --------------------------------------------------------*/
|
|
|
3387
|
|
|
3388 static const char *at_cmd_plus_FFD(at_state_t *s, const char *t)
|
|
|
3389 {
|
|
|
3390 /* T.32 8.5.1.14 - File diagnostic message parameter */
|
|
|
3391 /* TODO */
|
|
|
3392 t += 4;
|
|
|
3393 return t;
|
|
|
3394 }
|
|
|
3395 /*- End of function --------------------------------------------------------*/
|
|
|
3396
|
|
|
3397 static const char *at_cmd_plus_FHS(at_state_t *s, const char *t)
|
|
|
3398 {
|
|
|
3399 /* T.32 8.5.2.7 - Call termination status parameter */
|
|
|
3400 /* TODO */
|
|
|
3401 t += 4;
|
|
|
3402 return t;
|
|
|
3403 }
|
|
|
3404 /*- End of function --------------------------------------------------------*/
|
|
|
3405
|
|
|
3406 static const char *at_cmd_plus_FIE(at_state_t *s, const char *t)
|
|
|
3407 {
|
|
|
3408 /* T.32 8.5.2.1 - Procedure interrupt enable parameter */
|
|
|
3409 /* TODO */
|
|
|
3410 t += 4;
|
|
|
3411 return t;
|
|
|
3412 }
|
|
|
3413 /*- End of function --------------------------------------------------------*/
|
|
|
3414
|
|
|
3415 static const char *at_cmd_plus_FIP(at_state_t *s, const char *t)
|
|
|
3416 {
|
|
|
3417 /* T.32 8.3.6 - Initialize Facsimile Parameters */
|
|
|
3418 t += 4;
|
|
|
3419 return t;
|
|
|
3420 }
|
|
|
3421 /*- End of function --------------------------------------------------------*/
|
|
|
3422
|
|
|
3423 static const char *at_cmd_plus_FIS(at_state_t *s, const char *t)
|
|
|
3424 {
|
|
|
3425 /* T.32 8.5.1.2 - Current session parameters */
|
|
|
3426 /* TODO */
|
|
|
3427 t += 4;
|
|
|
3428 return t;
|
|
|
3429 }
|
|
|
3430 /*- End of function --------------------------------------------------------*/
|
|
|
3431
|
|
|
3432 static const char *at_cmd_plus_FIT(at_state_t *s, const char *t)
|
|
|
3433 {
|
|
|
3434 /* T.31 8.5.4 - DTE inactivity timeout */
|
|
|
3435 t += 4;
|
|
|
3436 if (!parse_2_out(s, &t, &s->dte_inactivity_timeout, 255, &s->dte_inactivity_action, 1, "+FIT:", "(0-255),(0-1)"))
|
|
|
3437 return NULL;
|
|
|
3438 return t;
|
|
|
3439 }
|
|
|
3440 /*- End of function --------------------------------------------------------*/
|
|
|
3441
|
|
|
3442 static const char *at_cmd_plus_FKS(at_state_t *s, const char *t)
|
|
|
3443 {
|
|
|
3444 /* T.32 8.3.5 - Session termination command */
|
|
|
3445 /* TODO: */
|
|
|
3446 t += 4;
|
|
|
3447 return t;
|
|
|
3448 }
|
|
|
3449 /*- End of function --------------------------------------------------------*/
|
|
|
3450
|
|
|
3451 static const char *at_cmd_plus_FLI(at_state_t *s, const char *t)
|
|
|
3452 {
|
|
|
3453 /* T.32 8.5.1.5 - Local ID string parameter, TSI or CSI */
|
|
|
3454 /* TODO: */
|
|
|
3455 t += 4;
|
|
|
3456 return t;
|
|
|
3457 }
|
|
|
3458 /*- End of function --------------------------------------------------------*/
|
|
|
3459
|
|
|
3460 static const char *at_cmd_plus_FLO(at_state_t *s, const char *t)
|
|
|
3461 {
|
|
|
3462 /* T.31 Annex A */
|
|
|
3463 /* Implement something similar to the V.250 +IFC command */
|
|
|
3464 /* TODO: */
|
|
|
3465 t += 4;
|
|
|
3466 return t;
|
|
|
3467 }
|
|
|
3468 /*- End of function --------------------------------------------------------*/
|
|
|
3469
|
|
|
3470 static const char *at_cmd_plus_FLP(at_state_t *s, const char *t)
|
|
|
3471 {
|
|
|
3472 /* T.32 8.5.1.7 - Indicate document to poll parameter */
|
|
|
3473 /* TODO: */
|
|
|
3474 t += 4;
|
|
|
3475 return t;
|
|
|
3476 }
|
|
|
3477 /*- End of function --------------------------------------------------------*/
|
|
|
3478
|
|
|
3479 static const char *at_cmd_plus_FMI(at_state_t *s, const char *t)
|
|
|
3480 {
|
|
|
3481 /* T.31 says to duplicate +GMI */
|
|
|
3482 t += 4;
|
|
|
3483 if (t[0] == '?')
|
|
|
3484 {
|
|
|
3485 at_put_response(s, manufacturer);
|
|
|
3486 t += 1;
|
|
|
3487 }
|
|
|
3488 return t;
|
|
|
3489 }
|
|
|
3490 /*- End of function --------------------------------------------------------*/
|
|
|
3491
|
|
|
3492 static const char *at_cmd_plus_FMM(at_state_t *s, const char *t)
|
|
|
3493 {
|
|
|
3494 /* T.31 says to duplicate +GMM */
|
|
|
3495 t += 4;
|
|
|
3496 if (t[0] == '?')
|
|
|
3497 {
|
|
|
3498 at_put_response(s, model);
|
|
|
3499 t += 1;
|
|
|
3500 }
|
|
|
3501 return t;
|
|
|
3502 }
|
|
|
3503 /*- End of function --------------------------------------------------------*/
|
|
|
3504
|
|
|
3505 static const char *at_cmd_plus_FMR(at_state_t *s, const char *t)
|
|
|
3506 {
|
|
|
3507 /* T.31 says to duplicate +GMR */
|
|
|
3508 t += 4;
|
|
|
3509 if (t[0] == '?')
|
|
|
3510 {
|
|
|
3511 at_put_response(s, revision);
|
|
|
3512 t += 1;
|
|
|
3513 }
|
|
|
3514 return t;
|
|
|
3515 }
|
|
|
3516 /*- End of function --------------------------------------------------------*/
|
|
|
3517
|
|
|
3518 static const char *at_cmd_plus_FMS(at_state_t *s, const char *t)
|
|
|
3519 {
|
|
|
3520 /* T.32 8.5.2.9 - Minimum phase C speed parameter */
|
|
|
3521 t += 4;
|
|
|
3522 return t;
|
|
|
3523 }
|
|
|
3524 /*- End of function --------------------------------------------------------*/
|
|
|
3525
|
|
|
3526 static const char *at_cmd_plus_FND(at_state_t *s, const char *t)
|
|
|
3527 {
|
|
|
3528 /* T.32 8.5.2.10 - Non-Standard Message Data Indication parameter */
|
|
|
3529 t += 4;
|
|
|
3530 return t;
|
|
|
3531 }
|
|
|
3532 /*- End of function --------------------------------------------------------*/
|
|
|
3533
|
|
|
3534 static const char *at_cmd_plus_FNR(at_state_t *s, const char *t)
|
|
|
3535 {
|
|
|
3536 /* T.32 8.5.1.11 - Negotiation message reporting control parameters */
|
|
|
3537 t += 4;
|
|
|
3538 return t;
|
|
|
3539 }
|
|
|
3540 /*- End of function --------------------------------------------------------*/
|
|
|
3541
|
|
|
3542 static const char *at_cmd_plus_FNS(at_state_t *s, const char *t)
|
|
|
3543 {
|
|
|
3544 /* T.32 8.5.1.6 - Non-Standard Frame FIF parameter */
|
|
|
3545 t += 4;
|
|
|
3546 return t;
|
|
|
3547 }
|
|
|
3548 /*- End of function --------------------------------------------------------*/
|
|
|
3549
|
|
|
3550 static const char *at_cmd_plus_FPA(at_state_t *s, const char *t)
|
|
|
3551 {
|
|
|
3552 /* T.32 8.5.1.13 - Selective polling address parameter */
|
|
|
3553 t += 4;
|
|
|
3554 return t;
|
|
|
3555 }
|
|
|
3556 /*- End of function --------------------------------------------------------*/
|
|
|
3557
|
|
|
3558 static const char *at_cmd_plus_FPI(at_state_t *s, const char *t)
|
|
|
3559 {
|
|
|
3560 /* T.32 8.5.1.5 - Local Polling ID String parameter */
|
|
|
3561 t += 4;
|
|
|
3562 return t;
|
|
|
3563 }
|
|
|
3564 /*- End of function --------------------------------------------------------*/
|
|
|
3565
|
|
|
3566 static const char *at_cmd_plus_FPP(at_state_t *s, const char *t)
|
|
|
3567 {
|
|
|
3568 /* T.32 8.5.3 - Facsimile packet protocol */
|
|
|
3569 t += 4;
|
|
|
3570 return t;
|
|
|
3571 }
|
|
|
3572 /*- End of function --------------------------------------------------------*/
|
|
|
3573
|
|
|
3574 static const char *at_cmd_plus_FPR(at_state_t *s, const char *t)
|
|
|
3575 {
|
|
|
3576 /* T.31 Annex A */
|
|
|
3577 /* Implement something similar to the V.250 +IPR command */
|
|
|
3578 t += 4;
|
|
|
3579 if (!parse_out(s, &t, &s->dte_rate, 115200, NULL, "115200"))
|
|
|
3580 return NULL;
|
|
|
3581 return t;
|
|
|
3582 }
|
|
|
3583 /*- End of function --------------------------------------------------------*/
|
|
|
3584
|
|
|
3585 static const char *at_cmd_plus_FPS(at_state_t *s, const char *t)
|
|
|
3586 {
|
|
|
3587 /* T.32 8.5.2.2 - Page Status parameter */
|
|
|
3588 t += 4;
|
|
|
3589 return t;
|
|
|
3590 }
|
|
|
3591 /*- End of function --------------------------------------------------------*/
|
|
|
3592
|
|
|
3593 static const char *at_cmd_plus_FPW(at_state_t *s, const char *t)
|
|
|
3594 {
|
|
|
3595 /* T.32 8.5.1.13 - PassWord parameter (Sending or Polling) */
|
|
|
3596 t += 4;
|
|
|
3597 return t;
|
|
|
3598 }
|
|
|
3599 /*- End of function --------------------------------------------------------*/
|
|
|
3600
|
|
|
3601 static const char *at_cmd_plus_FRH(at_state_t *s, const char *t)
|
|
|
3602 {
|
|
|
3603 /* T.31 8.3.6 - HDLC receive */
|
|
|
3604 if (!process_class1_cmd(s, &t))
|
|
|
3605 return NULL;
|
|
|
3606 return t;
|
|
|
3607 }
|
|
|
3608 /*- End of function --------------------------------------------------------*/
|
|
|
3609
|
|
|
3610 static const char *at_cmd_plus_FRM(at_state_t *s, const char *t)
|
|
|
3611 {
|
|
|
3612 /* T.31 8.3.4 - Facsimile receive */
|
|
|
3613 if (!process_class1_cmd(s, &t))
|
|
|
3614 return NULL;
|
|
|
3615 return t;
|
|
|
3616 }
|
|
|
3617 /*- End of function --------------------------------------------------------*/
|
|
|
3618
|
|
|
3619 static const char *at_cmd_plus_FRQ(at_state_t *s, const char *t)
|
|
|
3620 {
|
|
|
3621 /* T.32 8.5.2.4 - Receive Quality Thresholds parameters */
|
|
|
3622 /* TODO */
|
|
|
3623 t += 4;
|
|
|
3624 return t;
|
|
|
3625 }
|
|
|
3626 /*- End of function --------------------------------------------------------*/
|
|
|
3627
|
|
|
3628 static const char *at_cmd_plus_FRS(at_state_t *s, const char *t)
|
|
|
3629 {
|
|
|
3630 /* T.31 8.3.2 - Receive silence */
|
|
|
3631 if (!process_class1_cmd(s, &t))
|
|
|
3632 return NULL;
|
|
|
3633 return t;
|
|
|
3634 }
|
|
|
3635 /*- End of function --------------------------------------------------------*/
|
|
|
3636
|
|
|
3637 static const char *at_cmd_plus_FRY(at_state_t *s, const char *t)
|
|
|
3638 {
|
|
|
3639 /* T.32 8.5.2.8 - ECM Retry Value parameter */
|
|
|
3640 /* TODO */
|
|
|
3641 t += 4;
|
|
|
3642 return t;
|
|
|
3643 }
|
|
|
3644 /*- End of function --------------------------------------------------------*/
|
|
|
3645
|
|
|
3646 static const char *at_cmd_plus_FSA(at_state_t *s, const char *t)
|
|
|
3647 {
|
|
|
3648 /* T.32 8.5.1.13 - Subaddress parameter */
|
|
|
3649 /* TODO */
|
|
|
3650 t += 4;
|
|
|
3651 return t;
|
|
|
3652 }
|
|
|
3653 /*- End of function --------------------------------------------------------*/
|
|
|
3654
|
|
|
3655 static const char *at_cmd_plus_FSP(at_state_t *s, const char *t)
|
|
|
3656 {
|
|
|
3657 /* T.32 8.5.1.8 - Request to poll parameter */
|
|
|
3658 /* TODO */
|
|
|
3659 t += 4;
|
|
|
3660 return t;
|
|
|
3661 }
|
|
|
3662 /*- End of function --------------------------------------------------------*/
|
|
|
3663
|
|
|
3664 static const char *at_cmd_plus_FTH(at_state_t *s, const char *t)
|
|
|
3665 {
|
|
|
3666 /* T.31 8.3.5 - HDLC transmit */
|
|
|
3667 if (!process_class1_cmd(s, &t))
|
|
|
3668 return NULL;
|
|
|
3669 return t;
|
|
|
3670 }
|
|
|
3671 /*- End of function --------------------------------------------------------*/
|
|
|
3672
|
|
|
3673 static const char *at_cmd_plus_FTM(at_state_t *s, const char *t)
|
|
|
3674 {
|
|
|
3675 /* T.31 8.3.3 - Facsimile transmit */
|
|
|
3676 if (!process_class1_cmd(s, &t))
|
|
|
3677 return NULL;
|
|
|
3678 return t;
|
|
|
3679 }
|
|
|
3680 /*- End of function --------------------------------------------------------*/
|
|
|
3681
|
|
|
3682 static const char *at_cmd_plus_FTS(at_state_t *s, const char *t)
|
|
|
3683 {
|
|
|
3684 /* T.31 8.3.1 - Transmit silence */
|
|
|
3685 if (!process_class1_cmd(s, &t))
|
|
|
3686 return NULL;
|
|
|
3687 return t;
|
|
|
3688 }
|
|
|
3689 /*- End of function --------------------------------------------------------*/
|
|
|
3690
|
|
|
3691 static const char *at_cmd_plus_GCAP(at_state_t *s, const char *t)
|
|
|
3692 {
|
|
|
3693 /* V.250 6.1.9 - Request complete capabilities list */
|
|
|
3694 t += 5;
|
|
|
3695 /* Response elements
|
|
|
3696 +FCLASS +F (FAX) commands
|
|
|
3697 +MS +M (modulation control) commands +MS and +MR
|
|
|
3698 +MV18S +M (modulation control) commands +MV18S and +MV18R
|
|
|
3699 +ES +E (error control) commands +ES, +EB, +ER, +EFCS, and +ETBM
|
|
|
3700 +DS +D (data compression) commands +DS and +DR */
|
|
|
3701 /* TODO: make this adapt to the configuration we really have. */
|
|
|
3702 if (t[0] == '?')
|
|
|
3703 {
|
|
|
3704 at_put_response(s, "+GCAP:+FCLASS");
|
|
|
3705 t += 1;
|
|
|
3706 }
|
|
|
3707 return t;
|
|
|
3708 }
|
|
|
3709 /*- End of function --------------------------------------------------------*/
|
|
|
3710
|
|
|
3711 static const char *at_cmd_plus_GCI(at_state_t *s, const char *t)
|
|
|
3712 {
|
|
|
3713 /* V.250 6.1.10 - Country of installation, */
|
|
|
3714 t += 4;
|
|
|
3715 if (!parse_hex_out(s, &t, &s->country_of_installation, 255, "+GCI:", "(00-FF)"))
|
|
|
3716 return NULL;
|
|
|
3717 return t;
|
|
|
3718 }
|
|
|
3719 /*- End of function --------------------------------------------------------*/
|
|
|
3720
|
|
|
3721 static const char *at_cmd_plus_GMI(at_state_t *s, const char *t)
|
|
|
3722 {
|
|
|
3723 /* V.250 6.1.4 - Request manufacturer identification */
|
|
|
3724 t += 4;
|
|
|
3725 if (t[0] == '?')
|
|
|
3726 {
|
|
|
3727 at_put_response(s, manufacturer);
|
|
|
3728 t += 1;
|
|
|
3729 }
|
|
|
3730 return t;
|
|
|
3731 }
|
|
|
3732 /*- End of function --------------------------------------------------------*/
|
|
|
3733
|
|
|
3734 static const char *at_cmd_plus_GMM(at_state_t *s, const char *t)
|
|
|
3735 {
|
|
|
3736 /* V.250 6.1.5 - Request model identification */
|
|
|
3737 t += 4;
|
|
|
3738 if (t[0] == '?')
|
|
|
3739 {
|
|
|
3740 at_put_response(s, model);
|
|
|
3741 t += 1;
|
|
|
3742 }
|
|
|
3743 return t;
|
|
|
3744 }
|
|
|
3745 /*- End of function --------------------------------------------------------*/
|
|
|
3746
|
|
|
3747 static const char *at_cmd_plus_GMR(at_state_t *s, const char *t)
|
|
|
3748 {
|
|
|
3749 /* V.250 6.1.6 - Request revision identification */
|
|
|
3750 t += 4;
|
|
|
3751 if (t[0] == '?')
|
|
|
3752 {
|
|
|
3753 at_put_response(s, revision);
|
|
|
3754 t += 1;
|
|
|
3755 }
|
|
|
3756 return t;
|
|
|
3757 }
|
|
|
3758 /*- End of function --------------------------------------------------------*/
|
|
|
3759
|
|
|
3760 static const char *at_cmd_plus_GOI(at_state_t *s, const char *t)
|
|
|
3761 {
|
|
|
3762 /* V.250 6.1.8 - Request global object identification */
|
|
|
3763 /* TODO: */
|
|
|
3764 t += 4;
|
|
|
3765 if (t[0] == '?')
|
|
|
3766 {
|
|
|
3767 at_put_response(s, GLOBAL_OBJECT_IDENTITY);
|
|
|
3768 t += 1;
|
|
|
3769 }
|
|
|
3770 return t;
|
|
|
3771 }
|
|
|
3772 /*- End of function --------------------------------------------------------*/
|
|
|
3773
|
|
|
3774 static const char *at_cmd_plus_GSN(at_state_t *s, const char *t)
|
|
|
3775 {
|
|
|
3776 /* V.250 6.1.7 - Request product serial number identification */
|
|
|
3777 /* TODO: */
|
|
|
3778 t += 4;
|
|
|
3779 if (t[0] == '?')
|
|
|
3780 {
|
|
|
3781 at_put_response(s, SERIAL_NUMBER);
|
|
|
3782 t += 1;
|
|
|
3783 }
|
|
|
3784 return t;
|
|
|
3785 }
|
|
|
3786 /*- End of function --------------------------------------------------------*/
|
|
|
3787
|
|
|
3788 static const char *at_cmd_plus_IBC(at_state_t *s, const char *t)
|
|
|
3789 {
|
|
|
3790 /* TIA-617 8.3 - Control of in-band control */
|
|
|
3791 /* TODO: */
|
|
|
3792 t += 4;
|
|
|
3793 return t;
|
|
|
3794 }
|
|
|
3795 /*- End of function --------------------------------------------------------*/
|
|
|
3796
|
|
|
3797 static const char *at_cmd_plus_IBM(at_state_t *s, const char *t)
|
|
|
3798 {
|
|
|
3799 /* TIA-617 8.4 - In-Band MARK idle reporting control */
|
|
|
3800 /* TODO: */
|
|
|
3801 t += 4;
|
|
|
3802 return t;
|
|
|
3803 }
|
|
|
3804 /*- End of function --------------------------------------------------------*/
|
|
|
3805
|
|
|
3806 static const char *at_cmd_plus_ICF(at_state_t *s, const char *t)
|
|
|
3807 {
|
|
|
3808 /* V.250 6.2.11 - DTE-DCE character framing */
|
|
|
3809 t += 4;
|
|
|
3810 /* Character format
|
|
|
3811 0 auto detect
|
|
|
3812 1 8 data 2 stop
|
|
|
3813 2 8 data 1 parity 1 stop
|
|
|
3814 3 8 data 1 stop
|
|
|
3815 4 7 data 2 stop
|
|
|
3816 5 7 data 1 parity 1 stop
|
|
|
3817 6 7 data 1 stop
|
|
|
3818
|
|
|
3819 parity
|
|
|
3820 0 Odd
|
|
|
3821 1 Even
|
|
|
3822 2 Mark
|
|
|
3823 3 Space */
|
|
|
3824 if (!parse_2_out(s, &t, &s->dte_char_format, 6, &s->dte_parity, 3, "+ICF:", "(0-6),(0-3)"))
|
|
|
3825 return NULL;
|
|
|
3826 return t;
|
|
|
3827 }
|
|
|
3828 /*- End of function --------------------------------------------------------*/
|
|
|
3829
|
|
|
3830 static const char *at_cmd_plus_ICLOK(at_state_t *s, const char *t)
|
|
|
3831 {
|
|
|
3832 /* V.250 6.2.14 - Select sync transmit clock source */
|
|
|
3833 t += 6;
|
|
|
3834 if (!parse_out(s, &t, &s->sync_tx_clock_source, 2, "+ICLOK:", "(0-2)"))
|
|
|
3835 return NULL;
|
|
|
3836 return t;
|
|
|
3837 }
|
|
|
3838 /*- End of function --------------------------------------------------------*/
|
|
|
3839
|
|
|
3840 static const char *at_cmd_plus_IDSR(at_state_t *s, const char *t)
|
|
|
3841 {
|
|
|
3842 /* V.250 6.2.16 - Select data set ready option */
|
|
|
3843 t += 5;
|
|
|
3844 if (!parse_out(s, &t, &s->dsr_option, 2, "+IDSR:", "(0-2)"))
|
|
|
3845 return NULL;
|
|
|
3846 return t;
|
|
|
3847 }
|
|
|
3848 /*- End of function --------------------------------------------------------*/
|
|
|
3849
|
|
|
3850 static const char *at_cmd_plus_IFC(at_state_t *s, const char *t)
|
|
|
3851 {
|
|
|
3852 /* V.250 6.2.12 - DTE-DCE local flow control */
|
|
|
3853 /* TODO: */
|
|
|
3854 t += 4;
|
|
|
3855 return t;
|
|
|
3856 }
|
|
|
3857 /*- End of function --------------------------------------------------------*/
|
|
|
3858
|
|
|
3859 static const char *at_cmd_plus_ILRR(at_state_t *s, const char *t)
|
|
|
3860 {
|
|
|
3861 /* V.250 6.2.13 - DTE-DCE local rate reporting */
|
|
|
3862 /* TODO: */
|
|
|
3863 t += 5;
|
|
|
3864 return t;
|
|
|
3865 }
|
|
|
3866 /*- End of function --------------------------------------------------------*/
|
|
|
3867
|
|
|
3868 static const char *at_cmd_plus_ILSD(at_state_t *s, const char *t)
|
|
|
3869 {
|
|
|
3870 /* V.250 6.2.15 - Select long space disconnect option */
|
|
|
3871 t += 5;
|
|
|
3872 if (!parse_out(s, &t, &s->long_space_disconnect_option, 2, "+ILSD:", "(0,1)"))
|
|
|
3873 return NULL;
|
|
|
3874 return t;
|
|
|
3875 }
|
|
|
3876 /*- End of function --------------------------------------------------------*/
|
|
|
3877
|
|
|
3878 static const char *at_cmd_plus_IPR(at_state_t *s, const char *t)
|
|
|
3879 {
|
|
|
3880 /* V.250 6.2.10 - Fixed DTE rate */
|
|
|
3881 /* TODO: */
|
|
|
3882 t += 4;
|
|
|
3883 if (!parse_out(s, &t, &s->dte_rate, 115200, "+IPR:", "(115200),(115200)"))
|
|
|
3884 return NULL;
|
|
|
3885 return t;
|
|
|
3886 }
|
|
|
3887 /*- End of function --------------------------------------------------------*/
|
|
|
3888
|
|
|
3889 static const char *at_cmd_plus_IRTS(at_state_t *s, const char *t)
|
|
|
3890 {
|
|
|
3891 /* V.250 6.2.17 - Select synchronous mode RTS option */
|
|
|
3892 t += 5;
|
|
|
3893 if (!parse_out(s, &t, NULL, 1, "+IRTS:", "(0,1)"))
|
|
|
3894 return NULL;
|
|
|
3895 return t;
|
|
|
3896 }
|
|
|
3897 /*- End of function --------------------------------------------------------*/
|
|
|
3898
|
|
|
3899 static const char *at_cmd_plus_MA(at_state_t *s, const char *t)
|
|
|
3900 {
|
|
|
3901 /* V.250 6.4.2 - Modulation automode control */
|
|
|
3902 /* TODO: */
|
|
|
3903 t += 3;
|
|
|
3904 return t;
|
|
|
3905 }
|
|
|
3906 /*- End of function --------------------------------------------------------*/
|
|
|
3907
|
|
|
3908 static const char *at_cmd_plus_MR(at_state_t *s, const char *t)
|
|
|
3909 {
|
|
|
3910 /* V.250 6.4.3 - Modulation reporting control */
|
|
|
3911 /* 0 Disables reporting of modulation connection (+MCR: and +MRR: are not transmitted)
|
|
|
3912 1 Enables reporting of modulation connection (+MCR: and +MRR: are transmitted) */
|
|
|
3913 /* TODO: */
|
|
|
3914 t += 3;
|
|
|
3915 if (!parse_out(s, &t, NULL, 1, "+MR:", "(0,1)"))
|
|
|
3916 return NULL;
|
|
|
3917 return t;
|
|
|
3918 }
|
|
|
3919 /*- End of function --------------------------------------------------------*/
|
|
|
3920
|
|
|
3921 static const char *at_cmd_plus_MS(at_state_t *s, const char *t)
|
|
|
3922 {
|
|
|
3923 /* V.250 6.4.1 - Modulation selection */
|
|
|
3924 /* TODO: */
|
|
|
3925 t += 3;
|
|
|
3926 return t;
|
|
|
3927 }
|
|
|
3928 /*- End of function --------------------------------------------------------*/
|
|
|
3929
|
|
|
3930 static const char *at_cmd_plus_MSC(at_state_t *s, const char *t)
|
|
|
3931 {
|
|
|
3932 /* V.250 6.4.8 - Seamless rate change enable */
|
|
|
3933 /* 0 Disables V.34 seamless rate change
|
|
|
3934 1 Enables V.34 seamless rate change */
|
|
|
3935 /* TODO: */
|
|
|
3936 t += 4;
|
|
|
3937 if (!parse_out(s, &t, NULL, 1, "+MSC:", "(0,1)"))
|
|
|
3938 return NULL;
|
|
|
3939 return t;
|
|
|
3940 }
|
|
|
3941 /*- End of function --------------------------------------------------------*/
|
|
|
3942
|
|
|
3943 static const char *at_cmd_plus_MV18AM(at_state_t *s, const char *t)
|
|
|
3944 {
|
|
|
3945 /* V.250 6.4.6 - V.18 answering message editing */
|
|
|
3946 /* TODO: */
|
|
|
3947 t += 7;
|
|
|
3948 return t;
|
|
|
3949 }
|
|
|
3950 /*- End of function --------------------------------------------------------*/
|
|
|
3951
|
|
|
3952 static const char *at_cmd_plus_MV18P(at_state_t *s, const char *t)
|
|
|
3953 {
|
|
|
3954 /* V.250 6.4.7 - Order of probes */
|
|
|
3955 /* 2 Send probe message in 5-bit (Baudot) mode
|
|
|
3956 3 Send probe message in DTMF mode
|
|
|
3957 4 Send probe message in EDT mode
|
|
|
3958 5 Send Rec. V.21 carrier as a probe
|
|
|
3959 6 Send Rec. V.23 carrier as a probe
|
|
|
3960 7 Send Bell 103 carrier as a probe */
|
|
|
3961 /* TODO: */
|
|
|
3962 t += 6;
|
|
|
3963 if (!parse_out(s, &t, NULL, 7, "+MV18P:", "(2-7)"))
|
|
|
3964 return NULL;
|
|
|
3965 return t;
|
|
|
3966 }
|
|
|
3967 /*- End of function --------------------------------------------------------*/
|
|
|
3968
|
|
|
3969 static const char *at_cmd_plus_MV18R(at_state_t *s, const char *t)
|
|
|
3970 {
|
|
|
3971 /* V.250 6.4.5 - V.18 reporting control */
|
|
|
3972 /* TODO: */
|
|
|
3973 t += 6;
|
|
|
3974 if (!parse_out(s, &t, NULL, 1, "+MV18R:", "(0,1)"))
|
|
|
3975 return NULL;
|
|
|
3976 return t;
|
|
|
3977 }
|
|
|
3978 /*- End of function --------------------------------------------------------*/
|
|
|
3979
|
|
|
3980 static const char *at_cmd_plus_MV18S(at_state_t *s, const char *t)
|
|
|
3981 {
|
|
|
3982 /* V.250 6.4.4 - V.18 selection */
|
|
|
3983 /* mode:
|
|
|
3984 0 Disables V.18 operation
|
|
|
3985 1 V.18 operation, auto detect mode
|
|
|
3986 2 V.18 operation, connect in 5-bit (Baudot) mode
|
|
|
3987 3 V.18 operation, connect in DTMF mode
|
|
|
3988 4 V.18 operation, connect in EDT mode
|
|
|
3989 5 V.18 operation, connect in V.21 mode
|
|
|
3990 6 V.18 operation, connect in V.23 mode
|
|
|
3991 7 V.18 operation, connect in Bell 103-type mode
|
|
|
3992
|
|
|
3993 dflt_ans_mode:
|
|
|
3994 0 Disables V.18 answer operation
|
|
|
3995 1 No default specified (auto detect)
|
|
|
3996 2 V.18 operation connect in 5-bit (Baudot) mode
|
|
|
3997 3 V.18 operation connect in DTMF mode
|
|
|
3998 4 V.18 operation connect in EDT mode
|
|
|
3999
|
|
|
4000 fbk_time_enable:
|
|
|
4001 0 Disable
|
|
|
4002 1 Enable
|
|
|
4003
|
|
|
4004 ans_msg_enable
|
|
|
4005 0 Disable
|
|
|
4006 1 Enable
|
|
|
4007
|
|
|
4008 probing_en
|
|
|
4009 0 Disable probing
|
|
|
4010 1 Enable probing
|
|
|
4011 2 Initiate probing */
|
|
|
4012 /* TODO: */
|
|
|
4013 t += 6;
|
|
|
4014 return t;
|
|
|
4015 }
|
|
|
4016 /*- End of function --------------------------------------------------------*/
|
|
|
4017
|
|
|
4018 static const char *at_cmd_plus_PCW(at_state_t *s, const char *t)
|
|
|
4019 {
|
|
|
4020 /* V.250 6.8.1 - Call waiting enable (V.92 DCE) */
|
|
|
4021 /* TODO: */
|
|
|
4022 t += 4;
|
|
|
4023 return t;
|
|
|
4024 }
|
|
|
4025 /*- End of function --------------------------------------------------------*/
|
|
|
4026
|
|
|
4027 static const char *at_cmd_plus_PIG(at_state_t *s, const char *t)
|
|
|
4028 {
|
|
|
4029 /* V.250 6.8.5 - PCM upstream ignore */
|
|
|
4030 /* TODO: */
|
|
|
4031 t += 4;
|
|
|
4032 return t;
|
|
|
4033 }
|
|
|
4034 /*- End of function --------------------------------------------------------*/
|
|
|
4035
|
|
|
4036 static const char *at_cmd_plus_PMH(at_state_t *s, const char *t)
|
|
|
4037 {
|
|
|
4038 /* V.250 6.8.2 - Modem on hold enable */
|
|
|
4039 /* TODO: */
|
|
|
4040 t += 4;
|
|
|
4041 return t;
|
|
|
4042 }
|
|
|
4043 /*- End of function --------------------------------------------------------*/
|
|
|
4044
|
|
|
4045 static const char *at_cmd_plus_PMHF(at_state_t *s, const char *t)
|
|
|
4046 {
|
|
|
4047 /* V.250 6.8.6 - V.92 Modem on hold hook flash */
|
|
|
4048 /* TODO: */
|
|
|
4049 t += 5;
|
|
|
4050 return t;
|
|
|
4051 }
|
|
|
4052 /*- End of function --------------------------------------------------------*/
|
|
|
4053
|
|
|
4054 static const char *at_cmd_plus_PMHR(at_state_t *s, const char *t)
|
|
|
4055 {
|
|
|
4056 /* V.250 6.8.4 - Initiate modem on hold */
|
|
|
4057 /* TODO: */
|
|
|
4058 t += 5;
|
|
|
4059 return t;
|
|
|
4060 }
|
|
|
4061 /*- End of function --------------------------------------------------------*/
|
|
|
4062
|
|
|
4063 static const char *at_cmd_plus_PMHT(at_state_t *s, const char *t)
|
|
|
4064 {
|
|
|
4065 /* V.250 6.8.3 - Modem on hold timer */
|
|
|
4066 /* TODO: */
|
|
|
4067 t += 5;
|
|
|
4068 return t;
|
|
|
4069 }
|
|
|
4070 /*- End of function --------------------------------------------------------*/
|
|
|
4071
|
|
|
4072 static const char *at_cmd_plus_PQC(at_state_t *s, const char *t)
|
|
|
4073 {
|
|
|
4074 /* V.250 6.8.7 - V.92 Phase 1 and Phase 2 Control */
|
|
|
4075 /* TODO: */
|
|
|
4076 t += 4;
|
|
|
4077 return t;
|
|
|
4078 }
|
|
|
4079 /*- End of function --------------------------------------------------------*/
|
|
|
4080
|
|
|
4081 static const char *at_cmd_plus_PSS(at_state_t *s, const char *t)
|
|
|
4082 {
|
|
|
4083 /* V.250 6.8.8 - V.92 Use Short Sequence */
|
|
|
4084 /* TODO: */
|
|
|
4085 t += 4;
|
|
|
4086 return t;
|
|
|
4087 }
|
|
|
4088 /*- End of function --------------------------------------------------------*/
|
|
|
4089
|
|
|
4090 static const char *at_cmd_plus_SAC(at_state_t *s, const char *t)
|
|
|
4091 {
|
|
|
4092 /* V.252 3.4 - Audio transmit configuration */
|
|
|
4093 /* TODO: */
|
|
|
4094 t += 4;
|
|
|
4095 return t;
|
|
|
4096 }
|
|
|
4097 /*- End of function --------------------------------------------------------*/
|
|
|
4098
|
|
|
4099 static const char *at_cmd_plus_SAM(at_state_t *s, const char *t)
|
|
|
4100 {
|
|
|
4101 /* V.252 3.5 - Audio receive mode */
|
|
|
4102 /* TODO: */
|
|
|
4103 t += 4;
|
|
|
4104 return t;
|
|
|
4105 }
|
|
|
4106 /*- End of function --------------------------------------------------------*/
|
|
|
4107
|
|
|
4108 static const char *at_cmd_plus_SAR(at_state_t *s, const char *t)
|
|
|
4109 {
|
|
|
4110 /* V.252 5.3 - Audio receive channel indication */
|
|
|
4111 /* TODO: */
|
|
|
4112 t += 4;
|
|
|
4113 return t;
|
|
|
4114 }
|
|
|
4115 /*- End of function --------------------------------------------------------*/
|
|
|
4116
|
|
|
4117 static const char *at_cmd_plus_SARR(at_state_t *s, const char *t)
|
|
|
4118 {
|
|
|
4119 /* V.252 3.9 - Audio indication reporting */
|
|
|
4120 /* TODO: */
|
|
|
4121 t += 5;
|
|
|
4122 return t;
|
|
|
4123 }
|
|
|
4124 /*- End of function --------------------------------------------------------*/
|
|
|
4125
|
|
|
4126 static const char *at_cmd_plus_SAT(at_state_t *s, const char *t)
|
|
|
4127 {
|
|
|
4128 /* V.252 5.4 - Audio transmit channel indication */
|
|
|
4129 /* TODO: */
|
|
|
4130 t += 4;
|
|
|
4131 return t;
|
|
|
4132 }
|
|
|
4133 /*- End of function --------------------------------------------------------*/
|
|
|
4134
|
|
|
4135 static const char *at_cmd_plus_SCRR(at_state_t *s, const char *t)
|
|
|
4136 {
|
|
|
4137 /* V.252 3.11 - Capabilities indication reporting */
|
|
|
4138 /* TODO: */
|
|
|
4139 t += 5;
|
|
|
4140 return t;
|
|
|
4141 }
|
|
|
4142 /*- End of function --------------------------------------------------------*/
|
|
|
4143
|
|
|
4144 static const char *at_cmd_plus_SDC(at_state_t *s, const char *t)
|
|
|
4145 {
|
|
|
4146 /* V.252 3.3 - Data configuration */
|
|
|
4147 /* TODO: */
|
|
|
4148 t += 4;
|
|
|
4149 return t;
|
|
|
4150 }
|
|
|
4151 /*- End of function --------------------------------------------------------*/
|
|
|
4152
|
|
|
4153 static const char *at_cmd_plus_SDI(at_state_t *s, const char *t)
|
|
|
4154 {
|
|
|
4155 /* V.252 5.2 - Data channel identification */
|
|
|
4156 /* TODO: */
|
|
|
4157 t += 4;
|
|
|
4158 return t;
|
|
|
4159 }
|
|
|
4160 /*- End of function --------------------------------------------------------*/
|
|
|
4161
|
|
|
4162 static const char *at_cmd_plus_SDR(at_state_t *s, const char *t)
|
|
|
4163 {
|
|
|
4164 /* V.252 3.8 - Data indication reporting */
|
|
|
4165 /* TODO: */
|
|
|
4166 t += 4;
|
|
|
4167 return t;
|
|
|
4168 }
|
|
|
4169 /*- End of function --------------------------------------------------------*/
|
|
|
4170
|
|
|
4171 static const char *at_cmd_plus_SRSC(at_state_t *s, const char *t)
|
|
|
4172 {
|
|
|
4173 /* V.252 5.1.2 - Remote terminal simultaneous capability indication */
|
|
|
4174 /* TODO: */
|
|
|
4175 t += 5;
|
|
|
4176 return t;
|
|
|
4177 }
|
|
|
4178 /*- End of function --------------------------------------------------------*/
|
|
|
4179
|
|
|
4180 static const char *at_cmd_plus_STC(at_state_t *s, const char *t)
|
|
|
4181 {
|
|
|
4182 /* V.252 3.1 - Terminal configuration */
|
|
|
4183 /* TODO: */
|
|
|
4184 t += 4;
|
|
|
4185 return t;
|
|
|
4186 }
|
|
|
4187 /*- End of function --------------------------------------------------------*/
|
|
|
4188
|
|
|
4189 static const char *at_cmd_plus_STH(at_state_t *s, const char *t)
|
|
|
4190 {
|
|
|
4191 /* V.252 3.2 - Close logical channel */
|
|
|
4192 /* TODO: */
|
|
|
4193 t += 4;
|
|
|
4194 return t;
|
|
|
4195 }
|
|
|
4196 /*- End of function --------------------------------------------------------*/
|
|
|
4197
|
|
|
4198 static const char *at_cmd_plus_SVC(at_state_t *s, const char *t)
|
|
|
4199 {
|
|
|
4200 /* V.252 3.6 - Video transmit configuration */
|
|
|
4201 /* TODO: */
|
|
|
4202 t += 4;
|
|
|
4203 return t;
|
|
|
4204 }
|
|
|
4205 /*- End of function --------------------------------------------------------*/
|
|
|
4206
|
|
|
4207 static const char *at_cmd_plus_SVM(at_state_t *s, const char *t)
|
|
|
4208 {
|
|
|
4209 /* V.252 3.7 - Video receive mode */
|
|
|
4210 /* TODO: */
|
|
|
4211 t += 4;
|
|
|
4212 return t;
|
|
|
4213 }
|
|
|
4214 /*- End of function --------------------------------------------------------*/
|
|
|
4215
|
|
|
4216 static const char *at_cmd_plus_SVR(at_state_t *s, const char *t)
|
|
|
4217 {
|
|
|
4218 /* V.252 5.5 - Video receive channel indication */
|
|
|
4219 /* TODO: */
|
|
|
4220 t += 4;
|
|
|
4221 return t;
|
|
|
4222 }
|
|
|
4223 /*- End of function --------------------------------------------------------*/
|
|
|
4224
|
|
|
4225 static const char *at_cmd_plus_SVRR(at_state_t *s, const char *t)
|
|
|
4226 {
|
|
|
4227 /* V.252 3.10 - Video indication reporting */
|
|
|
4228 /* TODO: */
|
|
|
4229 t += 5;
|
|
|
4230 return t;
|
|
|
4231 }
|
|
|
4232 /*- End of function --------------------------------------------------------*/
|
|
|
4233
|
|
|
4234 static const char *at_cmd_plus_SVT(at_state_t *s, const char *t)
|
|
|
4235 {
|
|
|
4236 /* V.252 5.6 - Video transmit channel indication */
|
|
|
4237 /* TODO: */
|
|
|
4238 t += 4;
|
|
|
4239 return t;
|
|
|
4240 }
|
|
|
4241 /*- End of function --------------------------------------------------------*/
|
|
|
4242
|
|
|
4243 static const char *at_cmd_plus_TADR(at_state_t *s, const char *t)
|
|
|
4244 {
|
|
|
4245 /* V.250 6.7.2.9 - Local V.54 address */
|
|
|
4246 /* TODO: */
|
|
|
4247 t += 5;
|
|
|
4248 return t;
|
|
|
4249 }
|
|
|
4250 /*- End of function --------------------------------------------------------*/
|
|
|
4251
|
|
|
4252 static const char *at_cmd_plus_TAL(at_state_t *s, const char *t)
|
|
|
4253 {
|
|
|
4254 /* V.250 6.7.2.15 - Local analogue loop */
|
|
|
4255 /* Action
|
|
|
4256 0 Disable analogue loop
|
|
|
4257 1 Enable analogue loop
|
|
|
4258 Band
|
|
|
4259 0 Low frequency band
|
|
|
4260 1 High frequency band */
|
|
|
4261 /* TODO: */
|
|
|
4262 t += 4;
|
|
|
4263 if (!parse_2_out(s, &t, NULL, 1, NULL, 1, "+TAL:", "(0,1),(0,1)"))
|
|
|
4264 return NULL;
|
|
|
4265 return t;
|
|
|
4266 }
|
|
|
4267 /*- End of function --------------------------------------------------------*/
|
|
|
4268
|
|
|
4269 static const char *at_cmd_plus_TALS(at_state_t *s, const char *t)
|
|
|
4270 {
|
|
|
4271 /* V.250 6.7.2.6 - Analogue loop status */
|
|
|
4272 /* 0 Inactive
|
|
|
4273 1 V.24 circuit 141 invoked
|
|
|
4274 2 Front panel invoked
|
|
|
4275 3 Network management system invoked */
|
|
|
4276 /* TODO: */
|
|
|
4277 t += 5;
|
|
|
4278 if (!parse_out(s, &t, NULL, 3, "+TALS:", "(0-3)"))
|
|
|
4279 return NULL;
|
|
|
4280 return t;
|
|
|
4281 }
|
|
|
4282 /*- End of function --------------------------------------------------------*/
|
|
|
4283
|
|
|
4284 static const char *at_cmd_plus_TDLS(at_state_t *s, const char *t)
|
|
|
4285 {
|
|
|
4286 /* V.250 6.7.2.7 - Local digital loop status */
|
|
|
4287 /* 0 Disabled
|
|
|
4288 1 Enabled, inactive
|
|
|
4289 2 Front panel invoked
|
|
|
4290 3 Network management system invoked
|
|
|
4291 4 Remote invoked */
|
|
|
4292 /* TODO: */
|
|
|
4293 t += 5;
|
|
|
4294 if (!parse_out(s, &t, NULL, 3, "+TDLS:", "(0-4)"))
|
|
|
4295 return NULL;
|
|
|
4296 return t;
|
|
|
4297 }
|
|
|
4298 /*- End of function --------------------------------------------------------*/
|
|
|
4299
|
|
|
4300 static const char *at_cmd_plus_TE140(at_state_t *s, const char *t)
|
|
|
4301 {
|
|
|
4302 /* V.250 6.7.2.1 - Enable ckt 140 */
|
|
|
4303 /* 0 Disabled
|
|
|
4304 1 Enabled */
|
|
|
4305 /* TODO: */
|
|
|
4306 t += 6;
|
|
|
4307 if (!parse_out(s, &t, NULL, 1, "+TE140:", "(0,1)"))
|
|
|
4308 return NULL;
|
|
|
4309 return t;
|
|
|
4310 }
|
|
|
4311 /*- End of function --------------------------------------------------------*/
|
|
|
4312
|
|
|
4313 static const char *at_cmd_plus_TE141(at_state_t *s, const char *t)
|
|
|
4314 {
|
|
|
4315 /* V.250 6.7.2.2 - Enable ckt 141 */
|
|
|
4316 /* 0 Response is disabled
|
|
|
4317 1 Response is enabled */
|
|
|
4318 /* TODO: */
|
|
|
4319 t += 6;
|
|
|
4320 if (!parse_out(s, &t, NULL, 1, "+TE141:", "(0,1)"))
|
|
|
4321 return NULL;
|
|
|
4322 return t;
|
|
|
4323 }
|
|
|
4324 /*- End of function --------------------------------------------------------*/
|
|
|
4325
|
|
|
4326 static const char *at_cmd_plus_TEPAL(at_state_t *s, const char *t)
|
|
|
4327 {
|
|
|
4328 /* V.250 6.7.2.5 - Enable front panel analogue loop */
|
|
|
4329 /* 0 Disabled
|
|
|
4330 1 Enabled */
|
|
|
4331 /* TODO: */
|
|
|
4332 t += 6;
|
|
|
4333 if (!parse_out(s, &t, NULL, 1, "+TEPAL:", "(0,1)"))
|
|
|
4334 return NULL;
|
|
|
4335 return t;
|
|
|
4336 }
|
|
|
4337 /*- End of function --------------------------------------------------------*/
|
|
|
4338
|
|
|
4339 static const char *at_cmd_plus_TEPDL(at_state_t *s, const char *t)
|
|
|
4340 {
|
|
|
4341 /* V.250 6.7.2.4 - Enable front panel RDL */
|
|
|
4342 /* 0 Disabled
|
|
|
4343 1 Enabled */
|
|
|
4344 /* TODO: */
|
|
|
4345 t += 6;
|
|
|
4346 if (!parse_out(s, &t, NULL, 1, "+TEPDL:", "(0,1)"))
|
|
|
4347 return NULL;
|
|
|
4348 return t;
|
|
|
4349 }
|
|
|
4350 /*- End of function --------------------------------------------------------*/
|
|
|
4351
|
|
|
4352 static const char *at_cmd_plus_TERDL(at_state_t *s, const char *t)
|
|
|
4353 {
|
|
|
4354 /* V.250 6.7.2.3 - Enable RDL from remote */
|
|
|
4355 /* 0 Local DCE will ignore command from remote
|
|
|
4356 1 Local DCE will obey command from remote */
|
|
|
4357 /* TODO: */
|
|
|
4358 t += 6;
|
|
|
4359 if (!parse_out(s, &t, NULL, 1, "+TERDL:", "(0,1)"))
|
|
|
4360 return NULL;
|
|
|
4361 return t;
|
|
|
4362 }
|
|
|
4363 /*- End of function --------------------------------------------------------*/
|
|
|
4364
|
|
|
4365 static const char *at_cmd_plus_TLDL(at_state_t *s, const char *t)
|
|
|
4366 {
|
|
|
4367 /* V.250 6.7.2.13 - Local digital loop */
|
|
|
4368 /* 0 Stop test
|
|
|
4369 1 Start test */
|
|
|
4370 /* TODO: */
|
|
|
4371 t += 5;
|
|
|
4372 if (!parse_out(s, &t, NULL, 1, "+TLDL:", "(0,1)"))
|
|
|
4373 return NULL;
|
|
|
4374 return t;
|
|
|
4375 }
|
|
|
4376 /*- End of function --------------------------------------------------------*/
|
|
|
4377
|
|
|
4378 static const char *at_cmd_plus_TMO(at_state_t *s, const char *t)
|
|
|
4379 {
|
|
|
4380 /* V.250 6.9 - V.59 command */
|
|
|
4381 /* TODO: */
|
|
|
4382 t += 4;
|
|
|
4383 return t;
|
|
|
4384 }
|
|
|
4385 /*- End of function --------------------------------------------------------*/
|
|
|
4386
|
|
|
4387 static const char *at_cmd_plus_TMODE(at_state_t *s, const char *t)
|
|
|
4388 {
|
|
|
4389 /* V.250 6.7.2.10 - Set V.54 mode */
|
|
|
4390 /* TODO: */
|
|
|
4391 t += 6;
|
|
|
4392 if (!parse_out(s, &t, NULL, 1, "+TMODE:", "(0,1)"))
|
|
|
4393 return NULL;
|
|
|
4394 return t;
|
|
|
4395 }
|
|
|
4396 /*- End of function --------------------------------------------------------*/
|
|
|
4397
|
|
|
4398 static const char *at_cmd_plus_TNUM(at_state_t *s, const char *t)
|
|
|
4399 {
|
|
|
4400 /* V.250 6.7.2.12 - Errored bit and block counts */
|
|
|
4401 /* TODO: */
|
|
|
4402 t += 5;
|
|
|
4403 return t;
|
|
|
4404 }
|
|
|
4405 /*- End of function --------------------------------------------------------*/
|
|
|
4406
|
|
|
4407 static const char *at_cmd_plus_TRDL(at_state_t *s, const char *t)
|
|
|
4408 {
|
|
|
4409 /* V.250 6.7.2.14 - Request remote digital loop */
|
|
|
4410 /* 0 Stop RDL
|
|
|
4411 1 Start RDL */
|
|
|
4412 /* TODO: */
|
|
|
4413 t += 5;
|
|
|
4414 if (!parse_out(s, &t, NULL, 1, "+TRDL:", "(0,1)"))
|
|
|
4415 return NULL;
|
|
|
4416 return t;
|
|
|
4417 }
|
|
|
4418 /*- End of function --------------------------------------------------------*/
|
|
|
4419
|
|
|
4420 static const char *at_cmd_plus_TRDLS(at_state_t *s, const char *t)
|
|
|
4421 {
|
|
|
4422 /* V.250 6.7.2.8 - Remote digital loop status */
|
|
|
4423 /* TODO: */
|
|
|
4424 t += 6;
|
|
|
4425 return t;
|
|
|
4426 }
|
|
|
4427 /*- End of function --------------------------------------------------------*/
|
|
|
4428
|
|
|
4429 static const char *at_cmd_plus_TRES(at_state_t *s, const char *t)
|
|
|
4430 {
|
|
|
4431 /* V.250 6.7.2.17 - Self test result */
|
|
|
4432 /* 0 No test
|
|
|
4433 1 Pass
|
|
|
4434 2 Fail */
|
|
|
4435 /* TODO: */
|
|
|
4436 t += 5;
|
|
|
4437 if (!parse_out(s, &t, NULL, 1, "+TRES:", "(0-2)"))
|
|
|
4438 return NULL;
|
|
|
4439 return t;
|
|
|
4440 }
|
|
|
4441 /*- End of function --------------------------------------------------------*/
|
|
|
4442
|
|
|
4443 static const char *at_cmd_plus_TSELF(at_state_t *s, const char *t)
|
|
|
4444 {
|
|
|
4445 /* V.250 6.7.2.16 - Self test */
|
|
|
4446 /* 0 Intrusive full test
|
|
|
4447 1 Safe partial test */
|
|
|
4448 /* TODO: */
|
|
|
4449 t += 6;
|
|
|
4450 if (!parse_out(s, &t, NULL, 1, "+TSELF:", "(0,1)"))
|
|
|
4451 return NULL;
|
|
|
4452 return t;
|
|
|
4453 }
|
|
|
4454 /*- End of function --------------------------------------------------------*/
|
|
|
4455
|
|
|
4456 static const char *at_cmd_plus_TTER(at_state_t *s, const char *t)
|
|
|
4457 {
|
|
|
4458 /* V.250 6.7.2.11 - Test error rate */
|
|
|
4459 /* TODO: */
|
|
|
4460 t += 5;
|
|
|
4461 if (!parse_2_out(s, &t, NULL, 65535, NULL, 65535, "+TTER:", "(0-65535),(0-65535)"))
|
|
|
4462 return NULL;
|
|
|
4463 return t;
|
|
|
4464 }
|
|
|
4465 /*- End of function --------------------------------------------------------*/
|
|
|
4466
|
|
|
4467 static const char *at_cmd_plus_VAC(at_state_t *s, const char *t)
|
|
|
4468 {
|
|
|
4469 /* V.252 4.1 - Set audio code */
|
|
|
4470 return t;
|
|
|
4471 }
|
|
|
4472 /*- End of function --------------------------------------------------------*/
|
|
|
4473
|
|
|
4474 static const char *at_cmd_plus_VACR(at_state_t *s, const char *t)
|
|
|
4475 {
|
|
|
4476 /* V.252 6.1 - Audio code report */
|
|
|
4477 /* TODO: */
|
|
|
4478 t += 5;
|
|
|
4479 return t;
|
|
|
4480 }
|
|
|
4481 /*- End of function --------------------------------------------------------*/
|
|
|
4482
|
|
|
4483 static const char *at_cmd_plus_VBT(at_state_t *s, const char *t)
|
|
|
4484 {
|
|
|
4485 /* 3GPP TS 27.007 C.2.2 - Buffer threshold setting */
|
|
|
4486 /* TODO: */
|
|
|
4487 t += 4;
|
|
|
4488 return t;
|
|
|
4489 }
|
|
|
4490 /*- End of function --------------------------------------------------------*/
|
|
|
4491
|
|
|
4492 static const char *at_cmd_plus_VCID(at_state_t *s, const char *t)
|
|
|
4493 {
|
|
|
4494 /* 3GPP TS 27.007 C.2.3 - Calling number ID presentation */
|
|
|
4495 /* TODO: */
|
|
|
4496 t += 5;
|
|
|
4497 if (!parse_out(s, &t, &s->display_call_info, 1, NULL, "0,1"))
|
|
|
4498 return NULL;
|
|
|
4499 return t;
|
|
|
4500 }
|
|
|
4501 /*- End of function --------------------------------------------------------*/
|
|
|
4502
|
|
|
4503 static const char *at_cmd_plus_VCIDR(at_state_t *s, const char *t)
|
|
|
4504 {
|
|
|
4505 /* V.252 6.2 - Caller ID report */
|
|
|
4506 /* TODO: */
|
|
|
4507 t += 6;
|
|
|
4508 return t;
|
|
|
4509 }
|
|
|
4510 /*- End of function --------------------------------------------------------*/
|
|
|
4511
|
|
|
4512 static const char *at_cmd_plus_VDID(at_state_t *s, const char *t)
|
|
|
4513 {
|
|
|
4514 /* V.253 9.2.4 - DID service */
|
|
|
4515 /* TODO: */
|
|
|
4516 t += 5;
|
|
|
4517 return t;
|
|
|
4518 }
|
|
|
4519 /*- End of function --------------------------------------------------------*/
|
|
|
4520
|
|
|
4521 static const char *at_cmd_plus_VDIDR(at_state_t *s, const char *t)
|
|
|
4522 {
|
|
|
4523 /* V.252 6.2 - DID report */
|
|
|
4524 /* TODO: */
|
|
|
4525 t += 6;
|
|
|
4526 return t;
|
|
|
4527 }
|
|
|
4528 /*- End of function --------------------------------------------------------*/
|
|
|
4529
|
|
|
4530 static const char *at_cmd_plus_VDR(at_state_t *s, const char *t)
|
|
|
4531 {
|
|
|
4532 /* V.253 10.3.1 - Distinctive ring (ring cadence reporting) */
|
|
|
4533 /* TODO: */
|
|
|
4534 t += 4;
|
|
|
4535 return t;
|
|
|
4536 }
|
|
|
4537 /*- End of function --------------------------------------------------------*/
|
|
|
4538
|
|
|
4539 static const char *at_cmd_plus_VDT(at_state_t *s, const char *t)
|
|
|
4540 {
|
|
|
4541 /* V.253 10.3.2 - Control tone cadence reporting */
|
|
|
4542 /* TODO: */
|
|
|
4543 t += 4;
|
|
|
4544 return t;
|
|
|
4545 }
|
|
|
4546 /*- End of function --------------------------------------------------------*/
|
|
|
4547
|
|
|
4548 static const char *at_cmd_plus_VDX(at_state_t *s, const char *t)
|
|
|
4549 {
|
|
|
4550 /* V.253 10.5.6 - Speakerphone duplex mode */
|
|
|
4551 /* TODO: */
|
|
|
4552 t += 4;
|
|
|
4553 return t;
|
|
|
4554 }
|
|
|
4555 /*- End of function --------------------------------------------------------*/
|
|
|
4556
|
|
|
4557 static const char *at_cmd_plus_VEM(at_state_t *s, const char *t)
|
|
|
4558 {
|
|
|
4559 /* V.253 10.5.7 - Deliver event reports */
|
|
|
4560 /* TODO: */
|
|
|
4561 t += 4;
|
|
|
4562 return t;
|
|
|
4563 }
|
|
|
4564 /*- End of function --------------------------------------------------------*/
|
|
|
4565
|
|
|
4566 static const char *at_cmd_plus_VGM(at_state_t *s, const char *t)
|
|
|
4567 {
|
|
|
4568 /* V.253 10.5.2 - Microphone gain */
|
|
|
4569 /* TODO: */
|
|
|
4570 t += 4;
|
|
|
4571 return t;
|
|
|
4572 }
|
|
|
4573 /*- End of function --------------------------------------------------------*/
|
|
|
4574
|
|
|
4575 static const char *at_cmd_plus_VGR(at_state_t *s, const char *t)
|
|
|
4576 {
|
|
|
4577 /* V.253 10.2.1 - Receive gain selection */
|
|
|
4578 /* TODO: */
|
|
|
4579 t += 4;
|
|
|
4580 return t;
|
|
|
4581 }
|
|
|
4582 /*- End of function --------------------------------------------------------*/
|
|
|
4583
|
|
|
4584 static const char *at_cmd_plus_VGS(at_state_t *s, const char *t)
|
|
|
4585 {
|
|
|
4586 /* V.253 10.5.3 - Speaker gain */
|
|
|
4587 /* TODO: */
|
|
|
4588 t += 4;
|
|
|
4589 return t;
|
|
|
4590 }
|
|
|
4591 /*- End of function --------------------------------------------------------*/
|
|
|
4592
|
|
|
4593 static const char *at_cmd_plus_VGT(at_state_t *s, const char *t)
|
|
|
4594 {
|
|
|
4595 /* V.253 10.2.2 - Volume selection */
|
|
|
4596 /* TODO: */
|
|
|
4597 t += 4;
|
|
|
4598 return t;
|
|
|
4599 }
|
|
|
4600 /*- End of function --------------------------------------------------------*/
|
|
|
4601
|
|
|
4602 static const char *at_cmd_plus_VHC(at_state_t *s, const char *t)
|
|
|
4603 {
|
|
|
4604 /* V.252 4.12 - Telephony port hook control */
|
|
|
4605 /* TODO: */
|
|
|
4606 t += 4;
|
|
|
4607 return t;
|
|
|
4608 }
|
|
|
4609 /*- End of function --------------------------------------------------------*/
|
|
|
4610
|
|
|
4611 static const char *at_cmd_plus_VIP(at_state_t *s, const char *t)
|
|
|
4612 {
|
|
|
4613 /* V.253 10.1.1 - Initialize voice parameters */
|
|
|
4614 /* TODO: */
|
|
|
4615 t += 4;
|
|
|
4616 return t;
|
|
|
4617 }
|
|
|
4618 /*- End of function --------------------------------------------------------*/
|
|
|
4619
|
|
|
4620 static const char *at_cmd_plus_VIT(at_state_t *s, const char *t)
|
|
|
4621 {
|
|
|
4622 /* V.253 10.2.3 - DTE/DCE inactivity timer */
|
|
|
4623 /* TODO: */
|
|
|
4624 t += 4;
|
|
|
4625 return t;
|
|
|
4626 }
|
|
|
4627 /*- End of function --------------------------------------------------------*/
|
|
|
4628
|
|
|
4629 static const char *at_cmd_plus_VLS(at_state_t *s, const char *t)
|
|
|
4630 {
|
|
|
4631 /* V.253 10.2.4 - Analogue source/destination selection */
|
|
|
4632 /* TODO: */
|
|
|
4633 t += 4;
|
|
|
4634 return t;
|
|
|
4635 }
|
|
|
4636 /*- End of function --------------------------------------------------------*/
|
|
|
4637
|
|
|
4638 static const char *at_cmd_plus_VNH(at_state_t *s, const char *t)
|
|
|
4639 {
|
|
|
4640 /* V.253 9.2.5 - Automatic hangup control */
|
|
|
4641 /* TODO: */
|
|
|
4642 t += 4;
|
|
|
4643 return t;
|
|
|
4644 }
|
|
|
4645 /*- End of function --------------------------------------------------------*/
|
|
|
4646
|
|
|
4647 static const char *at_cmd_plus_VPH(at_state_t *s, const char *t)
|
|
|
4648 {
|
|
|
4649 /* V.252 4.11 - Phone hookswitch status */
|
|
|
4650 /* TODO: */
|
|
|
4651 t += 4;
|
|
|
4652 return t;
|
|
|
4653 }
|
|
|
4654 /*- End of function --------------------------------------------------------*/
|
|
|
4655
|
|
|
4656 static const char *at_cmd_plus_VPP(at_state_t *s, const char *t)
|
|
|
4657 {
|
|
|
4658 /* V.253 10.4.2 - Voice packet protocol */
|
|
|
4659 /* TODO: */
|
|
|
4660 t += 4;
|
|
|
4661 return t;
|
|
|
4662 }
|
|
|
4663 /*- End of function --------------------------------------------------------*/
|
|
|
4664
|
|
|
4665 static const char *at_cmd_plus_VPR(at_state_t *s, const char *t)
|
|
|
4666 {
|
|
|
4667 /* IS-101 10.4.3 - Select DTE/DCE interface rate */
|
|
|
4668 /* TODO: */
|
|
|
4669 t += 4;
|
|
|
4670 return t;
|
|
|
4671 }
|
|
|
4672 /*- End of function --------------------------------------------------------*/
|
|
|
4673
|
|
|
4674 static const char *at_cmd_plus_VRA(at_state_t *s, const char *t)
|
|
|
4675 {
|
|
|
4676 /* V.253 10.2.5 - Ringing tone goes away timer */
|
|
|
4677 /* TODO: */
|
|
|
4678 t += 4;
|
|
|
4679 return t;
|
|
|
4680 }
|
|
|
4681 /*- End of function --------------------------------------------------------*/
|
|
|
4682
|
|
|
4683 static const char *at_cmd_plus_VRID(at_state_t *s, const char *t)
|
|
|
4684 {
|
|
|
4685 int val;
|
|
|
4686
|
|
|
4687 /* Extension of V.253 +VCID, Calling number ID report/repeat */
|
|
|
4688 t += 5;
|
|
|
4689 val = 0;
|
|
|
4690 if (!parse_out(s, &t, &val, 1, NULL, "0,1"))
|
|
|
4691 return NULL;
|
|
|
4692 if (val == 1)
|
|
|
4693 at_display_call_info(s);
|
|
|
4694 return t;
|
|
|
4695 }
|
|
|
4696 /*- End of function --------------------------------------------------------*/
|
|
|
4697
|
|
|
4698 static const char *at_cmd_plus_VRL(at_state_t *s, const char *t)
|
|
|
4699 {
|
|
|
4700 /* V.253 10.1.2 - Ring local phone */
|
|
|
4701 /* TODO: */
|
|
|
4702 t += 4;
|
|
|
4703 return t;
|
|
|
4704 }
|
|
|
4705 /*- End of function --------------------------------------------------------*/
|
|
|
4706
|
|
|
4707 static const char *at_cmd_plus_VRN(at_state_t *s, const char *t)
|
|
|
4708 {
|
|
|
4709 /* V.253 10.2.6 - Ringing tone never appeared timer */
|
|
|
4710 /* TODO: */
|
|
|
4711 t += 4;
|
|
|
4712 return t;
|
|
|
4713 }
|
|
|
4714 /*- End of function --------------------------------------------------------*/
|
|
|
4715
|
|
|
4716 static const char *at_cmd_plus_VRX(at_state_t *s, const char *t)
|
|
|
4717 {
|
|
|
4718 /* V.253 10.1.3 - Voice receive state */
|
|
|
4719 /* TODO: */
|
|
|
4720 t += 4;
|
|
|
4721 return t;
|
|
|
4722 }
|
|
|
4723 /*- End of function --------------------------------------------------------*/
|
|
|
4724
|
|
|
4725 static const char *at_cmd_plus_VSD(at_state_t *s, const char *t)
|
|
|
4726 {
|
|
|
4727 /* V.253 10.2.7 - Silence detection (QUIET and SILENCE) */
|
|
|
4728 /* TODO: */
|
|
|
4729 t += 4;
|
|
|
4730 return t;
|
|
|
4731 }
|
|
|
4732 /*- End of function --------------------------------------------------------*/
|
|
|
4733
|
|
|
4734 static const char *at_cmd_plus_VSID(at_state_t *s, const char *t)
|
|
|
4735 {
|
|
|
4736 /* Extension of V.253 +VCID, Set calling number ID */
|
|
|
4737 t += 5;
|
|
|
4738 switch (*t)
|
|
|
4739 {
|
|
|
4740 case '=':
|
|
|
4741 switch (*(t+1))
|
|
|
4742 {
|
|
|
4743 case '?':
|
|
|
4744 /* Show possible values */
|
|
|
4745 at_put_response(s, "");
|
|
|
4746 break;
|
|
|
4747 default:
|
|
|
4748 /* Set value */
|
|
|
4749 s->local_id = strdup(t + 1);
|
|
|
4750 if (at_modem_control(s, AT_MODEM_CONTROL_SETID, s->local_id) < 0)
|
|
|
4751 return NULL;
|
|
|
4752 break;
|
|
|
4753 }
|
|
|
4754 break;
|
|
|
4755 case '?':
|
|
|
4756 /* Show current index value from def */
|
|
|
4757 at_put_response(s, (s->local_id) ? s->local_id : "");
|
|
|
4758 break;
|
|
|
4759 default:
|
|
|
4760 return NULL;
|
|
|
4761 }
|
|
|
4762 while (*t) t++;
|
|
|
4763 return t;
|
|
|
4764 }
|
|
|
4765 /*- End of function --------------------------------------------------------*/
|
|
|
4766
|
|
|
4767 static const char *at_cmd_plus_VSM(at_state_t *s, const char *t)
|
|
|
4768 {
|
|
|
4769 /* V.253 10.2.8 - Compression method selection */
|
|
|
4770 /* TODO: */
|
|
|
4771 t += 4;
|
|
|
4772 return t;
|
|
|
4773 }
|
|
|
4774 /*- End of function --------------------------------------------------------*/
|
|
|
4775
|
|
|
4776 static const char *at_cmd_plus_VSP(at_state_t *s, const char *t)
|
|
|
4777 {
|
|
|
4778 /* V.253 10.5.1 - Voice speakerphone state */
|
|
|
4779 /* TODO: */
|
|
|
4780 t += 4;
|
|
|
4781 return t;
|
|
|
4782 }
|
|
|
4783 /*- End of function --------------------------------------------------------*/
|
|
|
4784
|
|
|
4785 static const char *at_cmd_plus_VTA(at_state_t *s, const char *t)
|
|
|
4786 {
|
|
|
4787 /* V.253 10.5.4 - Train acoustic echo-canceller */
|
|
|
4788 /* TODO: */
|
|
|
4789 t += 4;
|
|
|
4790 return t;
|
|
|
4791 }
|
|
|
4792 /*- End of function --------------------------------------------------------*/
|
|
|
4793
|
|
|
4794 static const char *at_cmd_plus_VTD(at_state_t *s, const char *t)
|
|
|
4795 {
|
|
|
4796 /* V.253 10.2.9 - Beep tone duration timer */
|
|
|
4797 /* TODO: */
|
|
|
4798 t += 4;
|
|
|
4799 return t;
|
|
|
4800 }
|
|
|
4801 /*- End of function --------------------------------------------------------*/
|
|
|
4802
|
|
|
4803 static const char *at_cmd_plus_VTER(at_state_t *s, const char *t)
|
|
|
4804 {
|
|
|
4805 /* V.252 6.4 - Simple telephony event report */
|
|
|
4806 /* TODO: */
|
|
|
4807 t += 4;
|
|
|
4808 return t;
|
|
|
4809 }
|
|
|
4810 /*- End of function --------------------------------------------------------*/
|
|
|
4811
|
|
|
4812 static const char *at_cmd_plus_VTH(at_state_t *s, const char *t)
|
|
|
4813 {
|
|
|
4814 /* V.253 10.5.5 - Train line echo-canceller */
|
|
|
4815 /* TODO: */
|
|
|
4816 t += 4;
|
|
|
4817 return t;
|
|
|
4818 }
|
|
|
4819 /*- End of function --------------------------------------------------------*/
|
|
|
4820
|
|
|
4821 static const char *at_cmd_plus_VTR(at_state_t *s, const char *t)
|
|
|
4822 {
|
|
|
4823 /* V.253 10.1.4 - Voice duplex state */
|
|
|
4824 /* TODO: */
|
|
|
4825 t += 4;
|
|
|
4826 return t;
|
|
|
4827 }
|
|
|
4828 /*- End of function --------------------------------------------------------*/
|
|
|
4829
|
|
|
4830 static const char *at_cmd_plus_VTS(at_state_t *s, const char *t)
|
|
|
4831 {
|
|
|
4832 /* V.253 10.1.5 - DTMF and tone generation in voice */
|
|
|
4833 /* TODO: */
|
|
|
4834 t += 4;
|
|
|
4835 return t;
|
|
|
4836 }
|
|
|
4837 /*- End of function --------------------------------------------------------*/
|
|
|
4838
|
|
|
4839 static const char *at_cmd_plus_VTX(at_state_t *s, const char *t)
|
|
|
4840 {
|
|
|
4841 /* V.253 10.1.6 - Transmit data state */
|
|
|
4842 /* TODO: */
|
|
|
4843 t += 4;
|
|
|
4844 return t;
|
|
|
4845 }
|
|
|
4846 /*- End of function --------------------------------------------------------*/
|
|
|
4847
|
|
|
4848 static const char *at_cmd_plus_VXT(at_state_t *s, const char *t)
|
|
|
4849 {
|
|
|
4850 /* IS-101 10.1.5 - Translate voice data */
|
|
|
4851 /* TODO: */
|
|
|
4852 t += 4;
|
|
|
4853 return t;
|
|
|
4854 }
|
|
|
4855 /*- End of function --------------------------------------------------------*/
|
|
|
4856
|
|
|
4857 static const char *at_cmd_plus_W(at_state_t *s, const char *t)
|
|
|
4858 {
|
|
|
4859 /* TIA-678 5.2.4.1 - Compliance indication */
|
|
|
4860 /* TODO: */
|
|
|
4861 t += 2;
|
|
|
4862 return t;
|
|
|
4863 }
|
|
|
4864 /*- End of function --------------------------------------------------------*/
|
|
|
4865
|
|
|
4866 static const char *at_cmd_plus_WBAG(at_state_t *s, const char *t)
|
|
|
4867 {
|
|
|
4868 /* TIA-678 C.5.6 Bias Modem Audio Gain */
|
|
|
4869 /* TODO: */
|
|
|
4870 t += 5;
|
|
|
4871 return t;
|
|
|
4872 }
|
|
|
4873 /*- End of function --------------------------------------------------------*/
|
|
|
4874
|
|
|
4875 static const char *at_cmd_plus_WCDA(at_state_t *s, const char *t)
|
|
|
4876 {
|
|
|
4877 /* TIA-678 B.3.2.5 Display Data Link Address */
|
|
|
4878 /* TODO: */
|
|
|
4879 t += 5;
|
|
|
4880 return t;
|
|
|
4881 }
|
|
|
4882 /*- End of function --------------------------------------------------------*/
|
|
|
4883
|
|
|
4884 static const char *at_cmd_plus_WCHG(at_state_t *s, const char *t)
|
|
|
4885 {
|
|
|
4886 /* TIA-678 B.3.2.4 Display Battery Charging Status */
|
|
|
4887 /* TODO: */
|
|
|
4888 t += 5;
|
|
|
4889 return t;
|
|
|
4890 }
|
|
|
4891 /*- End of function --------------------------------------------------------*/
|
|
|
4892
|
|
|
4893 static const char *at_cmd_plus_WCID(at_state_t *s, const char *t)
|
|
|
4894 {
|
|
|
4895 /* TIA-678 B.3.2.1 Display System ID (operator) */
|
|
|
4896 /* TODO: */
|
|
|
4897 t += 5;
|
|
|
4898 return t;
|
|
|
4899 }
|
|
|
4900 /*- End of function --------------------------------------------------------*/
|
|
|
4901
|
|
|
4902 static const char *at_cmd_plus_WCLK(at_state_t *s, const char *t)
|
|
|
4903 {
|
|
|
4904 /* TIA-678 B.3.2.3 Lock/Unlock DCE */
|
|
|
4905 /* TODO: */
|
|
|
4906 t += 5;
|
|
|
4907 return t;
|
|
|
4908 }
|
|
|
4909 /*- End of function --------------------------------------------------------*/
|
|
|
4910
|
|
|
4911 static const char *at_cmd_plus_WCPN(at_state_t *s, const char *t)
|
|
|
4912 {
|
|
|
4913 /* TIA-678 B.3.2.2 Set Personal Identification Number */
|
|
|
4914 /* TODO: */
|
|
|
4915 t += 5;
|
|
|
4916 return t;
|
|
|
4917 }
|
|
|
4918 /*- End of function --------------------------------------------------------*/
|
|
|
4919
|
|
|
4920 static const char *at_cmd_plus_WCXF(at_state_t *s, const char *t)
|
|
|
4921 {
|
|
|
4922 /* TIA-678 B.3.2.6 Display Supported Annex B commands */
|
|
|
4923 /* TODO: */
|
|
|
4924 t += 5;
|
|
|
4925 return t;
|
|
|
4926 }
|
|
|
4927 /*- End of function --------------------------------------------------------*/
|
|
|
4928
|
|
|
4929 static const char *at_cmd_plus_WDAC(at_state_t *s, const char *t)
|
|
|
4930 {
|
|
|
4931 /* TIA-678 C.5.1 Data over Analogue Cellular Command Query */
|
|
|
4932 /* TODO: */
|
|
|
4933 t += 5;
|
|
|
4934 return t;
|
|
|
4935 }
|
|
|
4936 /*- End of function --------------------------------------------------------*/
|
|
|
4937
|
|
|
4938 static const char *at_cmd_plus_WDIR(at_state_t *s, const char *t)
|
|
|
4939 {
|
|
|
4940 /* TIA-678 C.5.8 Phone Number Directory Selection */
|
|
|
4941 /* TODO: */
|
|
|
4942 t += 5;
|
|
|
4943 return t;
|
|
|
4944 }
|
|
|
4945 /*- End of function --------------------------------------------------------*/
|
|
|
4946
|
|
|
4947 static const char *at_cmd_plus_WECR(at_state_t *s, const char *t)
|
|
|
4948 {
|
|
|
4949 /* TIA-678 C.5.3 Enable Cellular Result Codes */
|
|
|
4950 /* TODO: */
|
|
|
4951 t += 5;
|
|
|
4952 return t;
|
|
|
4953 }
|
|
|
4954 /*- End of function --------------------------------------------------------*/
|
|
|
4955
|
|
|
4956 static const char *at_cmd_plus_WFON(at_state_t *s, const char *t)
|
|
|
4957 {
|
|
|
4958 /* TIA-678 C.5.5 Phone Specification */
|
|
|
4959 /* TODO: */
|
|
|
4960 t += 5;
|
|
|
4961 return t;
|
|
|
4962 }
|
|
|
4963 /*- End of function --------------------------------------------------------*/
|
|
|
4964
|
|
|
4965 static const char *at_cmd_plus_WKPD(at_state_t *s, const char *t)
|
|
|
4966 {
|
|
|
4967 /* TIA-678 C.5.7 Keypad Emulation */
|
|
|
4968 /* TODO: */
|
|
|
4969 t += 5;
|
|
|
4970 return t;
|
|
|
4971 }
|
|
|
4972 /*- End of function --------------------------------------------------------*/
|
|
|
4973
|
|
|
4974 static const char *at_cmd_plus_WPBA(at_state_t *s, const char *t)
|
|
|
4975 {
|
|
|
4976 /* TIA-678 C.5.9 Phone Battery Query */
|
|
|
4977 /* TODO: */
|
|
|
4978 t += 5;
|
|
|
4979 return t;
|
|
|
4980 }
|
|
|
4981 /*- End of function --------------------------------------------------------*/
|
|
|
4982
|
|
|
4983 static const char *at_cmd_plus_WPTH(at_state_t *s, const char *t)
|
|
|
4984 {
|
|
|
4985 /* TIA-678 C.5.10 Call Path */
|
|
|
4986 /* TODO: */
|
|
|
4987 t += 5;
|
|
|
4988 return t;
|
|
|
4989 }
|
|
|
4990 /*- End of function --------------------------------------------------------*/
|
|
|
4991
|
|
|
4992 static const char *at_cmd_plus_WRLK(at_state_t *s, const char *t)
|
|
|
4993 {
|
|
|
4994 /* TIA-678 C.5.4 Roam Lockout */
|
|
|
4995 /* TODO: */
|
|
|
4996 t += 5;
|
|
|
4997 return t;
|
|
|
4998 }
|
|
|
4999 /*- End of function --------------------------------------------------------*/
|
|
|
5000
|
|
|
5001 static const char *at_cmd_plus_WS45(at_state_t *s, const char *t)
|
|
|
5002 {
|
|
|
5003 /* TIA-678 5.2.4.2 DTE-side stack selection */
|
|
|
5004 /* TODO: */
|
|
|
5005 t += 5;
|
|
|
5006 return t;
|
|
|
5007 }
|
|
|
5008 /*- End of function --------------------------------------------------------*/
|
|
|
5009
|
|
|
5010 static const char *at_cmd_plus_WS46(at_state_t *s, const char *t)
|
|
|
5011 {
|
|
|
5012 /* 3GPP TS 27.007 5.9 - PCCA STD-101 [17] select wireless network */
|
|
|
5013 /* TODO: */
|
|
|
5014 t += 5;
|
|
|
5015 return t;
|
|
|
5016 }
|
|
|
5017 /*- End of function --------------------------------------------------------*/
|
|
|
5018
|
|
|
5019 static const char *at_cmd_plus_WS50(at_state_t *s, const char *t)
|
|
|
5020 {
|
|
|
5021 /* TIA-678 B.3.1.1 Normalized Signal Strength */
|
|
|
5022 /* TODO: */
|
|
|
5023 t += 5;
|
|
|
5024 return t;
|
|
|
5025 }
|
|
|
5026 /*- End of function --------------------------------------------------------*/
|
|
|
5027
|
|
|
5028 static const char *at_cmd_plus_WS51(at_state_t *s, const char *t)
|
|
|
5029 {
|
|
|
5030 /* TIA-678 B.3.1.2 Carrier Detect Signal Threshold */
|
|
|
5031 /* TODO: */
|
|
|
5032 t += 5;
|
|
|
5033 return t;
|
|
|
5034 }
|
|
|
5035 /*- End of function --------------------------------------------------------*/
|
|
|
5036
|
|
|
5037 static const char *at_cmd_plus_WS52(at_state_t *s, const char *t)
|
|
|
5038 {
|
|
|
5039 /* TIA-678 B.3.1.3 Normalized Battery Level */
|
|
|
5040 /* TODO: */
|
|
|
5041 t += 5;
|
|
|
5042 return t;
|
|
|
5043 }
|
|
|
5044 /*- End of function --------------------------------------------------------*/
|
|
|
5045
|
|
|
5046 static const char *at_cmd_plus_WS53(at_state_t *s, const char *t)
|
|
|
5047 {
|
|
|
5048 /* TIA-678 B.3.1.4 Normalized Channel Quality */
|
|
|
5049 /* TODO: */
|
|
|
5050 t += 5;
|
|
|
5051 return t;
|
|
|
5052 }
|
|
|
5053 /*- End of function --------------------------------------------------------*/
|
|
|
5054
|
|
|
5055 static const char *at_cmd_plus_WS54(at_state_t *s, const char *t)
|
|
|
5056 {
|
|
|
5057 /* TIA-678 B.3.1.5 Carrier Detect Channel Quality Threshold */
|
|
|
5058 /* TODO: */
|
|
|
5059 t += 5;
|
|
|
5060 return t;
|
|
|
5061 }
|
|
|
5062 /*- End of function --------------------------------------------------------*/
|
|
|
5063
|
|
|
5064 static const char *at_cmd_plus_WS57(at_state_t *s, const char *t)
|
|
|
5065 {
|
|
|
5066 /* TIA-678 B.3.1.7 Antenna Preference */
|
|
|
5067 /* TODO: */
|
|
|
5068 t += 5;
|
|
|
5069 return t;
|
|
|
5070 }
|
|
|
5071 /*- End of function --------------------------------------------------------*/
|
|
|
5072
|
|
|
5073 static const char *at_cmd_plus_WS58(at_state_t *s, const char *t)
|
|
|
5074 {
|
|
|
5075 /* TIA-678 B.3.1.8 Idle Time-out Value */
|
|
|
5076 /* TODO: */
|
|
|
5077 t += 5;
|
|
|
5078 return t;
|
|
|
5079 }
|
|
|
5080 /*- End of function --------------------------------------------------------*/
|
|
|
5081
|
|
|
5082 static const char *at_cmd_plus_WSTL(at_state_t *s, const char *t)
|
|
|
5083 {
|
|
|
5084 /* TIA-678 C.5.2 Call Session Time Limit */
|
|
|
5085 /* TODO: */
|
|
|
5086 t += 5;
|
|
|
5087 return t;
|
|
|
5088 }
|
|
|
5089 /*- End of function --------------------------------------------------------*/
|
|
|
5090
|
|
|
5091 /*
|
|
|
5092 AT command group prefixes:
|
|
|
5093
|
|
|
5094 +A Call control (network addressing) issues, common, PSTN, ISDN, Rec. X.25, switched digital
|
|
|
5095 +C Digital cellular extensions
|
|
|
5096 +D Data compression, Rec. V.42bis
|
|
|
5097 +E Error control, Rec. V.42
|
|
|
5098 +F Facsimile, Rec. T.30, etc.
|
|
|
5099 +G Generic issues such as identity and capabilities
|
|
|
5100 +I DTE-DCE interface issues, Rec. V.24, etc.
|
|
|
5101 +M Modulation, Rec. V.32bis, etc.
|
|
|
5102 +S Switched or simultaneous data types
|
|
|
5103 +T Test issues
|
|
|
5104 +V Voice extensions
|
|
|
5105 +W Wireless extensions
|
|
|
5106 */
|
|
|
5107
|
|
|
5108 #include "at_interpreter_dictionary.h"
|
|
|
5109
|
|
|
5110 static int command_search(const char *u, int len, int *matched)
|
|
|
5111 {
|
|
|
5112 int i;
|
|
|
5113 int index;
|
|
|
5114 int first;
|
|
|
5115 int last;
|
|
|
5116 int entry;
|
|
|
5117 int ptr;
|
|
|
5118
|
|
|
5119 entry = 0;
|
|
|
5120 /* Loop over the length of the string to search the trie... */
|
|
|
5121 for (i = 0, ptr = 0; ptr < COMMAND_TRIE_LEN; i++)
|
|
|
5122 {
|
|
|
5123 /* The character in u we are processing... */
|
|
|
5124 /* V.250 5.4.1 says upper and lower case are equivalent in commands */
|
|
|
5125 index = (unsigned char) toupper(u[i]);
|
|
|
5126 /* Is there a child node for this character? */
|
|
|
5127 /* Note: First and last could have been packed into one uint16_t,
|
|
|
5128 but space is not that critical, so the other packing is good
|
|
|
5129 enough to make the table reasonable. */
|
|
|
5130 first = command_trie[ptr++];
|
|
|
5131 last = command_trie[ptr++];
|
|
|
5132 entry = command_trie[ptr++];
|
|
|
5133 if (index < first || index > last)
|
|
|
5134 break;
|
|
|
5135 if ((ptr = command_trie[ptr + index - first]) == 0)
|
|
|
5136 break;
|
|
|
5137 ptr--;
|
|
|
5138 }
|
|
|
5139 *matched = i;
|
|
|
5140 return entry;
|
|
|
5141 }
|
|
|
5142 /*- End of function --------------------------------------------------------*/
|
|
|
5143
|
|
|
5144 int at_modem_control(at_state_t *s, int op, const char *num)
|
|
|
5145 {
|
|
|
5146 switch (op)
|
|
|
5147 {
|
|
|
5148 case AT_MODEM_CONTROL_ANSWER:
|
|
|
5149 break;
|
|
|
5150 case AT_MODEM_CONTROL_CALL:
|
|
|
5151 break;
|
|
|
5152 case AT_MODEM_CONTROL_HANGUP:
|
|
|
5153 break;
|
|
|
5154 case AT_MODEM_CONTROL_OFFHOOK:
|
|
|
5155 break;
|
|
|
5156 case AT_MODEM_CONTROL_DTR:
|
|
|
5157 break;
|
|
|
5158 case AT_MODEM_CONTROL_RTS:
|
|
|
5159 break;
|
|
|
5160 case AT_MODEM_CONTROL_CTS:
|
|
|
5161 break;
|
|
|
5162 case AT_MODEM_CONTROL_CAR:
|
|
|
5163 break;
|
|
|
5164 case AT_MODEM_CONTROL_RNG:
|
|
|
5165 break;
|
|
|
5166 case AT_MODEM_CONTROL_DSR:
|
|
|
5167 break;
|
|
|
5168 case AT_MODEM_CONTROL_RESTART:
|
|
|
5169 break;
|
|
|
5170 default:
|
|
|
5171 break;
|
|
|
5172 }
|
|
|
5173 /*endswitch*/
|
|
|
5174 return s->modem_control_handler(s, s->modem_control_user_data, op, num);
|
|
|
5175 }
|
|
|
5176 /*- End of function --------------------------------------------------------*/
|
|
|
5177
|
|
|
5178 void at_interpreter(at_state_t *s, const char *cmd, int len)
|
|
|
5179 {
|
|
|
5180 int i;
|
|
|
5181 int c;
|
|
|
5182 int entry;
|
|
|
5183 int matched;
|
|
|
5184 const char *t;
|
|
|
5185
|
|
|
5186 if (s->p.echo)
|
|
|
5187 s->at_tx_handler(s, s->at_tx_user_data, (uint8_t *) cmd, len);
|
|
|
5188
|
|
|
5189 for (i = 0; i < len; i++)
|
|
|
5190 {
|
|
|
5191 /* The spec says the top bit should be ignored */
|
|
|
5192 c = *cmd++ & 0x7F;
|
|
|
5193 /* Handle incoming character */
|
|
|
5194 if (s->line_ptr < 2)
|
|
|
5195 {
|
|
|
5196 /* Look for the initial "at", "AT", "a/" or "A/", and ignore anything before it */
|
|
|
5197 /* V.250 5.2.1 only shows "at" and "AT" as command prefixes. "At" and "aT" are
|
|
|
5198 not specified, despite 5.4.1 saying upper and lower case are equivalent in
|
|
|
5199 commands. Let's be tolerant and accept them. */
|
|
|
5200 if (tolower(c) == 'a')
|
|
|
5201 {
|
|
|
5202 s->line_ptr = 0;
|
|
|
5203 s->line[s->line_ptr++] = (char) toupper(c);
|
|
|
5204 }
|
|
|
5205 else if (s->line_ptr == 1)
|
|
|
5206 {
|
|
|
5207 if (tolower(c) == 't')
|
|
|
5208 {
|
|
|
5209 /* We have an "AT" command */
|
|
|
5210 s->line[s->line_ptr++] = (char) toupper(c);
|
|
|
5211 }
|
|
|
5212 else if (c == '/')
|
|
|
5213 {
|
|
|
5214 /* We have an "A/" command */
|
|
|
5215 /* TODO: implement "A/" command repeat */
|
|
|
5216 s->line[s->line_ptr++] = (char) c;
|
|
|
5217 }
|
|
|
5218 else
|
|
|
5219 {
|
|
|
5220 s->line_ptr = 0;
|
|
|
5221 }
|
|
|
5222 }
|
|
|
5223 }
|
|
|
5224 else
|
|
|
5225 {
|
|
|
5226 /* We are beyond the initial AT */
|
|
|
5227 if (c >= 0x20 && c <= 0x7E)
|
|
|
5228 {
|
|
|
5229 /* Add a new char */
|
|
|
5230 if (s->line_ptr < (int) (sizeof(s->line) - 1))
|
|
|
5231 s->line[s->line_ptr++] = (char) toupper(c);
|
|
|
5232 }
|
|
|
5233 else if (c == s->p.s_regs[3])
|
|
|
5234 {
|
|
|
5235 /* End of command line. Do line validation */
|
|
|
5236 s->line[s->line_ptr] = '\0';
|
|
|
5237 if (s->line_ptr > 2)
|
|
|
5238 {
|
|
|
5239 /* The spec says the commands within a command line are executed in order, until
|
|
|
5240 an error is found, or the end of the command line is reached. */
|
|
|
5241 t = s->line + 2;
|
|
|
5242 while (t && *t)
|
|
|
5243 {
|
|
|
5244 if ((entry = command_search(t, 15, &matched)) <= 0)
|
|
|
5245 break;
|
|
|
5246 if ((t = at_commands[entry - 1](s, t)) == NULL)
|
|
|
5247 break;
|
|
|
5248 if (t == (const char *) -1)
|
|
|
5249 break;
|
|
|
5250 }
|
|
|
5251 if (t != (const char *) -1)
|
|
|
5252 {
|
|
|
5253 if (t == NULL)
|
|
|
5254 at_put_response_code(s, AT_RESPONSE_CODE_ERROR);
|
|
|
5255 else
|
|
|
5256 at_put_response_code(s, AT_RESPONSE_CODE_OK);
|
|
|
5257 }
|
|
|
5258 }
|
|
|
5259 else if (s->line_ptr == 2)
|
|
|
5260 {
|
|
|
5261 /* It's just an empty "AT" command, return OK. */
|
|
|
5262 at_put_response_code(s, AT_RESPONSE_CODE_OK);
|
|
|
5263 }
|
|
|
5264 s->line_ptr = 0;
|
|
|
5265 }
|
|
|
5266 else if (c == s->p.s_regs[5])
|
|
|
5267 {
|
|
|
5268 /* Command line editing character (backspace) */
|
|
|
5269 if (s->line_ptr > 0)
|
|
|
5270 s->line_ptr--;
|
|
|
5271 }
|
|
|
5272 else
|
|
|
5273 {
|
|
|
5274 /* The spec says control characters, other than those
|
|
|
5275 explicitly handled, should be ignored, and so this
|
|
|
5276 invalid character causes everything buffered
|
|
|
5277 before it to also be ignored. */
|
|
|
5278 s->line_ptr = 0;
|
|
|
5279 }
|
|
|
5280 }
|
|
|
5281 }
|
|
|
5282 }
|
|
|
5283 /*- End of function --------------------------------------------------------*/
|
|
|
5284
|
|
|
5285 void at_set_class1_handler(at_state_t *s, at_class1_handler_t handler, void *user_data)
|
|
|
5286 {
|
|
|
5287 s->class1_handler = handler;
|
|
|
5288 s->class1_user_data = user_data;
|
|
|
5289 }
|
|
|
5290 /*- End of function --------------------------------------------------------*/
|
|
|
5291
|
|
|
5292 at_state_t *at_init(at_state_t *s,
|
|
|
5293 at_tx_handler_t *at_tx_handler,
|
|
|
5294 void *at_tx_user_data,
|
|
|
5295 at_modem_control_handler_t *modem_control_handler,
|
|
|
5296 void *modem_control_user_data)
|
|
|
5297 {
|
|
|
5298 memset(s, '\0', sizeof(*s));
|
|
|
5299 s->modem_control_handler = modem_control_handler;
|
|
|
5300 s->modem_control_user_data = modem_control_user_data;
|
|
|
5301 s->at_tx_handler = at_tx_handler;
|
|
|
5302 s->at_tx_user_data = at_tx_user_data;
|
|
|
5303 at_reset_call_info(s);
|
|
|
5304 s->local_id = NULL;
|
|
|
5305 s->display_call_info = 0;
|
|
|
5306 at_set_at_rx_mode(s, AT_MODE_ONHOOK_COMMAND);
|
|
|
5307 s->p = profiles[0];
|
|
|
5308 return s;
|
|
|
5309 }
|
|
|
5310 /*- End of function --------------------------------------------------------*/
|
|
|
5311 /*- End of file ------------------------------------------------------------*/
|
