Ticket #974: 01_atcmd-timeout-scheme.patch

File 01_atcmd-timeout-scheme.patch, 22.4 KB (added by sean_chiang@…, 12 years ago)

At command timeout scheme to avoid dead waiting

  • include/gsmd/atcmd.h

    === include/gsmd/atcmd.h
    ==================================================================
     
    77 
    88typedef int atcmd_cb_t(struct gsmd_atcmd *cmd, void *ctx, char *resp); 
    99 
    10 extern struct gsmd_atcmd *atcmd_fill(const char *cmd, int rlen, atcmd_cb_t *cb, void *ctx, u_int16_t id); 
     10extern struct gsmd_atcmd *atcmd_fill(const char *cmd, int rlen, atcmd_cb_t *cb, void *ctx, u_int16_t id,  
     11                                                                                           create_timer_t ct); 
    1112extern int atcmd_submit(struct gsmd *g, struct gsmd_atcmd *cmd); 
    1213extern int cancel_atcmd(struct gsmd *g, struct gsmd_atcmd *cmd); 
    1314extern int atcmd_init(struct gsmd *g, int sockfd); 
  • include/gsmd/gsmd.h

    === include/gsmd/gsmd.h
    ==================================================================
     
    1919#define LGSM_ATCMD_F_PARAM      0x02    /* as opposed to action */ 
    2020#define LGSM_ATCMD_F_LFCR       0x04    /* accept LFCR as a line terminator */ 
    2121 
     22typedef struct gsmd_timer * (create_timer_t)(struct gsmd *data); 
    2223struct gsmd_atcmd { 
    2324        struct llist_head list; 
    2425        void *ctx; 
     
    2829        u_int32_t buflen; 
    2930        u_int16_t id; 
    3031        u_int8_t flags; 
     32        struct gsmd_timer *timeout; 
     33        create_timer_t * create_timer_func;   
    3134        char *cur; 
    3235        char buf[]; 
    3336}; 
     
    6770#define GSMD_FLAG_V0            0x0001  /* V0 responses to be expected from TA */ 
    6871#define GSMD_FLAG_SMS_FMT_TEXT  0x0002  /* TODO Use TEXT rather than PDU mode */ 
    6972 
    70 #define GSMD_MODEM_WAKEUP_TIMEOUT     3 
     73#define GSMD_ATCMD_TIMEOUT      60      /* If doesn get respond within 60 secs, discard */ 
    7174 
    7275struct gsmd { 
    7376        unsigned int flags; 
     
    8689        unsigned char *mlbuf;           /* ml_parse buffer */ 
    8790        unsigned int mlbuf_len; 
    8891        int mlunsolicited; 
    89         struct gsmd_timer *wakeup_timer; 
     92        int alive_responded; 
    9093}; 
    9194 
    9295struct gsmd_user { 
  • src/gsmd/atcmd.c

    === src/gsmd/atcmd.c
    ==================================================================
     
    4141#include <gsmd/unsolicited.h> 
    4242 
    4343static void *__atcmd_ctx; 
     44static int remove_timer(struct gsmd_atcmd * cmd); 
    4445 
    4546enum final_result_codes { 
    4647        GSMD_RESULT_OK = 0, 
     
    214215static int atcmd_done(struct gsmd *g, struct gsmd_atcmd *cmd, const char *buf) 
    215216{ 
    216217        int rc = 0; 
     218        /* remove timer if get respond before timeout */ 
     219        remove_timer(cmd); 
    217220        if (!cmd->cb) { 
    218221                gsmd_log(GSMD_NOTICE, "command without cb!!!\n"); 
    219222        } else { 
     
    359362                        /* it might be a multiline response, so if there's a previous 
    360363                           response, send out mlbuf and start afresh with an empty buffer */ 
    361364                        if (g->mlbuf_len) { 
     365                                /* remove timer if get respond before timeout */ 
     366                                remove_timer(cmd); 
    362367                                if (!cmd->cb) { 
    363368                                        gsmd_log(GSMD_NOTICE, "command without cb!!!\n"); 
    364369                                } else { 
     
    512517                        write(fd, "\r", 1); 
    513518 
    514519                        if (!pos->buflen) { 
     520                                /* success: create atcommand timeout timer */ 
     521                                pos->timeout = pos->create_timer_func(g);   
    515522                                /* success: remove from global list of 
    516523                                 * to-be-sent atcmds */ 
    517524                                llist_del(&pos->list); 
     
    536543        return 0; 
    537544} 
    538545 
     546static void discard_timeout(struct gsmd_timer *tmr, void *data)  
     547{ 
     548        struct gsmd *g=data; 
     549        struct gsmd_atcmd *cmd=NULL; 
     550        DEBUGP("discard time out!!\n"); 
     551        if (!llist_empty(&g->busy_atcmds)) { 
     552                cmd = llist_entry(g->busy_atcmds.next,struct gsmd_atcmd, list); 
     553        } 
     554        if (!cmd) {  
     555                DEBUGP("ERROR!! busy_atcmds is NULL\n"); 
     556                return; 
     557        } 
     558        if (cmd->timeout != tmr) { 
     559                DEBUGP("ERROR!! cmd->timeout != tmr\n"); 
     560                return; 
     561        } 
    539562 
     563        gsmd_timer_free(cmd->timeout); 
     564        cmd->timeout = NULL; 
     565 
     566        if (cmd->cb) { 
     567                cmd->resp = "Timeout"; 
     568                cmd->cb(cmd, cmd->ctx, cmd->resp); 
     569        } 
     570         
     571        // discard the timeout at command 
     572        llist_del(&cmd->list); 
     573        talloc_free(cmd); 
     574         
     575        // pass the next pending at command 
     576        if (llist_empty(&g->busy_atcmds) && !llist_empty(&g->pending_atcmds)) { 
     577                atcmd_wake_pending_queue(g); 
     578        } 
     579} 
     580 
     581static struct gsmd_timer * discard_timer(struct gsmd *g) 
     582{ 
     583         
     584        struct timeval tv; 
     585        tv.tv_sec = GSMD_ATCMD_TIMEOUT; 
     586        tv.tv_usec = 0; 
     587          
     588        DEBUGP("Create discard timer\n"); 
     589         
     590        return gsmd_timer_create(&tv, &discard_timeout, g); 
     591} 
     592 
    540593struct gsmd_atcmd *atcmd_fill(const char *cmd, int rlen, 
    541                               atcmd_cb_t cb, void *ctx, u_int16_t id) 
     594                              atcmd_cb_t cb, void *ctx, u_int16_t id, 
     595                              create_timer_t ct) 
    542596{ 
    543597        int buflen = strlen(cmd); 
    544598        struct gsmd_atcmd *atcmd; 
     
    559613        atcmd->cur = atcmd->buf; 
    560614        atcmd->cb = cb; 
    561615        atcmd->resp = NULL; 
     616        atcmd->timeout = NULL; 
    562617        strncpy(atcmd->buf, cmd, buflen-1); 
    563618 
     619        if (!ct) 
     620                atcmd->create_timer_func = discard_timer;  
     621        else 
     622                atcmd->create_timer_func = ct; 
     623 
    564624        return atcmd; 
    565625} 
    566626 
    567 static int null_wakeup_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp)  
     627static int remove_timer(struct gsmd_atcmd * cmd) 
    568628{ 
    569         struct gsmd *g = ctx; 
    570         if (g->wakeup_timer) { 
    571                 DEBUGP("modem is awake, remove timer!\n"); 
    572                 gsmd_timer_unregister(g->wakeup_timer); 
    573                 gsmd_timer_free(g->wakeup_timer); 
    574                 g->wakeup_timer=NULL; 
    575         } else { 
    576                 DEBUGP("ERROR!! The wake up response comes too late!!\n"); 
    577         } 
    578         return 0; 
    579 } 
     629        if (cmd->timeout) { 
     630                DEBUGP("Get respond before timeout, remove timer!\n"); 
     631                gsmd_timer_unregister(cmd->timeout); 
     632                gsmd_timer_free(cmd->timeout); 
     633                cmd->timeout = NULL; 
     634        } else { 
     635                DEBUGP("ERROR!! The %s response comes too late!!\n", cmd->buf); 
     636        } 
    580637 
    581 static void wakeup_timeout(struct gsmd_timer *tmr, void *data)  
    582 { 
    583         struct gsmd *g=data; 
    584         struct gsmd_atcmd *cmd=NULL; 
    585         DEBUGP("Wakeup time out!!\n"); 
    586         if (g->wakeup_timer != tmr) { 
    587                 DEBUGP("ERROR!! g->wakeup_timer != tmr\n"); 
    588                 return; 
    589         } 
    590         g->wakeup_timer = NULL; 
    591         gsmd_timer_free(tmr); 
    592         if (!llist_empty(&g->busy_atcmds)) { 
    593                 cmd = llist_entry(g->busy_atcmds.next,struct gsmd_atcmd, list); 
    594         } 
    595         if (!cmd) {  
    596                 DEBUGP("ERROR!! busy_atcmds is NULL\n"); 
    597                 return; 
    598         } 
    599         // It's a wakeup command 
    600         if ( cmd->buf[0]==' ') { 
    601                 llist_del(&cmd->list); 
    602                 talloc_free(cmd); 
    603                 // discard the wakeup command, and pass the real command. 
    604                 if (llist_empty(&g->busy_atcmds) && !llist_empty(&g->pending_atcmds)) { 
    605                         atcmd_wake_pending_queue(g); 
    606                 } 
    607         } else { 
    608                 DEBUGP("ERROR!! Wakeup timeout and cmd->buf is not wakeup command!! %s\n",cmd->buf); 
    609         } 
     638        return 0; 
    610639} 
    611640 
    612 void wakeup_timer (struct gsmd *g)  
    613 { 
    614         struct timeval tv; 
    615         struct gsmd_timer *timer; 
    616         tv.tv_sec = GSMD_MODEM_WAKEUP_TIMEOUT; 
    617         tv.tv_usec = 0; 
    618         timer=gsmd_timer_create(&tv,&wakeup_timeout,g); 
    619         g->wakeup_timer=timer; 
    620          
    621 } 
    622641 
    623 /// adding a null '\r' before real at command. 
    624 struct gsmd_atcmd * atcmd_wakeup_modem(struct gsmd *g)  
    625 { 
    626         if (!g->wakeup_timer) { 
    627                 DEBUGP("try to wake up\n"); 
    628                 struct gsmd_atcmd * cmd= atcmd_fill(" \r",2,null_wakeup_cb,g,0); 
    629                 wakeup_timer(g); 
    630                 if (llist_empty(&g->pending_atcmds)) { 
    631                         atcmd_wake_pending_queue(g); 
    632                 } 
    633                 llist_add_tail(&cmd->list, &g->pending_atcmds); 
    634         } 
    635 } 
    636  
    637  
    638  
    639642/* submit an atcmd in the global queue of pending atcmds */ 
    640643int atcmd_submit(struct gsmd *g, struct gsmd_atcmd *cmd) 
    641644{ 
    642645        int empty; 
    643         atcmd_wakeup_modem(g); 
    644646        DEBUGP("submitting command `%s'\n", cmd->buf); 
    645647 
    646648        empty = llist_empty(&g->pending_atcmds); 
     
    701703 
    702704        g->mlbuf_len = 0; 
    703705        g->mlunsolicited = 0; 
    704         g->wakeup_timer=NULL; 
     706        g->alive_responded = 0; 
    705707 
    706708        g->llp.cur = g->llp.buf; 
    707709        g->llp.len = sizeof(g->llp.buf); 
  • src/gsmd/gsmd.c

    === src/gsmd/gsmd.c
    ==================================================================
     
    5656 * either OK or ERROR is allowed since, both mean the modem still responds 
    5757 */ 
    5858 
    59  
    60 struct gsmd_alive_priv { 
    61         struct gsmd *gsmd; 
    62         int alive_responded; 
    63 }; 
    64  
    6559static int gsmd_alive_cb(struct gsmd_atcmd *cmd, void *ctx, char *resp) 
    6660{ 
    67         struct gsmd_alive_priv *alp = ctx; 
     61        struct gsmd *g = ctx; 
    6862 
    6963        if (!strcmp(resp, "OK") || !strcmp(resp, "ERROR") || 
    70             ((alp->gsmd->flags & GSMD_FLAG_V0) && resp[0] == '0')) 
    71                 alp->alive_responded = 1; 
     64            ((g->flags & GSMD_FLAG_V0) && resp[0] == '0')) 
     65                g->alive_responded = 1; 
    7266        return 0; 
    7367} 
    7468 
    7569static void alive_tmr_cb(struct gsmd_timer *tmr, void *data) 
    7670{ 
    77         struct gsmd_alive_priv *alp = data; 
     71        struct gsmd *g = data; 
    7872 
    79         DEBUGP("gsmd_alive timer expired\n", alp); 
     73        DEBUGP("gsmd_alive timer expired\n"); 
    8074 
    81         if (alp->alive_responded == 0) { 
     75        if (g->alive_responded == 0) { 
    8276                gsmd_log(GSMD_FATAL, "modem dead!\n"); 
    8377                exit(3); 
    8478        } else 
     
    8781        /* FIXME: update some global state */ 
    8882 
    8983        gsmd_timer_free(tmr); 
    90         talloc_free(alp); 
    9184} 
    9285 
     86static struct gsmd_timer * alive_timer(struct gsmd *g) 
     87{ 
     88        struct timeval tv; 
     89        tv.tv_sec = GSMD_ALIVE_TIMEOUT; 
     90        tv.tv_usec = 0; 
     91 
     92        return gsmd_timer_create(&tv, &alive_tmr_cb, g); 
     93} 
     94 
    9395static int gsmd_modem_alive(struct gsmd *gsmd) 
    9496{ 
    9597        struct gsmd_atcmd *cmd; 
    96         struct gsmd_alive_priv *alp; 
    97         struct timeval tv; 
    9898 
    99         alp = talloc(gsmd_tallocs, struct gsmd_alive_priv); 
    100         if (!alp) 
    101                 return -ENOMEM; 
     99        gsmd->alive_responded = 0; 
    102100 
    103         alp->gsmd = gsmd; 
    104         alp->alive_responded = 0; 
    105  
    106101        cmd = atcmd_fill(GSMD_ALIVECMD, strlen(GSMD_ALIVECMD)+1,  
    107                          &gsmd_alive_cb, alp, 0); 
     102                         &gsmd_alive_cb, gsmd, 0, alive_timer); 
    108103        if (!cmd) { 
    109                 talloc_free(alp); 
    110104                return -ENOMEM; 
    111105        } 
    112106 
    113         tv.tv_sec = GSMD_ALIVE_TIMEOUT; 
    114         tv.tv_usec = 0; 
    115         gsmd_timer_create(&tv, &alive_tmr_cb, alp); 
    116          
    117107        return atcmd_submit(gsmd, cmd); 
    118108} 
    119109 
     
    158148int gsmd_simplecmd(struct gsmd *gsmd, char *cmdtxt) 
    159149{ 
    160150        struct gsmd_atcmd *cmd; 
    161         cmd = atcmd_fill(cmdtxt, strlen(cmdtxt)+1, &gsmd_test_atcb, NULL, 0); 
     151        cmd = atcmd_fill(cmdtxt, strlen(cmdtxt)+1, &gsmd_test_atcb, NULL, 0, NULL); 
    162152        if (!cmd) 
    163153                return -ENOMEM; 
    164154         
     
    239229        struct gsmd_atcmd *cmd; 
    240230        struct timeval tv; 
    241231 
    242         cmd = atcmd_fill("ATZ", strlen("ATZ")+1, &firstcmd_atcb, gsmd, 0); 
     232        cmd = atcmd_fill("ATZ", strlen("ATZ")+1, &firstcmd_atcb, gsmd, 0, NULL); 
    243233        if (!cmd) 
    244234                return -ENOMEM; 
    245235 
  • src/gsmd/sms_cb.c

    === src/gsmd/sms_cb.c
    ==================================================================
     
    320320                        atcmd_len = sprintf(buf, "AT+CMGL=%i", *stat); 
    321321 
    322322                cmd = atcmd_fill(buf, atcmd_len + 1, 
    323                                 &sms_list_cb, gu, gph->id); 
     323                                &sms_list_cb, gu, gph->id, NULL); 
    324324                break; 
    325325 
    326326        case GSMD_SMS_READ: 
     
    331331                atcmd_len = sprintf(buf, "AT+CMGR=%i", *index); 
    332332 
    333333                cmd = atcmd_fill(buf, atcmd_len + 1, 
    334                                 &sms_read_cb, gu, gph->id); 
     334                                &sms_read_cb, gu, gph->id, NULL); 
    335335                break; 
    336336 
    337337        case GSMD_SMS_SEND: 
     
    353353                buf[atcmd_len ++] = 26; /* ^Z ends the message */ 
    354354                buf[atcmd_len ++] = 0; 
    355355 
    356                 cmd = atcmd_fill(buf, atcmd_len, &sms_send_cb, gu, gph->id); 
     356                cmd = atcmd_fill(buf, atcmd_len, &sms_send_cb, gu, gph->id, NULL); 
    357357                break; 
    358358 
    359359        case GSMD_SMS_WRITE: 
     
    378378                buf[atcmd_len ++] = 26; /* ^Z ends the message */ 
    379379                buf[atcmd_len ++] = 0; 
    380380 
    381                 cmd = atcmd_fill(buf, atcmd_len, &sms_write_cb, gu, gph->id); 
     381                cmd = atcmd_fill(buf, atcmd_len, &sms_write_cb, gu, gph->id, NULL); 
    382382                break; 
    383383 
    384384        case GSMD_SMS_DELETE: 
     
    390390                                gsd->index, gsd->delflg); 
    391391 
    392392                cmd = atcmd_fill(buf, atcmd_len + 1, 
    393                                 &sms_delete_cb, gu, gph->id); 
     393                                &sms_delete_cb, gu, gph->id, NULL); 
    394394                break; 
    395395 
    396396        case GSMD_SMS_GET_MSG_STORAGE: 
    397                 cmd = atcmd_fill("AT+CPMS?", 8 + 1, usock_cpms_cb, gu, 0); 
     397                cmd = atcmd_fill("AT+CPMS?", 8 + 1, usock_cpms_cb, gu, 0, NULL); 
    398398                break; 
    399399 
    400400        case GSMD_SMS_SET_MSG_STORAGE: 
     
    406406                                ts0705_memtype_name[storage[0]], 
    407407                                ts0705_memtype_name[storage[1]], 
    408408                                ts0705_memtype_name[storage[2]]); 
    409                 cmd = atcmd_fill(buf, atcmd_len + 1, NULL, gu, gph->id); 
     409                cmd = atcmd_fill(buf, atcmd_len + 1, NULL, gu, gph->id, NULL); 
    410410                break; 
    411411 
    412412        case GSMD_SMS_GET_SERVICE_CENTRE: 
    413                 cmd = atcmd_fill("AT+CSCA?", 8 + 1, &usock_get_smsc_cb, gu, 0); 
     413                cmd = atcmd_fill("AT+CSCA?", 8 + 1, &usock_get_smsc_cb, gu, 0, NULL); 
    414414                break; 
    415415 
    416416        case GSMD_SMS_SET_SERVICE_CENTRE: 
     
    419419                ga = (struct gsmd_addr *) ((void *) gph + sizeof(*gph)); 
    420420                atcmd_len = sprintf(buf, "AT+CSCA=\"%s\",%i", 
    421421                                ga->number, ga->type); 
    422                 cmd = atcmd_fill(buf, atcmd_len + 1, NULL, gu, gph->id); 
     422                cmd = atcmd_fill(buf, atcmd_len + 1, NULL, gu, gph->id, NULL); 
    423423                break; 
    424424 
    425425        default: 
     
    440440 
    441441        switch (gph->msg_subtype) { 
    442442        case GSMD_CB_SUBSCRIBE: 
    443                 cmd = atcmd_fill("AT+CSCB=1", 9 + 1, NULL, gu->gsmd, 0); 
     443                cmd = atcmd_fill("AT+CSCB=1", 9 + 1, NULL, gu->gsmd, 0, NULL); 
    444444                break; 
    445445        case GSMD_CB_UNSUBSCRIBE: 
    446                 cmd = atcmd_fill("AT+CSCB=0", 9 + 1, NULL, gu->gsmd, 0); 
     446                cmd = atcmd_fill("AT+CSCB=0", 9 + 1, NULL, gu->gsmd, 0, NULL); 
    447447                break; 
    448448        default: 
    449449                return -ENOSYS; 
     
    681681 
    682682        /* If text mode, set the encoding */ 
    683683        if (gsmd->flags & GSMD_FLAG_SMS_FMT_TEXT) { 
    684                 atcmd = atcmd_fill("AT+CSCS=\"IRA\"", 13 + 1, NULL, gsmd, 0); 
     684                atcmd = atcmd_fill("AT+CSCS=\"IRA\"", 13 + 1, NULL, gsmd, 0, NULL); 
    685685                if (!atcmd) 
    686686                        return -ENOMEM; 
    687687                atcmd_submit(gsmd, atcmd); 
     
    692692                                "AT+CMGF=%i", 
    693693                                (gsmd->flags & GSMD_FLAG_SMS_FMT_TEXT) ? 
    694694                                GSMD_SMS_FMT_TEXT : GSMD_SMS_FMT_PDU) + 1, 
    695                         NULL, gsmd, 0); 
     695                        NULL, gsmd, 0, NULL); 
    696696        if (!atcmd) 
    697697                return -ENOMEM; 
    698698 
  • src/gsmd/usock.c

    === src/gsmd/usock.c
    ==================================================================
     
    9090static int usock_rcv_passthrough(struct gsmd_user *gu, struct gsmd_msg_hdr *gph, int len) 
    9191{ 
    9292        struct gsmd_atcmd *cmd; 
    93         cmd = atcmd_fill((char *)gph+sizeof(*gph), gph->len, &usock_cmd_cb, gu, gph->id); 
     93        cmd = atcmd_fill((char *)gph+sizeof(*gph), gph->len, &usock_cmd_cb, gu, gph->id, NULL); 
    9494        if (!cmd) 
    9595                return -ENOMEM; 
    9696 
     
    127127                ga = (struct gsmd_addr *) ((void *)gph + sizeof(*gph)); 
    128128                ga->number[GSMD_ADDR_MAXLEN] = '\0'; 
    129129                cmd = atcmd_fill("ATD", 5 + strlen(ga->number), 
    130                                  &usock_cmd_cb, gu, gph->id); 
     130                                 &usock_cmd_cb, gu, gph->id, NULL); 
    131131                if (!cmd) 
    132132                        return -ENOMEM; 
    133133                sprintf(cmd->buf, "ATD%s;", ga->number); 
     
    135135                break; 
    136136        case GSMD_VOICECALL_HANGUP: 
    137137                /* ATH0 is not supported by QC, we hope ATH is supported by everone */ 
    138                 cmd = atcmd_fill("ATH", 4, &usock_cmd_cb, gu, gph->id); 
     138                cmd = atcmd_fill("ATH", 4, &usock_cmd_cb, gu, gph->id, NULL); 
    139139                 
    140140                /* This command is special because it needs to be sent to 
    141141                * the MS even if a command is currently executing.  */ 
     
    144144                } 
    145145                break; 
    146146        case GSMD_VOICECALL_ANSWER: 
    147                 cmd = atcmd_fill("ATA", 4, &usock_cmd_cb, gu, gph->id); 
     147                cmd = atcmd_fill("ATA", 4, &usock_cmd_cb, gu, gph->id, NULL); 
    148148                break; 
    149149        case GSMD_VOICECALL_DTMF: 
    150150                if (len < sizeof(*gph) + sizeof(*gd)) 
     
    160160 
    161161                atcmd_len = 1 + strlen("AT+VTS=") + (gd->len * 2); 
    162162                cmd = atcmd_fill("AT+VTS=", atcmd_len, &usock_cmd_cb, 
    163                                  gu, gph->id); 
     163                                 gu, gph->id, NULL); 
    164164                if (!cmd) 
    165165                        return -ENOMEM; 
    166166 
     
    224224        } 
    225225 
    226226        cmd = atcmd_fill("AT+CPIN=\"", 9+GSMD_PIN_MAXLEN+3+GSMD_PIN_MAXLEN+2, 
    227                          &pin_cmd_cb, gu, 0); 
     227                         &pin_cmd_cb, gu, 0, NULL); 
    228228        if (!cmd) 
    229229                return -ENOMEM; 
    230230 
     
    271271        switch (gph->msg_subtype) { 
    272272        case GSMD_PHONE_POWERUP: 
    273273                cmd = atcmd_fill("AT+CFUN=1", 9+1, 
    274                                  &phone_powerup_cb, gu, 0); 
     274                                 &phone_powerup_cb, gu, 0, NULL); 
    275275                break; 
    276276 
    277277        case GSMD_PHONE_POWERDOWN: 
    278278                cmd = atcmd_fill("AT+CFUN=0", 9+1, 
    279                                  &null_cmd_cb, gu, 0); 
     279                                 &null_cmd_cb, gu, 0, NULL); 
    280280                gu->gsmd->dev_state.on = 0; 
    281281                break; 
    282282        default: 
     
    592592                num->service = GSMD_SERVICE_UNKNOWN; 
    593593        num->name[len] = 0; 
    594594        num->addr.type = type; 
    595         num->is_last = (cmd->ret == 0); 
     595        num->is_last = (cmd->ret == 0, NULL); 
    596596 
    597597        usock_cmd_enqueue(ucmd, gu); 
    598598 
     
    615615                                        sizeof(gsmd_oper_numeric), oper); 
    616616                else 
    617617                        cmdlen = sprintf(buffer, "AT+COPS=0"); 
    618                 cmd = atcmd_fill(buffer, cmdlen + 1, &null_cmd_cb, gu, 0); 
     618                cmd = atcmd_fill(buffer, cmdlen + 1, &null_cmd_cb, gu, 0, NULL); 
    619619                break; 
    620620        case GSMD_NETWORK_DEREGISTER: 
    621                 cmd = atcmd_fill("AT+COPS=2", 9+1, &null_cmd_cb, gu, 0); 
     621                cmd = atcmd_fill("AT+COPS=2", 9+1, &null_cmd_cb, gu, 0, NULL); 
    622622                break; 
    623623        case GSMD_NETWORK_VMAIL_GET: 
    624                 cmd = atcmd_fill("AT+CSVM?", 8+1, &network_vmail_cb, gu, 0); 
     624                cmd = atcmd_fill("AT+CSVM?", 8+1, &network_vmail_cb, gu, 0, NULL); 
    625625                break; 
    626626        case GSMD_NETWORK_VMAIL_SET: 
    627                 cmd = atcmd_fill("AT+CSVM=", 8+1, &network_vmail_cb, gu, 0); 
     627                cmd = atcmd_fill("AT+CSVM=", 8+1, &network_vmail_cb, gu, 0, NULL); 
    628628                break; 
    629629        case GSMD_NETWORK_SIGQ_GET: 
    630                 cmd = atcmd_fill("AT+CSQ", 6+1, &network_sigq_cb, gu, 0); 
     630                cmd = atcmd_fill("AT+CSQ", 6+1, &network_sigq_cb, gu, 0, NULL); 
    631631                break; 
    632632        case GSMD_NETWORK_OPER_GET: 
    633633                /* Set long alphanumeric format */ 
    634634                atcmd_submit(gu->gsmd, atcmd_fill("AT+COPS=3,0", 11+1, 
    635                                         &null_cmd_cb, gu, 0)); 
    636                 cmd = atcmd_fill("AT+COPS?", 8+1, &network_oper_cb, gu, 0); 
     635                                        &null_cmd_cb, gu, 0, NULL)); 
     636                cmd = atcmd_fill("AT+COPS?", 8+1, &network_oper_cb, gu, 0, NULL); 
    637637                break; 
    638638        case GSMD_NETWORK_OPER_LIST: 
    639                 cmd = atcmd_fill("AT+COPS=?", 9+1, &network_opers_cb, gu, 0); 
     639                cmd = atcmd_fill("AT+COPS=?", 9+1, &network_opers_cb, gu, 0, NULL); 
    640640                break; 
    641641        case GSMD_NETWORK_PREF_LIST: 
    642642                /* Set long alphanumeric format */ 
    643643                atcmd_submit(gu->gsmd, atcmd_fill("AT+CPOL=,0", 10 + 1, 
    644                                         &null_cmd_cb, gu, 0)); 
     644                                        &null_cmd_cb, gu, 0, NULL)); 
    645645                cmd = atcmd_fill("AT+CPOL?", 8 + 1, 
    646                                 &network_pref_opers_cb, gu, 0); 
     646                                &network_pref_opers_cb, gu, 0, NULL); 
    647647                break; 
    648648        case GSMD_NETWORK_PREF_DEL: 
    649649                cmdlen = sprintf(buffer, "AT+CPOL=%i", *(int *) gph->data); 
    650                 cmd = atcmd_fill(buffer, cmdlen + 1, &null_cmd_cb, gu, 0); 
     650                cmd = atcmd_fill(buffer, cmdlen + 1, &null_cmd_cb, gu, 0, NULL); 
    651651                break; 
    652652        case GSMD_NETWORK_PREF_ADD: 
    653653                cmdlen = sprintf(buffer, "AT+CPOL=,2,\"%.*s\"", 
    654654                                sizeof(gsmd_oper_numeric), oper); 
    655                 cmd = atcmd_fill(buffer, cmdlen + 1, &null_cmd_cb, gu, 0); 
     655                cmd = atcmd_fill(buffer, cmdlen + 1, &null_cmd_cb, gu, 0, NULL); 
    656656                break; 
    657657        case GSMD_NETWORK_PREF_SPACE: 
    658658                cmd = atcmd_fill("AT+CPOL=?", 9 + 1, 
    659                                 &network_pref_num_cb, gu, 0); 
     659                                &network_pref_num_cb, gu, 0, NULL); 
    660660                break; 
    661661        case GSMD_NETWORK_GET_NUMBER: 
    662662                cmd = atcmd_fill("AT+CNUM", 7 + 1, 
    663                                 &network_ownnumbers_cb, gu, 0); 
     663                                &network_ownnumbers_cb, gu, 0, NULL); 
    664664                break; 
    665665        default: 
    666666                return -EINVAL; 
     
    987987        case GSMD_PHONEBOOK_LIST_STORAGE: 
    988988                cmd = atcmd_fill("AT+CPBS=?", 9 + 1, 
    989989                                &phonebook_list_storage_cb, 
    990                                 gu, gph->id); 
     990                                gu, gph->id, NULL); 
    991991                break; 
    992992        case GSMD_PHONEBOOK_SET_STORAGE: 
    993993                if (len < sizeof(*gph) + 3) 
     
    998998                /* ex. AT+CPBS="ME" */ 
    999999                atcmd_len = 1 + strlen("AT+CPBS=\"") + 2 + strlen("\""); 
    10001000                cmd = atcmd_fill("AT+CPBS=\"", atcmd_len, 
    1001                                 &usock_cmd_cb, gu, gph->id); 
     1001                                &usock_cmd_cb, gu, gph->id, NULL); 
    10021002 
    10031003                if (!cmd) 
    10041004                        return -ENOMEM; 
     
    10131013                atcmd_len = 1 + strlen("AT+CPBF=\"") + 
    10141014                        strlen(gpf->findtext) + strlen("\""); 
    10151015                cmd = atcmd_fill("AT+CPBF=\"", atcmd_len, 
    1016                                  &phonebook_find_cb, gu, gph->id); 
     1016                                 &phonebook_find_cb, gu, gph->id, NULL); 
    10171017                if (!cmd) 
    10181018                        return -ENOMEM; 
    10191019                sprintf(cmd->buf, "AT+CPBF=\"%s\"", gpf->findtext); 
     
    10291029                /* ex, AT+CPBR=23 */ 
    10301030                atcmd_len = 1 + strlen("AT+CPBR=") + strlen(buf); 
    10311031                cmd = atcmd_fill("AT+CPBR=", atcmd_len, 
    1032                                  &phonebook_read_cb, gu, gph->id); 
     1032                                 &phonebook_read_cb, gu, gph->id, NULL); 
    10331033                if (!cmd) 
    10341034                        return -ENOMEM; 
    10351035                sprintf(cmd->buf, "AT+CPBR=%d", *index); 
     
    10441044                /* ex, AT+CPBR=1,100 */ 
    10451045                atcmd_len = 1 + strlen("AT+CPBR=") + strlen(buf); 
    10461046                cmd = atcmd_fill("AT+CPBR=", atcmd_len, 
    1047                                  &phonebook_readrg_cb, gu, gph->id); 
     1047                                 &phonebook_readrg_cb, gu, gph->id, NULL); 
    10481048                if (!cmd) 
    10491049                        return -ENOMEM; 
    10501050                sprintf(cmd->buf, "AT+CPBR=%s", buf); 
     
    10591059 
    10601060                atcmd_len = 1 + strlen("AT+CPBW=") + strlen(buf); 
    10611061                cmd = atcmd_fill("AT+CPBW=", atcmd_len, 
    1062                                  &phonebook_write_cb, gu, gph->id); 
     1062                                 &phonebook_write_cb, gu, gph->id, NULL); 
    10631063                if (!cmd) 
    10641064                        return -ENOMEM; 
    10651065                sprintf(cmd->buf, "AT+CPBW=%s", buf); 
     
    10741074                /* ex, AT+CPBW=3*/ 
    10751075                atcmd_len = 1 + strlen("AT+CPBW=") + strlen(buf); 
    10761076                cmd = atcmd_fill("AT+CPBW=", atcmd_len, 
    1077                                  &phonebook_delete_cb, gu, gph->id); 
     1077                                 &phonebook_delete_cb, gu, gph->id, NULL); 
    10781078                if (!cmd) 
    10791079                        return -ENOMEM; 
    10801080                sprintf(cmd->buf, "AT+CPBW=%s", buf); 
    10811081                break;   
    10821082        case GSMD_PHONEBOOK_GET_SUPPORT: 
    10831083                cmd = atcmd_fill("AT+CPBR=?", 9+1, 
    1084                                  &phonebook_get_support_cb, gu, gph->id); 
     1084                                 &phonebook_get_support_cb, gu, gph->id, NULL); 
    10851085                break; 
    10861086        case GSMD_PHONEBOOK_RETRIEVE_READRG: 
    10871087                if (len < sizeof(*gph) + sizeof(int)) 
     
    11451145                break; 
    11461146         
    11471147        case GSMD_PHONEBOOK_GET_IMSI: 
    1148                 cmd = atcmd_fill("AT+CIMI", 7 + 1, &get_imsi_cb, gu, 0); 
     1148                cmd = atcmd_fill("AT+CIMI", 7 + 1, &get_imsi_cb, gu, 0, NULL); 
    11491149                break; 
    11501150 
    11511151        default: 
  • src/gsmd/vendor_ti.c

    === src/gsmd/vendor_ti.c
    ==================================================================
     
    262262                return -EINVAL; 
    263263         
    264264        /* retrieve voicemail number */ 
    265         cmd = atcmd_fill("AT%CPMB=1", 10, &cpmb_detect_cb, g, 0); 
     265        cmd = atcmd_fill("AT%CPMB=1", 10, &cpmb_detect_cb, g, 0, NULL); 
    266266        if (cmd) 
    267267                atcmd_submit(g, cmd); 
    268268         
     
    304304        rc |= gsmd_simplecmd(g, "AT%CPHS=1"); 
    305305         
    306306        /* enable %CPI: call progress indication */ 
    307         cmd = atcmd_fill("AT%CPI=?", 9, &cpi_detect_cb, g, 0); 
     307        cmd = atcmd_fill("AT%CPI=?", 9, &cpi_detect_cb, g, 0, NULL); 
    308308        if (cmd) 
    309309                atcmd_submit(g, cmd); 
    310310 
  • src/gsmd/vendor_tihtc.c

    === src/gsmd/vendor_tihtc.c
    ==================================================================
     
    4545int gsmd_simplecmd(struct gsmd *gsmd, char *cmdtxt) 
    4646{ 
    4747        struct gsmd_atcmd *cmd; 
    48         cmd = atcmd_fill(cmdtxt, strlen(cmdtxt)+1, &gsmd_test_atcb, NULL, 0); 
     48        cmd = atcmd_fill(cmdtxt, strlen(cmdtxt)+1, &gsmd_test_atcb, NULL, 0, NULL); 
    4949        if (!cmd) 
    5050                return -ENOMEM; 
    5151 
     
    261261        rc |= gsmd_simplecmd(g, "AT%CUNS=0"); 
    262262 
    263263        /* enable %CPI: call progress indication */ 
    264         cmd = atcmd_fill("AT%CPI=?", 9, &cpi_detect_cb, g, 0); 
     264        cmd = atcmd_fill("AT%CPI=?", 9, &cpi_detect_cb, g, 0, NULL); 
    265265        if (cmd) 
    266266                atcmd_submit(g, cmd); 
    267267