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

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

DVD

开发平台：

Others

NVM_BMK.c：源码内容
  1. /* **************************************************************************************
  2.  *  Copyright (c) 2001 ZORAN Corporation, All Rights Reserved
  3.  *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
  4.  *
  5.  *  File: "NVM_BMK.c"                                            05/27/03
  6.  *
  7.  * Description:
  8.  * ============
  9.  * NVM Bookmark 
  10.  * 
  11.  * Log:
  12.  * ====
  13.  * $Revision: 7 $
  14.  * Last Modified by $Author: Johnk $ at $Modtime: 4/01/04 9:55p $ 
  15.  ****************************************************************************************
  16.  * Updates:
  17.  ****************************************************************************************
  18.  * $Log: /I76/I76_Common/I76_Reference/Playcore/Coremain/NVM_BMK.c $
  19.  * 
  20.  * 7     4/01/04 10:57p Johnk
  21.  * support HW POWER_ON_RESUME
  22.  * 
  23.  * 6     03-06-17 14:59 Fwang
  24.  * Add API -- NVM_BMK_Flush(). Optimize API parameters.
  25.  * 
  26.  * 5     03-06-02 18:24 Fwang
  27.  * Add API function for get available setting slot.
  28.  * Optimize verifier.
  29.  * 
  30.  * 4     03-05-28 11:18 Fwang
  31.  * Add NVM_BMK_Get() to get bookmark
  32.  * Support specified postion in NVM_BMK_SET()
  33.  * 
  34.  * 3     03-05-28 9:40 Fwang
  35.  * Set bookmark type in NVM_BMK_SET()
  36.  * 
  37.  * 2     03-05-28 9:08 Fwang
  38.  * 
  39.  * 1     03-05-27 22:47 Fwang
  40.  * Creat
  41. ****************************************************************************************/
  43. #include "Config.h" // Global Configuration - do not remove!
  45. #ifndef EXINO2 //ZKR JK0331 : for power_on_resume in EEPROM
  46. #include "PlaycoreCoremainnvm_bmk.h"
  47. #ifdef HW_POWER_ON_RESUME
  49. #ifdef _DEBUG
  50. #undef IFTRACE
  51. #define IFTRACE if (gTraceCore) 
  52. #include "DebugDbgMain.h"
  53. #endif
  54. #include "PlaycorePSps.h"
  55. #include "PlaycoreScPadscmgr.h"
  56. #include "PlaycoreCoremaincoremain.h"
  57. #include "CPUCPU_API.h"
  58. #ifndef STORE_PS_DATA_IN_FLASH
  59. #include "eeprom.h"
  60. #endif
  63. #ifdef STORE_PS_DATA_IN_FLASH
  64. #define MK_FP(seg,ofs) ((void __seg *)(seg) + (void __near *)(ofs))
  66. static const BYTE huge *NVM_flash_base =  MK_FP(PS_SEG, 0);
  67. #define BMK_FLASH_BASE_ADDR  (NVM_flash_base + ((sizeof(NV_STORAGE) + 1)&0xfffe))
  68. #else
  69. #define BMK_EEPROM_BASE_ADDR (PS_OFFSET_ADDR+ ((sizeof(NV_STORAGE) + 1)&0xfffe))
  70. #endif
  72. #define BMK_SLOT_SIZE ((sizeof(NVM_GENERIC_BMK)+1)&0xfffe)
  74. #ifdef STORE_PS_DATA_IN_FLASH
  75. #define BMK_FLASH_SLOT_ADDR(slot)  (BMK_FLASH_BASE_ADDR + slot*BMK_SLOT_SIZE)
  76. #else
  77. #define BMK_EEPROM_SLOT_ADDR(slot)  (BMK_EEPROM_BASE_ADDR + slot*BMK_SLOT_SIZE)
  78. #endif
  80. static WORD sc_handle =  NULL_HANDLE;
  81. static const WORD sc_buffer_size = NUM_OF_NVM_BMK * CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK));
  83. static BOOL (*p_IsMatch)(NVM_GENERIC_BMK*) = NULL;
  84. static void (*p_SetDiscMarker)(WORD handle) = NULL;
  85. static void (*p_BmkPlay)(NVM_GENERIC_BMK*) = NULL;
  86. static BMK_TYPE Current_BMK_Type = BMK_NONE;
  88. static BYTE __CalculateCheckSum(BYTE* buff, int size);
  89. static BYTE __CalculateCheckSum_sc(WORD sc, int size);
  91. #ifdef STORE_PS_DATA_IN_FLASH
  92. #ifdef _DEBUG
  93. static void __trace_sc(int slot)
  94. {
  95. int i;
  96. NVM_GENERIC_BMK bmk;
  97. BYTE *buffer = (BYTE*)&bmk;
  99. sc_GetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), 0, sizeof(NVM_GENERIC_BMK), (BYTE*)&bmk);
  100. dbg_printf(("nSC Slot %d", slot));
  102. for (i=0; i<sizeof(NVM_GENERIC_BMK);)
  103. {
  104. dbg_printf(("n%3d: ", i));
  105. dbg_printf((" 0x%2x", buffer[i])); i++;
  106. dbg_printf((" 0x%2x", buffer[i])); i++;
  107. dbg_printf((" 0x%2x", buffer[i])); i++;
  108. dbg_printf((" 0x%2x", buffer[i])); i++;
  110. dbg_printf(("   0x%2x", buffer[i])); i++;
  111. dbg_printf((" 0x%2x", buffer[i])); i++;
  112. dbg_printf((" 0x%2x", buffer[i])); i++;
  113. dbg_printf((" 0x%2x", buffer[i])); i++;
  114. }
  115. }
  117. static void __trace_flash(int slot)
  118. {
  119. int i;
  120. BYTE* buffer = (BYTE*)BMK_FLASH_SLOT_ADDR(slot);
  121. dbg_printf(("nFlash Slot %d", slot));
  123. for (i=0; i<sizeof(NVM_GENERIC_BMK);)
  124. {
  125. dbg_printf(("n%3d   (%p): ", i, &buffer[i]));
  126. dbg_printf((" 0x%2x", buffer[i])); i++;
  127. dbg_printf((" 0x%2x", buffer[i])); i++;
  128. dbg_printf((" 0x%2x", buffer[i])); i++;
  129. dbg_printf((" 0x%2x", buffer[i])); i++;
  131. dbg_printf(("   0x%2x", buffer[i])); i++;
  132. dbg_printf((" 0x%2x", buffer[i])); i++;
  133. dbg_printf((" 0x%2x", buffer[i])); i++;
  134. dbg_printf((" 0x%2x", buffer[i])); i++;
  135. }
  136. }
  138. void NVM_BMK_DebugOut()
  139. {
  140. int i;
  142. for (i=0; i < NUM_OF_NVM_BMK; i++)
  143. {
  144. __trace_flash(i);
  145. }
  146. }
  148. #endif //_DEBUG
  149. #endif
  151. /**********************************************************************************
  152.  * Purpose          : Cache NVM bookmark
  153.  * Input Parameters :  None
  154.  * Return Value     :  BOOL
  155.  * Description :  Allocate cache from Scpad and preload bookmark from NVM
  156.  **********************************************************************************/
  157. BOOL NVM_BMK_Cache()
  158. {
  159. int i;
  160. #ifndef STORE_PS_DATA_IN_FLASH
  161. BYTE nvmdata[sizeof(NVM_GENERIC_BMK)]; 
  162. #endif
  164. //Allocate buffer from Scpad
  165. sc_handle = sc_Malloc(sc_buffer_size);
  166. if (NULL_HANDLE == sc_handle)
  167. return FALSE;
  169. //Cache NVM bookmark
  170. for( i = 0; i < NUM_OF_NVM_BMK ; i++ ){
  171. #ifdef STORE_PS_DATA_IN_FLASH
  172. sc_SetBytes( sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), 0, sizeof(NVM_GENERIC_BMK), (BYTE *)BMK_FLASH_SLOT_ADDR(i));
  173. #else
  174. eeprom_read( BMK_EEPROM_SLOT_ADDR(i),nvmdata, sizeof(NVM_GENERIC_BMK) );
  175. sc_SetBytes( sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), 0, sizeof(NVM_GENERIC_BMK), nvmdata);
  176. #endif
  177. }
  179. return TRUE;
  180. }
  182. /**********************************************************************************
  183.  * Purpose          : Uncache NVM bookmark
  184.  * Input Parameters :  None
  185.  * Return Value     :  None
  186.  * Description :  Free Scpad cache
  187.  **********************************************************************************/
  188. void NVM_BMK_UnCache()
  189. {
  190. if (NULL_HANDLE != sc_handle)
  191. {
  192. //Free Scpad cache
  193. sc_Free( sc_handle, sc_buffer_size );
  194. sc_handle = NULL_HANDLE;
  195. }
  196. }
  198. /**********************************************************************************
  199.  * Purpose          : Check if NVM bookmark is cached
  200.  * Input Parameters :  None
  201.  * Return Value     :  True if bookmark is cached in Scpad
  202.  * Description :  
  203.  **********************************************************************************/
  204. BOOL NVM_BMK_IsCached()
  205. {
  206. return (sc_handle != NULL_HANDLE);
  207. }
  210. /**********************************************************************************
  211.  * Purpose          : If bookmark of curren disc exits
  212.  * Input Parameters :  h_BmkSlot - slot position if hit
  213.  * Return Value     :  True if exists
  214.  * Description :  Comapre fingure print of disc with bookmark.
  215.  **********************************************************************************/
  216. BOOL NVM_BMK_hit(int *h_BmkSlot)
  217. {
  218. int i;
  219. #ifndef STORE_PS_DATA_IN_FLASH
  220. BMK_STORAGE bmk_storage;
  221. NVM_GENERIC_BMK *pGenric_bmk = &bmk_storage.bmk;
  222. #else
  223. NVM_GENERIC_BMK *pGenric_bmk;
  224. #endif
  226. if (NULL == p_IsMatch)
  227. return FALSE;
  229. for (i=0; i < NUM_OF_NVM_BMK; i++)
  230. {
  231. #ifdef STORE_PS_DATA_IN_FLASH
  232. pGenric_bmk = (NVM_GENERIC_BMK*)BMK_FLASH_SLOT_ADDR(i);
  233. #else
  234. eeprom_read( BMK_EEPROM_SLOT_ADDR(i),&(bmk_storage.data[0]), sizeof(NVM_GENERIC_BMK) );
  235. #endif
  236. if ( pGenric_bmk->bmk_type == Current_BMK_Type)
  237. {
  238. //Match with disc info
  239. if (p_IsMatch(pGenric_bmk))
  240. {
  241. if (h_BmkSlot != NULL)
  242. *h_BmkSlot = i;
  243. return TRUE;
  244. }
  245. }
  246. }
  247. return FALSE;
  248. }
  250. /**********************************************************************************
  251.  * Purpose          : To find a available slot
  252.  * Input Parameters :  h_BmkSlot - slot position
  253.  * Return Value     :  None
  254.  * Description :  If no blank slot exists, replace the oldest one.
  255.  **********************************************************************************/
  256. void NVM_BMK_Get_FreeSlot(int *h_BmkSlot)
  257. {
  258. int i, slot_id;
  259. #ifndef STORE_PS_DATA_IN_FLASH
  260. BMK_STORAGE bmk_storage;
  261. NVM_GENERIC_BMK *pGenric_bmk = &bmk_storage.bmk;
  262. #else
  263. NVM_GENERIC_BMK *pGenric_bmk;
  264. #endif
  265. BYTE oldest_age = 0;
  267. //Try to get a blank slot, otherwise return the oldest one.
  268. for (i=0; i < NUM_OF_NVM_BMK; i++)
  269. {
  270. #ifdef STORE_PS_DATA_IN_FLASH
  271. pGenric_bmk = (NVM_GENERIC_BMK*)BMK_FLASH_SLOT_ADDR(i);
  272. #else
  273. eeprom_read( BMK_EEPROM_SLOT_ADDR(i),&(bmk_storage.data[0]), sizeof(NVM_GENERIC_BMK) );
  274. #endif
  275. if ( pGenric_bmk->bmk_type == BMK_NONE)
  276. {
  277. //Found empty slot
  278. slot_id = i;
  279. break;
  280. }
  281. if (oldest_age <= pGenric_bmk->age)
  282. {
  283. oldest_age = pGenric_bmk->age;
  284. slot_id = i;
  285. }
  286. }
  288. *h_BmkSlot = slot_id;
  289. return;
  290. }
  292. /**********************************************************************************
  293.  * Purpose          : Save NVM bookmark
  294.  * Input Parameters :  bUpdateFlash - if NVM position exists in flash
  295.  * Return Value     :  None
  296.  * Description :  Write cached bookmark back to NVM
  297.  **********************************************************************************/
  298. #ifdef STORE_PS_DATA_IN_FLASH
  299. void NVM_BMK_Save(BOOL bUpdateFlash)
  300. #else
  301. void NVM_BMK_Save(void)
  302. #endif
  303. {
  304. int slot;
  305. #ifdef STORE_PS_DATA_IN_FLASH
  306. int offset;
  307. BYTE buff[2];
  308. unsigned short far *fp_uDestAddr;
  309. #else
  310. BYTE nvmdata[sizeof(NVM_GENERIC_BMK)];
  311. #endif
  313. if (NULL_HANDLE == sc_handle)
  314. return;
  316. #ifdef STORE_PS_DATA_IN_FLASH
  317. if ( bUpdateFlash ){
  318. //Update flash
  319. for (slot = 0; slot < NUM_OF_NVM_BMK; slot++)
  320. {
  321. for( offset = 0; offset < BMK_SLOT_SIZE; offset=offset+2 ){
  322. sc_GetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, 2, buff);
  323. fp_uDestAddr = BMK_FLASH_SLOT_ADDR(slot) + offset;
  324. Nor_Write((unsigned short huge *)fp_uDestAddr, (unsigned char far *)buff, 2);
  325. }
  326. }
  327. }else{
  328. //Update SRAM
  329. for (slot = 0; slot < NUM_OF_NVM_BMK; slot++)
  330. {
  331. sc_GetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), 0, BMK_SLOT_SIZE, (BYTE*)BMK_FLASH_SLOT_ADDR(slot));
  332. }
  333. }
  334. #else
  335. for (slot = 0; slot < NUM_OF_NVM_BMK; slot++)
  336. {
  337. sc_GetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), 0, BMK_SLOT_SIZE, nvmdata);
  338. eeprom_write( BMK_EEPROM_SLOT_ADDR(slot),nvmdata, sizeof(NVM_GENERIC_BMK) );
  339. }
  340. #endif
  341. }
  343. /**********************************************************************************
  344.  * Purpose          : Flush specified NVM bookmark
  345.  * Input Parameters :  position - specified slot. -1 means auto position 
  346.  * Return Value     :  None
  347.  * Description : 
  348.  **********************************************************************************/
  349. void NVM_BMK_Flush( int position )
  350. {
  351. BYTE ucTemp;
  352. int offset, slot;
  353. const BYTE buff[4] = {0,0,0,0};
  354. NVM_GENERIC_BMK *pGenric_bmk;
  356. if ((position>=0) && (position<NUM_OF_NVM_BMK))
  357. {
  358. //Specified position
  359. slot = position;
  360. }else
  361. {
  362. //Find matched slot
  363. if ( FALSE == NVM_BMK_hit(&slot) )
  364. return;
  365. }
  367. if ( FALSE == NVM_BMK_Cache() )
  368. return;
  370. //Flush specified Scpad cache
  371. for (offset=0; offset<CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK));offset++)
  372. sc_SetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset*BYTE_PER_CONTAINER, BYTE_PER_CONTAINER, buff);
  374. ucTemp = __CalculateCheckSum_sc(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), sizeof(NVM_GENERIC_BMK)-1);
  375. offset = (int)&pGenric_bmk->checksum - (int)pGenric_bmk;
  376. sc_SetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, 1, &ucTemp);
  378. //Write back to NVM
  379. #ifdef STORE_PS_DATA_IN_FLASH
  380. core_save_NVM_setting_In_Flash((unsigned short far *)NVM_flash_base);
  381. #else
  382. NVM_BMK_Save();
  383. #endif
  385. NVM_BMK_UnCache();
  386. return;
  387. }
  390. /**********************************************************************************
  391.  * Purpose          : Flush all NVM bookmark
  392.  * Input Parameters :  None
  393.  * Return Value     :  None
  394.  * Description : 
  395.  **********************************************************************************/
  396. void NVM_BMK_FlushAll()
  397. {
  398. BYTE ucTemp;
  399. int i, offset;
  400. const BYTE buff[4] = {0,0,0,0};
  401. NVM_GENERIC_BMK *pGenric_bmk;
  403. if ( FALSE == NVM_BMK_Cache() )
  404. return;
  406. //Flush all Scpad cache
  407. for (i=0; i < NUM_OF_NVM_BMK; i++)
  408. {
  409. for (offset=0; offset<CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK));offset++)
  410. sc_SetBytes(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset*BYTE_PER_CONTAINER, BYTE_PER_CONTAINER, buff);
  412. ucTemp = __CalculateCheckSum_sc(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), sizeof(NVM_GENERIC_BMK)-1);
  413. offset = (int)&pGenric_bmk->checksum - (int)pGenric_bmk;
  414. sc_SetBytes(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, 1, &ucTemp);
  415. }
  417. //Write back to NVM
  418. #ifdef STORE_PS_DATA_IN_FLASH
  419. core_save_NVM_setting_In_Flash((unsigned short far *)NVM_flash_base);
  420. #else
  421. NVM_BMK_Save();
  422. #endif
  424. NVM_BMK_UnCache();
  425. return;
  426. }
  428. /**********************************************************************************
  429.  * Purpose          : Verify the consistence of NVM bookmark
  430.  * Input Parameters :  None
  431.  * Return Value     :  None
  432.  * Description :  Flush NVM bookmark if contains error
  433.  **********************************************************************************/
  434. void NVM_BMK_Verify()
  435. {
  436. int i, offset;
  437. BOOL bError = FALSE;
  438. #ifndef STORE_PS_DATA_IN_FLASH
  439. BMK_STORAGE bmk_storage;
  440. NVM_GENERIC_BMK *pGenric_bmk = &bmk_storage.bmk;
  441. #else
  442. NVM_GENERIC_BMK *pGenric_bmk;
  443. #endif
  444. const BYTE buff[4] = {0,0,0,0};
  445. BYTE temp;
  447. for (i=0; i<NUM_OF_NVM_BMK; i++)
  448. {
  449. #ifdef STORE_PS_DATA_IN_FLASH
  450. pGenric_bmk = (NVM_GENERIC_BMK*)BMK_FLASH_SLOT_ADDR(i);
  451. #else
  452. eeprom_read( BMK_EEPROM_SLOT_ADDR(i),&(bmk_storage.data[0]), sizeof(NVM_GENERIC_BMK) );
  453. #endif
  454. if ( pGenric_bmk->checksum !=  __CalculateCheckSum((BYTE*)pGenric_bmk, sizeof(NVM_GENERIC_BMK)-1) )
  455. {
  456. bError = TRUE;
  457. break;
  458. }
  459. }
  461. if (!bError)
  462. return;
  464. dbg_printf(("nNVM Bookmark check sume error! "));
  466. if ( FALSE == NVM_BMK_Cache() )
  467. return;
  469. for (i=0; i<NUM_OF_NVM_BMK; i++)
  470. {
  471. #ifdef STORE_PS_DATA_IN_FLASH
  472. pGenric_bmk = (NVM_GENERIC_BMK*)BMK_FLASH_SLOT_ADDR(i);
  473. #else
  474. eeprom_read( BMK_EEPROM_SLOT_ADDR(i),&(bmk_storage.data[0]), sizeof(NVM_GENERIC_BMK) );
  475. #endif
  476. if ( pGenric_bmk->checksum !=  __CalculateCheckSum((BYTE*)pGenric_bmk, sizeof(NVM_GENERIC_BMK)-1) )
  477. {
  478. //Flush cache
  479. for (offset=0; offset<CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK));offset++)
  480. sc_SetBytes(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset*BYTE_PER_CONTAINER, BYTE_PER_CONTAINER, buff);
  481. temp = __CalculateCheckSum_sc(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), sizeof(NVM_GENERIC_BMK)-1);
  482. offset = (int)&pGenric_bmk->checksum - (int)pGenric_bmk;
  483. sc_SetBytes(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, 1, &temp);
  484. #ifdef STORE_PS_DATA_IN_FLASH
  485. #ifdef _DEBUG
  486. dbg_printf(("nERR In "));
  487. __trace_flash(i);
  488. #endif
  489. #endif
  490. }
  491. }
  493. #ifdef STORE_PS_DATA_IN_FLASH
  494. core_save_NVM_setting_In_Flash((unsigned short far *)NVM_flash_base);
  495. #else
  496. NVM_BMK_Save();
  497. #endif
  499. NVM_BMK_UnCache();
  500. }
  502. /**********************************************************************************
  503.  * Purpose          : Hook callback navigator functiones
  504.  * Input Parameters :  bmk_type - bmk type according to Navigator
  505.  *      match_func - function to check disc figure print
  506.  *                              set_func - function to set disc bookmark info
  507.  *                              play_func - function to retore disc bookmark info
  508.  * Return Value     :  None
  509.  * Description : 
  510.  **********************************************************************************/
  511. void NVM_BMK_Hook(BMK_TYPE bmk_type, BOOL(*match_func)(NVM_GENERIC_BMK*), void(*set_func)(WORD), void(*play_func)(NVM_GENERIC_BMK*))
  512. {
  513. p_IsMatch = match_func;
  514. p_SetDiscMarker = set_func;
  515. p_BmkPlay = play_func;
  516. Current_BMK_Type = bmk_type;
  517. return;
  518. }
  520. /**********************************************************************************
  521.  * Purpose          : Unhook callback navigator functiones
  522.  * Input Parameters :  None
  523.  * Return Value     :  None
  524.  * Description : 
  525.  **********************************************************************************/
  526. void NVM_BMK_UnHook()
  527. {
  528. p_IsMatch = NULL;
  529. p_SetDiscMarker = NULL;
  530. p_BmkPlay = NULL;
  531. Current_BMK_Type = BMK_NONE;
  532. return;
  533. }
  535. /**********************************************************************************
  536.  * Purpose          : Get available slot position
  537.  * Input Parameters :  None
  538.  * Return Value     :  available position
  539.  * Description :  Find available slot to set bookmark for the current disc
  540.  **********************************************************************************/
  541. int NVM_BMK_AvailableSlot()
  542. {
  543. int slot = 0;
  545. //Find available slot
  546. if (!NVM_BMK_hit(&slot))
  547. {
  548. NVM_BMK_Get_FreeSlot(&slot);
  549. }
  550. return slot;
  551. }
  553. /**********************************************************************************
  554.  * Purpose          : Set NVM bookmark
  555.  * Input Parameters :  position - specified position. -1 for auto posisition
  556.  * Return Value     :  None
  557.  * Description :  Save disc info to available NVM bookmark slot, and update age of each slot
  558.  **********************************************************************************/
  559. void NVM_BMK_SET(int position)
  560. {
  561. BYTE ucTemp;
  562. int i, slot, offset;
  563. #ifndef STORE_PS_DATA_IN_FLASH
  564. BMK_STORAGE bmk_storage;
  565. NVM_GENERIC_BMK *pGenric_bmk = &bmk_storage.bmk;
  566. #else
  567. NVM_GENERIC_BMK *pGenric_bmk;
  568. #endif
  570. if (NULL == p_SetDiscMarker)
  571. return;
  573. if ( FALSE == NVM_BMK_Cache() )
  574. return;
  576. if ((position>=0) && (position<NUM_OF_NVM_BMK))
  577. {
  578. //Specified position
  579. slot = position;
  580. }else
  581. {
  582. //Find available slot
  583. slot = NVM_BMK_AvailableSlot();
  584. }
  586. //Set disc info
  587. p_SetDiscMarker( sc_handle + slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)) );
  589. //Set bookmark type
  590. ucTemp = Current_BMK_Type;
  591. offset = (int)&pGenric_bmk->bmk_type - (int)pGenric_bmk;
  592. sc_SetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, sizeof(BYTE), (BYTE *) &ucTemp);
  594. //Set age as zero
  595. ucTemp = 0;
  596. offset = (int)&pGenric_bmk->age - (int)pGenric_bmk;
  597. sc_SetBytes(sc_handle+slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, sizeof(BYTE), &ucTemp);
  599. //Calculate check sum
  600. ucTemp = __CalculateCheckSum_sc(sc_handle + slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), sizeof(NVM_GENERIC_BMK)-1) ;
  601. offset =(int)& pGenric_bmk->checksum - (int)pGenric_bmk;
  602. sc_SetBytes(sc_handle + slot*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, sizeof(BMK_TYPE), (BYTE *) &ucTemp);
  604. //Update the age counting of each slot
  605. for (i=0; i < NUM_OF_NVM_BMK; i++)
  606. {
  607. #ifdef STORE_PS_DATA_IN_FLASH
  608. pGenric_bmk = (NVM_GENERIC_BMK*)BMK_FLASH_SLOT_ADDR(i);
  609. #else
  610. eeprom_read( BMK_EEPROM_SLOT_ADDR(i),&(bmk_storage.data[0]), sizeof(NVM_GENERIC_BMK) );
  611. #endif
  612. if (BMK_NONE == pGenric_bmk->bmk_type)          //Don't update blank slot
  613. continue;
  614. if (i == slot) //Don't update selected slot whose age is zero
  615. continue;
  617. if (pGenric_bmk->age < 0xFF)               //Maxium limitation
  618. {
  619. //Increment age
  620. ucTemp = pGenric_bmk->age + 1;
  621. offset = (int)&pGenric_bmk->age - (int)pGenric_bmk;
  622. sc_SetBytes(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, sizeof(BYTE), &ucTemp);
  624. ucTemp = __CalculateCheckSum_sc(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), sizeof(NVM_GENERIC_BMK)-1);
  625. offset = (int)&pGenric_bmk->checksum - (int)pGenric_bmk;
  626. sc_SetBytes(sc_handle+i*CONTAINER_COUNT(sizeof(NVM_GENERIC_BMK)), offset, 1, &ucTemp);
  627. }
  628. }
  630. //Write back to NVM
  631. #ifdef STORE_PS_DATA_IN_FLASH
  632. core_save_NVM_setting_In_Flash((unsigned short far *)NVM_flash_base);
  633. #else
  634. NVM_BMK_Save();
  635. #endif
  637. NVM_BMK_UnCache();
  638. return;
  639. }
  641. /**********************************************************************************
  642.  * Purpose          : Play from NVM bookmark
  643.  * Input Parameters :  None
  644.  * Return Value     :  Whether found matched bookmark or not
  645.  * Description :  If bookmark of current disc exists, play from the bookmark.
  646.  **********************************************************************************/
  647. BOOL NVM_BMK_Play()
  648. {
  649. int slot;
  650. #ifndef STORE_PS_DATA_IN_FLASH
  651. BMK_STORAGE bmk_storage;
  652. NVM_GENERIC_BMK *pGenric_bmk = &bmk_storage.bmk;
  653. #endif
  655. if (NULL == p_BmkPlay)
  656. return;
  658. #ifdef D_MEMORY_SETTING
  659. if (gps->memory_mode)
  660. {
  661. #endif
  662. if (NVM_BMK_hit(&slot))
  663. {
  664. //Bookmark play
  665. #ifdef STORE_PS_DATA_IN_FLASH
  666. p_BmkPlay( (NVM_GENERIC_BMK*)BMK_FLASH_SLOT_ADDR(slot) );
  667. #else
  668. eeprom_read( BMK_EEPROM_SLOT_ADDR(slot),&(bmk_storage.data[0]), sizeof(NVM_GENERIC_BMK) );
  669. p_BmkPlay(pGenric_bmk);
  670. #endif
  671. NVM_BMK_Flush(slot);
  672. return TRUE;
  673. }
  674. #ifdef D_MEMORY_SETTING
  675. }
  676. #endif
  677. return FALSE;
  678. }
  680. /**********************************************************************************
  681.  * Purpose          : Get bookmark info from NVM
  682.  * Input Parameters :  slot - postion
  683.  * Return Value     :  pointer to NVM bookmark. NULL if not exists
  684.  * Description : 
  685.  **********************************************************************************/
  686. #if 0
  687. NVM_GENERIC_BMK *NVM_BMK_Get(int slot)
  688. {
  689. NVM_GENERIC_BMK *pGenric_bmk;
  691. if ((slot>=0) && (slot<NUM_OF_NVM_BMK))
  692. {
  693. pGenric_bmk = BMK_FLASH_SLOT_ADDR(slot);
  694. if (pGenric_bmk->bmk_type != BMK_NONE)
  695. return pGenric_bmk;
  696. else
  697. return NULL;
  698. }
  699. else
  700. return NULL;
  701. }
  702. #endif
  704. /**********************************************************************************
  705.  * Purpose          : Calculate check sum of given buffer
  706.  **********************************************************************************/
  707. static BYTE __CalculateCheckSum(BYTE* buff, int size)
  708. {
  709. int i;
  710. BYTE checksum=0;
  712. for (i=0; i< size; i++) 
  713. {
  714. checksum += buff[i];
  715. }
  716. return checksum^0xFF;
  717. }
  719. /**********************************************************************************
  720.  * Purpose          : Calculate check sum of given Scpad buffer
  721.  **********************************************************************************/
  722. static BYTE __CalculateCheckSum_sc(WORD sc, int size)
  723. {
  724. int i;
  725. BYTE temp;
  726. BYTE checksum = 0;
  728. for (i=0; i< size; i++) 
  729. {
  730. sc_GetBytes(sc, i, 1, &temp);
  731. checksum += temp;
  732. }
  733. return checksum^0xFF;
  734. }
  736. #else
  738. void NVM_BMK_Verify()
  739. {
  740. }
  742. #pragma argsused
  743. void NVM_BMK_SET(int position)
  744. {
  745. }
  747. BOOL NVM_BMK_Play()
  748. {
  749. }
  751. #pragma argsused
  752. void NVM_BMK_Hook(BMK_TYPE bmk_type, BOOL(*match_func)(NVM_GENERIC_BMK*), void(*set_func)(WORD), void(*play_func)(NVM_GENERIC_BMK*))
  753. {
  754. }
  756. void NVM_BMK_UnHook()
  757. {
  758. }
  759. #endif //HW_POWER_ON_RESUME
  760. #endif //EXINO2