d7a_modem.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "dbg.h"
00004 #include "d7a_com.h"
00005 #include "d7a_fs.h"
00006 #include "d7a_modem.h"
00007 #include "d7a_sys.h"
00008 #include "d7a_common.h"
00009 #include "d7a.h"
00010 #include "d7a_alp.h"
00011 #include "d7a_typedefs.h"
00012 
00013 #if 1
00014     #define MODEM_DPRINT(...)       DPRINT(__VA_ARGS__)
00015     #define MODEM_DPRINT_DATA(...)  DPRINT_DATA(__VA_ARGS__)
00016     #define MODEM_FPRINT(...)       FPRINT(__VA_ARGS__)
00017 #else
00018     #define MODEM_DPRINT(...);
00019     #define MODEM_DPRINT_DATA(...);
00020     #define MODEM_FPRINT(...);
00021 #endif
00022 
00023 #define MODEM_TO    (20000)
00024 
00025 static NotifDoneFunction                g_modem_notif_done;
00026 static bool                             g_modem_booted;
00027 
00028 static MBED_PinName                     g_modem_reset_pin;
00029 
00030 static OS_Thread                        g_modem_thread(osPriorityHigh, 512, NULL);
00031 static OS_Queue<void, 8>                g_modem_ready;
00032 static OS_Queue<void, 2>                g_modem_boot;
00033 static OS_Queue<d7a_com_rx_msg_t, 8>    g_modem_pkt_queue;
00034 
00035 
00036 void d7a_modem_thread();
00037 
00038 d7a_errors_t d7a_modem_open(MBED_PinName reset_pin, NotifDoneFunction nd)
00039 {
00040     MODEM_FPRINT("\r\n");
00041     
00042     d7a_errors_t err;
00043         
00044     osStatus error = g_modem_thread.start(d7a_modem_thread);
00045     ASSERT(error == osOK, "Failed to start d7a_modem_thread (err: %d)\r\n", error);
00046     
00047     g_modem_booted = false;
00048     g_modem_notif_done = nd;
00049     g_modem_reset_pin = reset_pin;
00050 
00051     if (g_modem_reset_pin != NC)
00052     {
00053         DigitalIn rst(g_modem_reset_pin);
00054     }
00055 
00056     err = d7a_modem_reset();
00057     
00058     return err;
00059 }
00060 
00061 d7a_errors_t d7a_modem_close(void)
00062 {
00063     MODEM_FPRINT("\r\n");
00064         
00065     g_modem_thread.terminate();
00066     
00067     if (g_modem_reset_pin != NC)
00068     {   // Release reset
00069         DigitalIn rst(g_modem_reset_pin);
00070     }
00071     
00072     return D7A_ERR_NONE;
00073 }
00074 
00075 d7a_errors_t d7a_modem_wait_boot( uint32_t millisec )
00076 {
00077     MODEM_FPRINT("(%d)\r\n", millisec);
00078     osEvent evt = g_modem_boot.get(millisec);
00079     return (evt.status == osEventMessage)? (d7a_errors_t)(int32_t)evt.value.p : D7A_ERR_CMD_TO;
00080 }
00081 
00082 d7a_errors_t d7a_modem_wait_ready( uint32_t millisec )
00083 {
00084     MODEM_FPRINT("(%d)\r\n", millisec);
00085     osEvent evt = g_modem_ready.get(millisec);
00086     return (evt.status == osEventMessage)? (d7a_errors_t)(int32_t)evt.value.p : D7A_ERR_CMD_TO;
00087 }
00088 
00089 static void d7a_modem_soft_reset(void)
00090 {
00091     MODEM_FPRINT("\r\n");
00092     IPRINT("MODEM Soft Reset.\r\n");
00093             
00094     // Clean buffer and queues
00095     d7a_com_restart();
00096     
00097     // Try software reset
00098     d7a_sys_software_reset();
00099 }
00100 
00101 static void d7a_modem_hard_reset(void)
00102 {
00103     MODEM_FPRINT("\r\n");
00104         
00105     IPRINT("MODEM Hard Reset.\r\n");
00106     
00107     // Use hardware reset
00108     if (g_modem_reset_pin != NC)
00109     {   // Clear reset
00110         DigitalOut rst(g_modem_reset_pin, 0);
00111     }
00112     
00113     // Clean buffer and queues
00114     d7a_com_restart();
00115     OS_Thread  ::wait(100);
00116     
00117     if (g_modem_reset_pin != NC)
00118     {   // Release reset
00119         DigitalIn rst(g_modem_reset_pin);
00120     }
00121 }
00122 
00123 d7a_errors_t d7a_modem_reset(void)
00124 {
00125     MODEM_FPRINT("\r\n");
00126     d7a_errors_t err = D7A_ERR_UNKNOWN;
00127     g_modem_booted = false;
00128 
00129     //d7a_modem_soft_reset();
00130     //err = d7a_modem_wait_boot(5000);
00131     
00132     if (err)
00133     {
00134         d7a_modem_hard_reset();
00135         err = d7a_modem_wait_boot(MODEM_TO);
00136     }
00137     ASSERT(!err, "MODEM BOOT err %d\r\n", err);
00138     g_modem_booted = true;
00139     
00140     err = d7a_modem_wait_ready(MODEM_TO);
00141     ASSERT(!err, "MODEM READY err %d\r\n", err);
00142     
00143     IPRINT("MODEM Ready.\r\n");
00144     
00145     return err;
00146 }
00147 
00148 void d7a_modem_new_pkt(d7a_com_rx_msg_t* pkt)
00149 {
00150     MODEM_FPRINT("\r\n");
00151     ASSERT(g_modem_pkt_queue.put(pkt) == osOK, "MODEM queue full!\r\n");
00152 }
00153 
00154 d7a_com_rx_msg_t* d7a_modem_wait_pkt(uint32_t millisec)
00155 {
00156     MODEM_FPRINT("(millisec:%d)\r\n", millisec);
00157     osEvent evt = g_modem_pkt_queue.get(millisec);
00158     return (evt.status == osEventMessage)? (d7a_com_rx_msg_t*)evt.value.p : NULL;
00159 }
00160 
00161 void d7a_modem_msg(uint8_t value, uint8_t* buf, uint8_t len)
00162 {
00163     MODEM_FPRINT("(value:0x%02X, buf:0x%08x, len:%d)\r\n", value, buf, len);
00164     d7a_com_tx_msg_t msg;
00165     uint8_t val = value;
00166     msg.id = KAL_COM_FLOW_CMD;
00167     msg.pbuf = &val;
00168     msg.abuf = buf;
00169     msg.plen = 1;
00170     msg.alen = len;
00171     d7a_com_post_msg(&msg);
00172 }
00173 
00174 d7a_errors_t d7a_modem_register(register_file_param_t* file_infos)
00175 {
00176     d7a_errors_t err;
00177     
00178     d7a_modem_msg(WM_CMD_REGISTER_FILE, (uint8_t*)file_infos, sizeof(register_file_param_t));
00179     err = d7a_modem_wait_ready(TO_FS);
00180             
00181     return err;
00182 }
00183 
00184 d7a_errors_t d7a_modem_notify(notify_file_param_t* notif)
00185 {
00186     d7a_errors_t err;
00187     
00188     d7a_modem_msg(WM_CMD_NOTIFY_FILE, (uint8_t*)notif, sizeof(notify_file_param_t));
00189     err = d7a_modem_wait_ready(TO_FS);
00190             
00191     return err;
00192 }
00193 
00194 d7a_errors_t d7a_modem_start(void)
00195 {
00196     d7a_errors_t err;
00197     
00198     MODEM_DPRINT("Start modem.\r\n");
00199 
00200     d7a_modem_msg(WM_CMD_D7A_STACK_START, NULL, 0);
00201     err = d7a_modem_wait_ready(TO_FS);
00202     
00203     WARNING(!err, "Start modem err %d\r\n", err);
00204         
00205     MODEM_DPRINT("Start done.\r\n");
00206     
00207     return err;
00208 }
00209 
00210 d7a_errors_t d7a_modem_stop(void)
00211 {
00212     d7a_errors_t err;
00213     
00214     MODEM_DPRINT("Stop modem.\r\n");
00215 
00216     d7a_modem_msg(WM_CMD_D7A_STACK_STOP, NULL, 0);
00217     err = d7a_modem_wait_ready(TO_FS);
00218             
00219     MODEM_DPRINT("Stop done.\r\n");
00220     
00221     return err;
00222 }
00223 
00224 void d7a_modem_thread()
00225 {
00226     MODEM_FPRINT("(id:0x%08x)\r\n", osThreadGetId());
00227     d7a_com_rx_msg_t* pkt;
00228     
00229     while (true)
00230     {
00231         pkt = d7a_modem_wait_pkt();
00232         ASSERT(pkt != NULL, "MODEM NULL pkt\r\n");
00233 
00234         switch(pkt->id)
00235         {
00236             case KAL_COM_FLOW_CMD:
00237                 uint8_t cmd = pkt->buffer[0];
00238                 if (cmd == WM_OK)
00239                 {
00240                     MODEM_DPRINT("Modem ready\r\n");
00241                     g_modem_ready.put((void*)D7A_ERR_NONE);
00242                 }
00243                 else if (cmd == WM_BOOT)
00244                 {
00245                     boot_status_t* bs = (boot_status_t*)&(pkt->buffer[1]);
00246                     WARNING(false, "Modem booted CAUSE:%d NB_BOOT:%d\r\n", bs->bf.cause, bs->bf.nb_boot);
00247                     
00248                     if (g_modem_booted == true)
00249                     {
00250                         // Do something?
00251                     }
00252                     else
00253                     {
00254                         g_modem_boot.put(NULL);
00255                     }
00256                 }
00257                 else if (cmd == WM_ERROR)
00258                 {
00259                     int8_t err = pkt->buffer[1];
00260                     int8_t ret;
00261                     
00262                     WARNING(false, "Modem cmd error %d\r\n", err);
00263                     switch (err)
00264                     {
00265                         case WM_ERR_NOT_READY:          ret = D7A_ERR_NOT_READY; break;
00266                         case WM_ERR_COM_LINK:           ret = D7A_ERR_COM_LINK; break;
00267                         case WM_ERR_ILLEGAL_FID:        ret = D7A_ERR_ILLEGAL_FID; break;
00268                         case WM_ERR_ILLEGAL_FILE_DEF:   ret = D7A_ERR_ILLEGAL_FILE_DEF; break;
00269                         case WM_ERR_UNKNOWN:            ret = D7A_ERR_UNKNOWN; break;
00270                         default:                        ret = D7A_ERR_NONE; break;
00271                     }
00272                     
00273                     g_modem_ready.put((void*)ret);
00274                 }
00275                 else if (cmd == WM_NOTIF_DONE)
00276                 {
00277                     if (g_modem_notif_done != NULL)
00278                     {
00279                         g_modem_notif_done(pkt->buffer[1], pkt->buffer[2]);
00280                     }
00281                 }
00282                 else
00283                 {
00284                     EPRINT("MODEM Unknown cmd %d\r\n", cmd);
00285                 }
00286                 break;
00287             default:
00288                 EPRINT("MODEM Unknown Flow ID 0x%02X\r\n", pkt->id);
00289                 break;
00290         }
00291         
00292         FREE(pkt);
00293     }
00294 }
00295 
00296 
00297