开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
uart_api.c
资源名称：tb_i86_wr_1019_1102.　[点击查看]
上传用户：super_houu
上传日期：2008-09-21
资源大小：4099k
文件大小：19k
源码类别：

DVD

开发平台：

Others

uart_api.c：源码内容
  1. /*****************************************************************************
  2. Copyright (c) 2000 ZORAN Corporation, All Rights Reserved
  3. THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
  5. File: "uart_api.c"                                      07/11/01
  7.      Created by: Rinat Alfia rinata@zoran.co.il
  9. Description:
  10.       Uart driver for UART 0 - use by Boot ROM only.
  12. *****************************************************************************/
  14. #include "config.h"
  16. #ifdef SUPPORT_KEYS_UPDATE
  18. /* Includes */
  19. #include "UARTStore_Keys.h"
  20. #include "Uartuart_api.h"
  21. #include "eeprom.h"
  22.                                      
  23. /* Defines */
  24. //#define I49_IC
  25. //#ifdef I49_IC
  26. #define BAUDDIV  0xdc//0xb0 // 54000000/19200/16
  27. //#else
  28. //#error "Set baud rate for I64"
  29. //#endif
  31. #define UART_CON     0xff80U
  32. #define UART_BDIV    0xff88U
  33. #define UART_STS     0xff82U
  34. #define UART_TDATA   0xff84U
  35. #define UART_RDATA   0xff86U
  37. #define UART_RMODE1 0x0001 /* MODE bit 0 mask */
  38. #define UART_TMODE 0x0040 /* TMODE enable mask */
  39. #define UART_RMODE 0x0020 /* RMODE enable mask */
  41. #define TIME_OUT_LIMIT 0x7ffffUL
  43. static DWORD crc32;
  44. static BOOL timeout=FALSE;
  46. extern CONST BYTE Store_Keys_Num;
  47. extern CONST KEYS_STORE_STRUCT Store_Keys_Map[];
  48. extern BYTE* new_keys;
  50. #define START_CODE_LENGHT 12
  51. CONST BYTE Start_Code[START_CODE_LENGHT]={0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00};
  52. static CONST DWORD crc32_table[256] = {
  53.    0x00000000UL,0x77073096UL,0xee0e612cUL,0x990951baUL,0x076dc419UL,0x706af48fUL,0xe963a535UL,0x9e6495a3UL,
  54.    0x0edb8832UL,0x79dcb8a4UL,0xe0d5e91eUL,0x97d2d988UL,0x09b64c2bUL,0x7eb17cbdUL,0xe7b82d07UL,0x90bf1d91UL,
  55.    0x1db71064UL,0x6ab020f2UL,0xf3b97148UL,0x84be41deUL,0x1adad47dUL,0x6ddde4ebUL,0xf4d4b551UL,0x83d385c7UL,
  56.    0x136c9856UL,0x646ba8c0UL,0xfd62f97aUL,0x8a65c9ecUL,0x14015c4fUL,0x63066cd9UL,0xfa0f3d63UL,0x8d080df5UL,
  57.    0x3b6e20c8UL,0x4c69105eUL,0xd56041e4UL,0xa2677172UL,0x3c03e4d1UL,0x4b04d447UL,0xd20d85fdUL,0xa50ab56bUL,
  58.    0x35b5a8faUL,0x42b2986cUL,0xdbbbc9d6UL,0xacbcf940UL,0x32d86ce3UL,0x45df5c75UL,0xdcd60dcfUL,0xabd13d59UL,
  59.    0x26d930acUL,0x51de003aUL,0xc8d75180UL,0xbfd06116UL,0x21b4f4b5UL,0x56b3c423UL,0xcfba9599UL,0xb8bda50fUL,
  60.    0x2802b89eUL,0x5f058808UL,0xc60cd9b2UL,0xb10be924UL,0x2f6f7c87UL,0x58684c11UL,0xc1611dabUL,0xb6662d3dUL,
  61.    0x76dc4190UL,0x01db7106UL,0x98d220bcUL,0xefd5102aUL,0x71b18589UL,0x06b6b51fUL,0x9fbfe4a5UL,0xe8b8d433UL,
  62.    0x7807c9a2UL,0x0f00f934UL,0x9609a88eUL,0xe10e9818UL,0x7f6a0dbbUL,0x086d3d2dUL,0x91646c97UL,0xe6635c01UL,
  63.    0x6b6b51f4UL,0x1c6c6162UL,0x856530d8UL,0xf262004eUL,0x6c0695edUL,0x1b01a57bUL,0x8208f4c1UL,0xf50fc457UL,
  64.    0x65b0d9c6UL,0x12b7e950UL,0x8bbeb8eaUL,0xfcb9887cUL,0x62dd1ddfUL,0x15da2d49UL,0x8cd37cf3UL,0xfbd44c65UL,
  65.    0x4db26158UL,0x3ab551ceUL,0xa3bc0074UL,0xd4bb30e2UL,0x4adfa541UL,0x3dd895d7UL,0xa4d1c46dUL,0xd3d6f4fbUL,
  66.    0x4369e96aUL,0x346ed9fcUL,0xad678846UL,0xda60b8d0UL,0x44042d73UL,0x33031de5UL,0xaa0a4c5fUL,0xdd0d7cc9UL,
  67.    0x5005713cUL,0x270241aaUL,0xbe0b1010UL,0xc90c2086UL,0x5768b525UL,0x206f85b3UL,0xb966d409UL,0xce61e49fUL,
  68.    0x5edef90eUL,0x29d9c998UL,0xb0d09822UL,0xc7d7a8b4UL,0x59b33d17UL,0x2eb40d81UL,0xb7bd5c3bUL,0xc0ba6cadUL,
  69.    0xedb88320UL,0x9abfb3b6UL,0x03b6e20cUL,0x74b1d29aUL,0xead54739UL,0x9dd277afUL,0x04db2615UL,0x73dc1683UL,
  70.    0xe3630b12UL,0x94643b84UL,0x0d6d6a3eUL,0x7a6a5aa8UL,0xe40ecf0bUL,0x9309ff9dUL,0x0a00ae27UL,0x7d079eb1UL,
  71.    0xf00f9344UL,0x8708a3d2UL,0x1e01f268UL,0x6906c2feUL,0xf762575dUL,0x806567cbUL,0x196c3671UL,0x6e6b06e7UL,
  72.    0xfed41b76UL,0x89d32be0UL,0x10da7a5aUL,0x67dd4accUL,0xf9b9df6fUL,0x8ebeeff9UL,0x17b7be43UL,0x60b08ed5UL,
  73.    0xd6d6a3e8UL,0xa1d1937eUL,0x38d8c2c4UL,0x4fdff252UL,0xd1bb67f1UL,0xa6bc5767UL,0x3fb506ddUL,0x48b2364bUL,
  74.    0xd80d2bdaUL,0xaf0a1b4cUL,0x36034af6UL,0x41047a60UL,0xdf60efc3UL,0xa867df55UL,0x316e8eefUL,0x4669be79UL,
  75.    0xcb61b38cUL,0xbc66831aUL,0x256fd2a0UL,0x5268e236UL,0xcc0c7795UL,0xbb0b4703UL,0x220216b9UL,0x5505262fUL,
  76.    0xc5ba3bbeUL,0xb2bd0b28UL,0x2bb45a92UL,0x5cb36a04UL,0xc2d7ffa7UL,0xb5d0cf31UL,0x2cd99e8bUL,0x5bdeae1dUL,
  77.    0x9b64c2b0UL,0xec63f226UL,0x756aa39cUL,0x026d930aUL,0x9c0906a9UL,0xeb0e363fUL,0x72076785UL,0x05005713UL,
  78.    0x95bf4a82UL,0xe2b87a14UL,0x7bb12baeUL,0x0cb61b38UL,0x92d28e9bUL,0xe5d5be0dUL,0x7cdcefb7UL,0x0bdbdf21UL,
  79.    0x86d3d2d4UL,0xf1d4e242UL,0x68ddb3f8UL,0x1fda836eUL,0x81be16cdUL,0xf6b9265bUL,0x6fb077e1UL,0x18b74777UL,
  80.    0x88085ae6UL,0xff0f6a70UL,0x66063bcaUL,0x11010b5cUL,0x8f659effUL,0xf862ae69UL,0x616bffd3UL,0x166ccf45UL,
  81.    0xa00ae278UL,0xd70dd2eeUL,0x4e048354UL,0x3903b3c2UL,0xa7672661UL,0xd06016f7UL,0x4969474dUL,0x3e6e77dbUL,
  82.    0xaed16a4aUL,0xd9d65adcUL,0x40df0b66UL,0x37d83bf0UL,0xa9bcae53UL,0xdebb9ec5UL,0x47b2cf7fUL,0x30b5ffe9UL,
  83.    0xbdbdf21cUL,0xcabac28aUL,0x53b39330UL,0x24b4a3a6UL,0xbad03605UL,0xcdd70693UL,0x54de5729UL,0x23d967bfUL,
  84.    0xb3667a2eUL,0xc4614ab8UL,0x5d681b02UL,0x2a6f2b94UL,0xb40bbe37UL,0xc30c8ea1UL,0x5a05df1bUL,0x2d02ef8dUL
  85. };
  88. void _calculate_CRC(BYTE *data, int len)
  89. {
  90. unsigned long oldcrc32;
  91. unsigned long oldcrc;
  92. unsigned  int charcnt;
  93. BYTE c,t;
  95. oldcrc32 = crc32; //
  96. charcnt=0;
  97. while (len--) 
  98. {
  99. t= (BYTE)((oldcrc32 >> 24) & 0xFF);
  100. oldcrc=crc32_table[t];
  101. c=data[charcnt];
  102. oldcrc32= ((oldcrc32 << 8)&0xFFFFFF00) | (DWORD)c;
  103. oldcrc32^=oldcrc;
  104. charcnt++;
  105. }
  106. crc32=oldcrc32;
  107. return;
  108. }
  109. void _switch_word(WORD *data)
  110. {
  111. *data = (*data&0x00ff)<<8 | (*data&0xff00) >> 8;
  112. }
  113. void _switch_dword(DWORD *data)
  114. {
  115. *data = (*data&0xff)<<24 | (*data&0xff00)<<8 | (*data&0xff0000)>>8 | (*data&0xff000000)>>24;
  116. }
  117. /*---------------------------------------------------------------------------------
  118.  Purpose          :  Initialization of UART 0
  119.  Description :  Set UART Control and UART baud rate div registers
  120.  Input Parameters :  none
  121.  Return Value     :  none
  122. ---------------------------------------------------------------------------------*/
  123. void _uartOpen(void)
  124. {
  125. boot_outport( UART_CON, UART_RMODE1 | UART_TMODE | UART_RMODE );   // 8 bit word, 1 stop bit, no parity
  126. //#if defined(__JTAG__) || defined(__PDREMOTE__)
  127. // _uartBaudRate(0x50); // to debug on vautomation board
  128. //#else
  129. _uartBaudRate( BAUDDIV );
  130. //#endif
  131. }
  132. /*---------------------------------------------------------------------------------
  133.  Purpose          : Set UART baud rate
  134.  Description : Set UART_BDIV register
  135.  Input Parameters : baud_rate - the baud rate to set
  136.  Return Value     : void
  137. ---------------------------------------------------------------------------------*/
  138. void _uartBaudRate( unsigned int baud_rate )
  139. {
  140. while (!_uartIsTxReady());   // wait for tx ready to be set
  141. boot_outport(UART_BDIV, baud_rate);
  142. }
  143. /*---------------------------------------------------------------------------------
  144.  Purpose          :  Return if TX is ready
  145.  Description :  Read UART_STS TX bit
  146.  Input Parameters :  none
  147.  Return Value     :  TRUE - When TX is ready, else FLASE
  148. ---------------------------------------------------------------------------------*/
  149. BOOL _uartIsTxReady(void)
  150. {
  151. return (boot_inport(UART_STS) & 0x40) != 0; // is tx ready set
  152. }
  153. /*---------------------------------------------------------------------------------
  154.  Purpose          :  Return if RX is ready
  155.  Description :  Read UART_STS RX bit
  156.  Input Parameters :  none
  157.  Return Value     :  TRUE - When RX is ready, else FLASE
  158. ---------------------------------------------------------------------------------*/
  159. BOOL _uartIsRxReady(void)
  160. {
  161. return (boot_inport(UART_STS) & 0x80) != 0; // is rx ready set
  162. }
  163. /*---------------------------------------------------------------------------------
  164.  Purpose          :  Send one byte through UART 0
  165.  Description :  Wait Tx ready and then write to TDATA register.
  166.  Input Parameters :  byte - the byte to send
  167.  Return Value     :  void
  168. ---------------------------------------------------------------------------------*/
  169. void _uartSndByte( unsigned char byte)
  170. {
  171. while (!_uartIsTxReady()) ; // wait for tx ready to be set
  172. boot_outport(UART_TDATA, (int)byte);
  173. }
  174. /*---------------------------------------------------------------------------------
  175.  Purpose          :  Get one byte through UART 0
  176.  Description :  Wait Rx ready and then read from RDATA register.
  177.  Input Parameters :  none
  178.  Return Value     :  The read byte
  179. ---------------------------------------------------------------------------------*/
  180. unsigned char _uartRcvByte(void)
  181. {
  182. unsigned char c;
  183. DWORD times=0;
  184. while (!_uartIsRxReady())
  185. if( times++ > TIME_OUT_LIMIT)
  186. {
  187. timeout=TRUE;
  188. return 0;
  189. }
  190. c = (char)boot_inport(UART_RDATA);
  191. return c;
  192. }
  193. /*---------------------------------------------------------------------------------
  194.  Purpose          :  Send N bytes through uart 0
  195.  Description :  Call _uartSndByte N times
  196.  Input Parameters :  buff - pointer to array of bytes to send
  197.   N - number of bytes to send
  198.  Return Value     :  none
  199. ---------------------------------------------------------------------------------*/
  200. void _uartSndNBytes(unsigned char *buff , int N )
  201. {
  202. while (N--)
  203. {
  204. _calculate_CRC(buff, 1);
  205. _uartSndByte(*buff++);
  207. }
  208. }
  209. /*---------------------------------------------------------------------------------
  210.  Purpose          :  Recived N bytes through uart 0
  211.  Description :  Call _uartRcvByte N times
  212.  Input Parameters :  buff - pointer the recived buffer
  213.   N - number of bytes to recived
  214.  Return Value     :  none
  215. ---------------------------------------------------------------------------------*/
  216. BOOL _uartRcvNBytes( unsigned char *buff, int N)
  217. {
  218. //tr_printf(("_uartRcvNBytes(%d)n",N));
  219. while (N--)
  220. {
  221. *buff =_uartRcvByte();
  222. if(timeout)
  223. {
  224. tr_printf(("Receive data timeout!n"));
  225. timeout = 0;
  226. return FALSE;
  227. }
  228. tr_printf(("%02x  ",*buff));
  229. _calculate_CRC(buff, 1);
  230. buff++;
  231. }
  232. tr_printf(("n"));
  233. return TRUE;
  234. }
  235. /*---------------------------------------------------------------------------------
  236.  Purpose          :  out "data" register to "port" register
  237.  Description :  Implimentation in assembler
  238.  Input Parameters :  port  - destination register
  239.   data  - source register
  240.  Return Value     :  none
  241. ---------------------------------------------------------------------------------*/
  242. void  boot_outport(unsigned int port, unsigned int data)
  243. {
  244. asm {
  245. mov dx, port;
  246. mov ax, data;
  247. out dx, ax;
  248. }
  249. }
  250. /*---------------------------------------------------------------------------------
  251.  Purpose          :  Read from "port" register
  252.  Description :  Implimentation in assembler
  253.  Input Parameters :  port  - destination register
  254.  Return Value     :  return the read value
  255. ---------------------------------------------------------------------------------*/
  256. unsigned int boot_inport(unsigned int port)
  257. {
  258. asm {
  259. mov dx, port;
  260. in  ax, dx;
  261. }
  262. return (_AX);
  263. }
  265. BOOL b_disable_interrupt = FALSE;
  266. UINT16 disable_interrupt (void)
  267. {
  268. asm
  269. {
  270. pushf
  271. pop ax
  272. cli
  273. }
  274. b_disable_interrupt = TRUE;
  275. return (_AX);
  276. }
  277. void resume_interrupt ( UINT16 sr )
  278. {
  279. if( !b_disable_interrupt )
  280. return;
  281. b_disable_interrupt = FALSE;
  282. asm
  283. {
  284. push sr
  285. popf
  286. }
  287. }
  292. BOOL _receive_message(WORD *o_type, WORD *o_length, BYTE *o_data, BYTE *o_extend_data)
  293. {
  294. WORD buff_len;
  295. BYTE buff_startcode[START_CODE_LENGHT];
  296. DWORD buff_CRC;
  297. DWORD crc_data;
  298. BYTE index;
  299. crc32 = 0;
  300. //read start code
  301. if( !_uartRcvNBytes((BYTE*)&buff_startcode, START_CODE_LENGHT) )
  302. return FALSE;
  303. //_switch_word(&buff);
  304. if( !memcmp(buff_startcode, Start_Code,START_CODE_LENGHT) )
  305. {
  306. //read message type
  307. if( !_uartRcvNBytes((BYTE*)o_type, 2) )
  308. return FALSE;
  309. _switch_word(o_type);
  310. //read message length
  311. if( !_uartRcvNBytes((BYTE*)o_length, 2) )
  312. return FALSE;
  313. _switch_word(o_length);
  314. buff_len = *o_length;
  315. //read message data
  316. if( *o_type != MESSAGE_KEY_DOWNLOAD )
  317. {
  318. if( !_uartRcvNBytes(o_data, buff_len) )
  319. return FALSE;
  320. }
  321. else
  322. {
  323. if( !_uartRcvNBytes(o_data, 1) )
  324. return FALSE;
  325. for(index=0; index<Store_Keys_Num; index++)
  326. {
  327. if( Store_Keys_Map[index].Keys_type == *o_data)
  328. break;
  329. }
  330. if(index == Store_Keys_Num)
  331. return FALSE;
  332. if( buff_len>MAX_MESSAGE_DATA_LENGTH )
  333. {
  334. tr_printf(("Error: Message data length is too long.n"));
  335. return FALSE;
  336. }
  337. if( *o_data == KEY_TYPE_DVDA_CPRM_TYPE_A || *o_data == KEY_TYPE_DVDA_CPRM_TYPE_B || *o_data == KEY_TYPE_DVDA_CPRM_TYPE_C )
  338. {
  339. *(o_extend_data+Store_Keys_Map[index].Keys_offset+sizeof(DWORD)) = *o_data;
  340. if( !_uartRcvNBytes(o_extend_data+Store_Keys_Map[index].Keys_offset+sizeof(DWORD)+1, buff_len -1 ) )
  341. return FALSE;
  342. }
  343. else
  344. {
  345. if( !_uartRcvNBytes(o_extend_data+Store_Keys_Map[index].Keys_offset+sizeof(DWORD), buff_len -1 ) )
  346. return FALSE;
  347. }
  348. *((DWORD*)(o_extend_data+Store_Keys_Map[index].Keys_offset)) = STORE_KEYS_HEADER;
  349. }
  350. //read message crc
  351. crc_data = crc32;
  352. if( !_uartRcvNBytes((BYTE*)&buff_CRC, 4) )
  353. return FALSE;
  354. _switch_dword(&buff_CRC);
  355. if( buff_CRC == crc_data )
  356. return TRUE;
  357. else
  358. tr_printf(("CRC error! The correct CRC code is 0x%08lx, current CRC code is 0x%08lxn",crc_data,buff_CRC));
  359. }
  360. return FALSE;
  361. }
  362. BOOL _send_message(WORD i_type, WORD i_length, BYTE *i_data)
  363. {
  364. WORD length=i_length;
  365. DWORD crc_data;
  366. crc32=0;
  367. tr_printf(("SEND:    message: 0x%04x length: 0x%04x n",i_type,i_length));
  368. //if( _uartIsTxReady() )
  369. {
  370. //send start code
  372. _uartSndNBytes((BYTE*)&Start_Code, START_CODE_LENGHT);
  373. //if(1) //start code
  374. {
  375. _switch_word(&i_type);
  376. _uartSndNBytes((BYTE*)&i_type, 2);
  377. _switch_word(&i_length);
  378. _uartSndNBytes((BYTE*)&i_length, 2);
  379. _uartSndNBytes((BYTE*)i_data, length);
  380. crc_data = crc32;
  381. _switch_dword(&crc_data);
  382. _uartSndNBytes((BYTE*)&crc_data, 4);
  383. return TRUE;
  384. }
  385. }
  386. return FALSE;
  387. }
  389. void Check_Uart_Rx(UINT8 hTimer)
  390. {
  391. WORD message_type,message_length;
  392. int i;
  393. BYTE buff[4];
  394. DWORD CRC;
  395. UINT16 srValue;
  396. static BOOL b_received_release_msg=FALSE;
  397. BOOL first_message = TRUE;
  398. #ifndef STORE_KEYS_IN_FLASH
  399. DWORD header;
  400. #endif
  402. b_disable_interrupt = FALSE;
  404. if( _uartIsRxReady() && !b_received_release_msg )
  405. {
  406. if( !b_disable_interrupt )
  407. srValue = disable_interrupt();
  409. tr_printf(("Begin debuging mode!n"));
  411. _uartRcvNBytes(buff,1);
  413. while(1)
  414. {
  415. while (!_uartIsRxReady());
  416. //receive HDCP keys
  417. if( !_receive_message( &message_type, &message_length, buff, new_keys) )
  418. {
  419. tr_printf(("Error: The message hasn't beem received.n"));
  420. //resume_interrupt(srValue);
  421. //return;
  422. message_type = MESSAGE_ACKNOWLEDGE_ERROR;
  423. //continue;
  424. }
  425. else
  426. tr_printf(("RECEIVE: message: 0x%04x length: 0x%04x n",message_type,message_length));
  428. if( first_message && message_type != MESSAGE_PING )
  429. {
  430. while (1)
  431. {
  432. *buff =_uartRcvByte();
  433. if(timeout)
  434. {
  435. timeout = 0;
  436. break;
  437. }
  438. }
  439. resume_interrupt(srValue);
  440. return;
  441. }
  442. else
  443. first_message = FALSE;
  445. //check key available
  446. switch(message_type)
  447. {
  448. case MESSAGE_PING:
  449. //acknowledge
  451. message_type = MESSAGE_ACKNOWLEDGE_PING;
  452. message_length = Store_Keys_Num;
  453. for( i=0; i<message_length; i++)
  454. {
  455. buff[i] = Store_Keys_Map[i].Keys_type;
  456. #ifdef STORE_KEYS_IN_FLASH
  457. if( *((DWORD*)Store_Keys_Map[i].Keys_store_address) == STORE_KEYS_HEADER )
  458. #else
  459. if( eeprom_read((WORD)Store_Keys_Map[i].Keys_store_address,(BYTE*)&header, sizeof(DWORD) )
  460. && header == STORE_KEYS_HEADER )
  461. #endif
  462. buff[i] |= KEY_IS_DOWNLOADED;
  463. }
  464. _send_message(message_type, message_length, buff);
  465. break;
  467. case MESSAGE_RELEASE_DEVICE:
  468. //acknowledge
  469. message_type = MESSAGE_ACKNOWLEDGE_RELEASE_DEVICE;
  470. message_length = 0;
  471. b_received_release_msg= TRUE;
  472. _send_message(message_type, message_length, buff);
  473. resume_interrupt(srValue);
  474. return;
  476. case MESSAGE_KEY_DOWNLOAD:
  477. message_type = MESSAGE_ACKNOWLEDGE_KEY_DOWNLOAD;
  478. message_length = 1;
  479. //save other keys to the new_keys memory
  480. for(i=0; i<Store_Keys_Num; i++)
  481. {
  482. if( buff[0] != Store_Keys_Map[i].Keys_type)
  483. #ifdef STORE_KEYS_IN_FLASH
  484. memcpy(new_keys+Store_Keys_Map[i].Keys_offset, (BYTE*)Store_Keys_Map[i].Keys_store_address, Store_Keys_Map[i].Keys_length);
  485. #else
  486. eeprom_read((WORD)Store_Keys_Map[i].Keys_store_address, new_keys+Store_Keys_Map[i].Keys_offset, Store_Keys_Map[i].Keys_length);
  487. #endif
  488. }
  490. for(i=0;i<STORE_KEYS_END_OFFSET;i++)
  491. {
  492. if( i%16 == 0 )
  493. tr_printf(("n"));
  494. tr_printf(("%02x ",new_keys[i]));
  495. }
  496. tr_printf(("n"));
  499. if( Store_Keys_Save(new_keys) )
  500. buff[0] = 0x00;
  501. else
  502. buff[0] = 0x01;
  503. _send_message(message_type, message_length, buff);
  504. break;
  506. /* case MESSAGE_KEY_UPLOAD:
  507. message_type = MESSAGE_ACKNOWLEDGE_KEY_UPLOAD;
  508. for(i=0; i<Store_Keys_Num; i++)
  509. {
  510. if( buff[0] == Store_Keys_Map[i].Keys_type)
  511. break;
  512. }
  513. if( i == Store_Keys_Num )
  514. {
  515. buff[0] = 0x01;//fail: this key isn't exist
  516. }
  518. message_length = Store_Keys_Map[i].Keys_length - sizeof(DWORD) +1;
  519. *new_keys = Store_Keys_Map[i].Keys_type;
  520. memcpy(new_keys+1, (BYTE*)Store_Keys_Map[i].Keys_store_address, message_length-1);
  521. _send_message(message_type, message_length, new_keys);
  522. break;
  523. */
  524. case MESSAGE_KEY_DELETE:
  525. message_type = MESSAGE_ACKNOWLEDGE_KEY_DELETE;
  526. message_length = 1;
  527. for(i=0; i<Store_Keys_Num; i++)
  528. {
  529. if( buff[0] == Store_Keys_Map[i].Keys_type)
  530. break;
  531. }
  532. if( i == Store_Keys_Num )
  533. {
  534. tr_printf(("Error: This key isn't support.n"));
  535. buff[0] = 0x01;
  536. }
  537. #ifdef STORE_KEYS_IN_FLASH
  538. else if( *((DWORD*)Store_Keys_Map[i].Keys_store_address) != STORE_KEYS_HEADER )
  539. #else
  540. else if( eeprom_read((WORD)Store_Keys_Map[i].Keys_store_address,(BYTE*)&header, sizeof(DWORD) )
  541. && header != STORE_KEYS_HEADER )
  542. #endif
  543. {
  544. tr_printf(("Error: This key isn't exist.n"));
  545. buff[0] = 0x01;
  546. }
  547. else
  548. {
  549. for(i=0; i<Store_Keys_Num; i++)
  550. {
  551. if( buff[0] != Store_Keys_Map[i].Keys_type)
  552. #ifdef STORE_KEYS_IN_FLASH
  553. memcpy(new_keys+Store_Keys_Map[i].Keys_offset, (BYTE*)Store_Keys_Map[i].Keys_store_address, Store_Keys_Map[i].Keys_length);
  554. #else
  555. eeprom_read(Store_Keys_Map[i].Keys_store_address, new_keys+Store_Keys_Map[i].Keys_offset, Store_Keys_Map[i].Keys_length);
  556. #endif
  557. else
  558. memset(new_keys+Store_Keys_Map[i].Keys_offset,0,Store_Keys_Map[i].Keys_length);
  559. }
  561. if( Store_Keys_Save(new_keys) )
  562. buff[0] = 0x00;
  563. else
  564. buff[0] = 0x01;
  565. }
  566. _send_message(message_type, message_length, buff);
  567. break;
  569. case MESSAGE_ACKNOWLEDGE_ERROR:
  570. while (1)
  571. {
  572. *buff =_uartRcvByte();
  573. if(timeout)
  574. {
  575. timeout = 0;
  576. break;
  577. }
  578. }
  580. message_type = MESSAGE_ACKNOWLEDGE_ERROR;
  581. message_length = 0;
  582. _send_message(message_type, message_length, buff);
  583. resume_interrupt(srValue);
  584. return;
  585. default:
  586. tr_printf(("Error: Message type is unknown.n"));
  587. message_type = MESSAGE_ACKNOWLEDGE_ERROR;
  588. message_length = 0;
  589. _send_message(message_type, message_length, buff);
  590. resume_interrupt(srValue);
  591. break;
  592. }
  595. }
  596. }
  597. return;
  598. }
  600. #endif //SUPPORT_KEYS_UPDATE