nvitem/nvitem_sync.c

   1 \r
   2 #include "nvitem_common.h"\r
   3 #include "nvitem_buf.h"\r
   4 #include "nvitem_sync.h"\r
   5 #include "nvitem_packet.h"\r
   6 \r
   7 #define SYNC_REQ_HEAD 0\r
   8 #define SYNC_REQ_BODY 1\r
   9 #define SYNC_REQ_TAIL 2\r
  10 \r
  11 typedef struct\r
  12 {\r
  13         uint32  packet_type;                            // headd,body,tail\r
  14         uint32  reqIdx;                                         // ++operation\r
  15         uint32  partId;                                         // parition Id\r
  16         uint32  sctSize;                                                // size of sector\r
  17 }SYNC_HEAD;\r
  18 \r
  19 typedef struct\r
  20 {\r
  21         uint32  packet_type;                            // headd,body,tail\r
  22         uint32  reqIdx;                                         // ++operation\r
  23         uint32  partId;                                         // parition Id\r
  24         uint32  start;                                          // start position of dirty data\r
  25         uint32  num;                                            // number of dirty data, unit is sector\r
  26 }SYNC_BODY;\r
  27 \r
  28 typedef struct\r
  29 {\r
  30         uint32  packet_type;                            // headd,body,tail\r
  31         uint32  reqIdx;                                         // ++operation\r
  32         uint32  partId;                                         // parition Id\r
  33 }SYNC_TAIL;\r
  34 \r
  35 typedef union\r
  36 {\r
  37         SYNC_HEAD       head;\r
  38         SYNC_BODY       body;\r
  39         SYNC_TAIL       tail;\r
  40 }SYNC_REQ;\r
  41 \r
  42 \r
  43 uint32 _syncState;      // 0: analyzer head ,1 analyzer body, 2 annalyzer tail\r
  44 uint32 _syncBusy        = 0;    // 0: idle,  1: busy\r
  45 \r
  46 static  uint32  syncReqFrame = 0;\r
  47 static  uint8*  syncReqBuf[sizeof(SYNC_REQ)];\r
  48 static  uint32  _ofst = 0;\r
  49 static  uint32  _id = (uint32)(-1);\r
  50 static  uint32  _start = 0;\r
  51 static  uint32  _len    = 0;\r
  52 \r
  53 //----------------------------\r
  54 //      Init Sync module\r
  55 //----------------------------\r
  56 void _syncInit(void)\r
  57 {\r
  58         _syncState = 0;\r
  59         _syncBusy = 0;\r
  60         syncReqFrame = 0;\r
  61         //syncReqBuf;\r
  62         _ofst = 0;\r
  63         _id = (uint32)(-1);\r
  64         _start = 0;\r
  65         _len    = 0;\r
  66 }\r
  67 //----------------------------\r
  68 //      Reset Sync module\r
  69 //----------------------------\r
  70 /*PASS*/\r
  71 #define SYNC_FAIL_RESET 0\r
  72 #define SYNC_SUC_RESET  1\r
  73 static BOOLEAN _syncReset(uint32 ifSuc)\r
  74 {\r
  75         BOOLEAN ret;\r
  76 \r
  77         ret = 1;\r
  78         if(ifSuc)\r
  79         {\r
  80                 ret = backupData(_id);\r
  81         }\r
  82         else\r
  83         {\r
  84                 if(_syncState)  // in this state , fromchannel buffer maybe changed. So we must restore it.\r
  85                 {\r
  86                         restoreData(_id);\r
  87                 }\r
  88         }\r
  89         _syncInit();\r
  90         return ret;\r
  91 }\r
  92 \r
  93 //--------------------------------------------------\r
  94 //      TRUE: have getted\r
  95 //      FALSE: not getted, need more information\r
  96 /*PASS*/\r
  97 static uint32 __getToken(uint8* *buf, uint32* size)\r
  98 {\r
  99         if((sizeof(SYNC_REQ)-_ofst) > *size)\r
 100         {\r
 101                 if(*size)\r
 102                 {\r
 103                         return 0;\r
 104                 }\r
 105                 memcpy(syncReqBuf+_ofst, *buf, *size);\r
 106                 _ofst += *size;\r
 107                 *buf += *size;\r
 108                 *size = 0;\r
 109                 return 0;\r
 110         }\r
 111         else\r
 112         {\r
 113                 if(0 == (sizeof(SYNC_REQ)-_ofst))\r
 114                 {\r
 115                         _ofst = 0;\r
 116                         return 1;\r
 117                 }\r
 118                 memcpy(syncReqBuf+_ofst, *buf,(sizeof(SYNC_REQ)-_ofst));\r
 119                 *buf += (sizeof(SYNC_REQ)-_ofst);\r
 120                 *size -= (sizeof(SYNC_REQ)-_ofst);\r
 121                 _ofst = 0;\r
 122                 return 1;\r
 123         }\r
 124 }\r
 125 \r
 126 \r
 127 #define SYNC_CONTINUE   0               // analyzer not complete, information is not enough, wait for continuous information\r
 128 #define SYNC_NEXT               1               // one token analyzer complete,  should analyzer next token of request\r
 129 #define SYNC_DONE               2               // all token analyzer is all complete\r
 130 #define SYNC_FAIL               3               // analyzer fail, infomation error, should reset\r
 131 /*PASS*/\r
 132 static uint32 _syncGetHead(uint8** buf, uint32 *size)\r
 133 {\r
 134         SYNC_REQ* head = (SYNC_REQ*)syncReqBuf;\r
 135 \r
 136         if(!__getToken(buf,size))\r
 137         {\r
 138                 return SYNC_CONTINUE;\r
 139         }\r
 140         if(SYNC_REQ_HEAD != head->head.packet_type)\r
 141         {\r
 142                 return SYNC_FAIL;\r
 143         }\r
 144         syncReqFrame = head->head.reqIdx;\r
 145         printf("NVITEM:_syncGetHead partId 0x%x\n",head->head.partId);\r
 146         _id = getCtlId(head->head.partId);\r
 147         if(((uint32)-1) == _id)\r
 148         {\r
 149                 return SYNC_FAIL;\r
 150         }\r
 151         return SYNC_NEXT;\r
 152 }\r
 153 \r
 154 /*PASS*/\r
 155 static uint32 _syncGetBody(uint8** buf, uint32* size)\r
 156 {\r
 157         SYNC_REQ* req = (SYNC_REQ*)syncReqBuf;\r
 158 \r
 159         if(!__getToken(buf,size))\r
 160         {\r
 161                 return SYNC_CONTINUE;\r
 162         }\r
 163         if(SYNC_REQ_BODY == req->body.packet_type)\r
 164         {\r
 165                 if((syncReqFrame+1) != req->body.reqIdx)\r
 166                 {\r
 167                         return SYNC_FAIL;\r
 168                 }\r
 169                 syncReqFrame++;\r
 170                 _markDirtyInfo(_id,  req->body.start, req->body.num);\r
 171                 _start  = req->body.start*RAMNV_SECT_SIZE;\r
 172                 _len    = req->body.num*RAMNV_SECT_SIZE;\r
 173                 return SYNC_NEXT;\r
 174         }\r
 175         else if(SYNC_REQ_TAIL == req->tail.packet_type)\r
 176         {\r
 177                 if((syncReqFrame+1) != req->tail.reqIdx)\r
 178                 {\r
 179                         return SYNC_FAIL;\r
 180                 }\r
 181                 syncReqFrame++;\r
 182                 return SYNC_DONE;\r
 183         }\r
 184         else\r
 185         {\r
 186                 return SYNC_FAIL;\r
 187         }\r
 188 }\r
 189 \r
 190 /*PASS*/\r
 191 static uint32 _syncGetData(uint8** buf, uint32* size)\r
 192 {\r
 193         if(_len <= *size)\r
 194         {\r
 195                 writeData(_id,  _start, _len, *buf);\r
 196                 *buf    +=_len;\r
 197                 *size   -=_len;\r
 198                 _start  += _len;\r
 199                 _len    = 0;\r
 200                 return SYNC_NEXT;\r
 201         }\r
 202         else\r
 203         {\r
 204                 writeData(_id,  _start, *size, *buf);\r
 205                 _start  += *size;\r
 206                 _len    -= *size;\r
 207                 *buf    += *size;\r
 208                 *size   = 0;\r
 209                 return SYNC_CONTINUE;\r
 210         }\r
 211 }\r
 212 \r
 213 \r
 214 //----------------------------\r
 215 //      analyzer packet buf\r
 216 //----------------------------\r
 217 /*PASS*/\r
 218 void syncAnalyzer(void)\r
 219 {\r
 220         uint32 syncRet;\r
 221         uint32 packetState;\r
 222         uint8* buf = 0;\r
 223         uint32 size = 0;\r
 224 \r
 225 do\r
 226 {\r
 227         packetState = _getPacket(&buf, &size);\r
 228         if(_PACKET_FAIL == packetState)\r
 229         {\r
 230                 //printf("NVITEM:packetState fail\n");\r
 231                 // packet module connection fail. teminate current req process\r
 232                 //_syncReset(SYNC_FAIL_RESET);\r
 233                 return;\r
 234         }\r
 235         else if((_PACKET_START == packetState)&&_syncBusy)\r
 236         {\r
 237                 printf("NVITEM:packetState no req tail\n");\r
 238                 // 1 == _syncBusy, means current req not finish\r
 239                 // _PACKET_START means next req has come. so teminate current req process, and start new process\r
 240                 _syncReset(SYNC_FAIL_RESET);\r
 241         }\r
 242         else if((_PACKET_CONTINUE == packetState)&&(!_syncBusy))\r
 243         {\r
 244                 printf("NVITEM:packetState no req head\n");\r
 245                 // 0 == _syncBusy, means no req is process.\r
 246                 // 1 _PACKET_CONTINUE means body of req. So has no head, skip it.\r
 247                 _sendPacktRsp(0);\r
 248                 continue;\r
 249         }\r
 250         else if(_PACKET_SKIP == packetState)\r
 251         {\r
 252                 printf("NVITEM:packetState skip\n");\r
 253                 // invalid packet, skip it\r
 254                 continue;\r
 255         }\r
 256 \r
 257         _syncBusy = 1;\r
 258 \r
 259         while(0 != size)\r
 260         {\r
 261                 if(0 == _syncState)                                                     // head analyzer\r
 262                 {\r
 263                         syncRet = _syncGetHead(&buf, &size);\r
 264                         if(SYNC_FAIL == syncRet)\r
 265                         {\r
 266                                 printf("NVITEM:_syncGetHead fail\n");\r
 267                                 _syncReset(SYNC_FAIL_RESET);\r
 268                                 _sendPacktRsp(0);\r
 269                                 break;\r
 270                         }\r
 271                         else if(SYNC_NEXT == syncRet)\r
 272                         {\r
 273                                 _syncState = 1;\r
 274                                 continue;\r
 275                         }\r
 276                         else if(SYNC_CONTINUE == syncRet)\r
 277                         {\r
 278                                 _sendPacktRsp(1);\r
 279                                 break;\r
 280                         }\r
 281                 }\r
 282                 else if(1 == _syncState)                                                // body and tail analyzer\r
 283                 {\r
 284                         syncRet = _syncGetBody(&buf, &size);\r
 285                         if(SYNC_FAIL == syncRet)\r
 286                         {\r
 287                                 printf("NVITEM:_syncGetBody fail\n");\r
 288                                 _syncReset(SYNC_FAIL_RESET);\r
 289                                 _sendPacktRsp(0);\r
 290                                 break;\r
 291                         }\r
 292                         else if(SYNC_NEXT == syncRet)\r
 293                         {\r
 294                                 _syncState = 2;\r
 295                                 continue;\r
 296                         }\r
 297                         else if(SYNC_CONTINUE == syncRet)\r
 298                         {\r
 299                                 _sendPacktRsp(1);\r
 300                                 break;\r
 301                         }\r
 302                         else if(SYNC_DONE == syncRet)\r
 303                         {\r
 304                                 printf("NVITEM:sync _syncGetTail success\n");\r
 305                                 _sendPacktRsp(_syncReset(SYNC_SUC_RESET));\r
 306                                 break;\r
 307                         }\r
 308                 }\r
 309                 else // (2 == _syncState)                                               // data analyzer\r
 310                 {\r
 311                         syncRet =  _syncGetData(&buf, &size);\r
 312                         if(SYNC_CONTINUE == syncRet)\r
 313                         {\r
 314                                 _sendPacktRsp(1);\r
 315                                 break;\r
 316                         }\r
 317                         else if(SYNC_NEXT == syncRet)\r
 318                         {\r
 319                                 _syncState = 1;\r
 320                                 continue;\r
 321                         }\r
 322                 }\r
 323         }\r
 324 }while(1);\r
 325 }\r
 326 \r