text.c

本程序为ST公司开发的源代码

/*******************************************************************************
 *                    CONFIDENTIAL - PHILIPS APM
 *
 *  This is unpublished work is a trade secret. Philips APM owns all rights
 *  to this work and intends to maintain it in confidence to preserve its
 *  trade secret status. Philips Automotive Playback Modules reserves the
 *  right to protect this work as an unpublished copyrighted work in the
 *  event of an inadvertent Automotive Systems also reserves its right.
 *  Those having access to this work mayor deliberate unauthorized publication.
 *  Do not copy it, use it, or disclose the information contained in it
 *  without the written authorization of Philips Automotive Playback Modules.
 ******************************************************************************/
/******************************************************************************/
/*! \file
 *
 *  Project Scope: CDM M8
 *
 *  Organization:  Philips APM-DS
 *
 *  Version Control:
 *    \source       sources/player/text.c
 *    \version      0.2
 *    \author       Wolfgang Werner
 *    \date         31.03.2004
 *
 *  Target Hardware:    Accordo
 *******************************************************************************
 *  \brief        CD-Text management
 *
 *  \par          Change History:
 *
 * - BB040609d    Fixed clearing of CD text memory
 * - WW040701     Split clearing of CD text memory in several steps
 * - WW040705a    Fix reporting wrong performer
 * - WW040705b    tab (0x09) behaviour robustness increased
 * - WW040706a    Reduce used RAM
 * - WW040707a    Implement CD-Text debug mode
 * - WW040722     tab (0x09) support for DBCC
 * - YNM040804    Fixed CNF_CDTEXT_ON definition for S-ONE
 * - PH040805a    Changes reg. service mode (access to cd_text_buffer is not allowed)
 * - WW040818a    Implement S-One reading
 * - WW040827     Fix bug in S-One Performer storing
 * - BB040923c    Added jumper configuration handling
 * - BB040923j    CD-text rework and optimizations:
 *                - Fixed DBCC handling
 *                - Supported running from ISR
 *                - Clear only first bytes of stored packs in buffers
 *                - Generalized algorithm and interface to support other packs IDs
 * - WW050114a    Implement special debugmode for moduletest
 *                to enable define READ_ALL_PACKS_FROM_BLOCK_0
 *
 ****************************************************
 *
 * STM CVS Log:
 *
 * $Log: text.c,v $
 * Revision 1.16  2007/02/22 16:52:50  marcucci
 * Added some modification to allow I2S Word Clock and Bit Clock Level Programmable
 * Through CIS command
 *
 * Revision 1.15  2006/11/25 08:10:46  belardi
 * Ununsed function removal to free code space
 *
 * Revision 1.14  2006/10/31 11:11:47  marcucci
 * No more static functions for Jump Table
 *
 * Revision 1.13  2006/09/18 09:55:21  belardi
 * Corrected CVS keyword usage
 *
 * Revision 1.12  2006/09/18 09:22:36  belardi
 * Added Log CVS keyword into file header
 *
 * Revision 1.11  2006/09/15 20:17:25  belardi
 * Added Log CVS keyword into file header
 *
 *
 ******************************************************************************/

#include "gendef.h"
//#include "regmap.h"
#include "hwreg.h" // [RB] for Accordo+
#include "osal.h" // [RB] for Accordo+
#include "srvinc.h"
#include "text.h"  // [RB] for Accordo+

#ifdef APM_PICKUP
#include "mconfig.h"
#include "service.h"
#endif

#if (1==HAVE_CDTEXT)

#if (1 == HAVE_SHOCK_MEMORY)
uint8 *cd_text_buffer;       //[MM]
uint8 *cd_text_sdram_buffer; //[MM]
#else
uint8 cd_text_buffer[CD_TEXT_BUFFERSIZE]; // [RB] for Accordo+
#endif

#define DISABLE_CDTEXT_INTERRUPT()    do{CD_TEXT_CONTROL.field.en_cd_txt_rcv = 0;}while(0)

#define RUN_FROM_ISR // [RB] This is the only configuration tested with Accordo+
//#define READ_ALL_PACKS_FROM_BLOCK_0
//#define CHECK_FOR_WRONG_ID3_IN_8F_PACKS

//----------------------------------------------------------------------------
// Global definitions
//----------------------------------------------------------------------------

#ifdef APM_PICKUP
#define CNF_CDTEXT_ON                (HAVE_CDTEXT && (MCONFIG_DISABLED != mconfig_cd_text_support()))
#define PREFERRED_LANGUAGE(x)        (mconfig_cd_text_priority_language(x))
#define MAX_PRIORITY_LANGUAGES       3
#else
#define CNF_CDTEXT_ON                1
#define PREFERRED_LANGUAGE(x)        ((x) == 1)
// [RB] find a better way once we have some configuration object
#define MAX_PRIORITY_LANGUAGES       3
#endif


#define PACKS_TO_CONVERT_IN_ONE_STEP  0 //BB 4
#define PACKS_TO_CLEAR_IN_ONE_STEP    0 //BB 43 // [RB] not used in Accordo+
#define MAX_WAIT_FOR_PACK             1024

#define CD_TEXT_SERVICE_BUFFERSIZE    ((CD_TEXT_BUFFERSIZE/SERVICE_PACK_LEN)-1)

#define cd_text_data                  (&cd_text_buffer[CD_TEXT_DATA_OFFSET])

// for cd_text_current_state array
#define STATE_ID_LANGUAGE_CODE        0
#define STATE_ID_CHARACTER_CODE       1
#define STATE_ID_BLOCK                2
#define STATE_ID_DBCC                 3

// for cd_text_8F_packs
#define TEXT_8F_CHARACTER_CODE  0
#define TEXT_8F_FIRST_TRACK     1
#define TEXT_8F_LAST_TRACK      2
#define TEXT_8F_COPYPROTECT     3
#define TEXT_8F_NUM_ID_80       4
#define TEXT_8F_NUM_ID_81       5
#define TEXT_8F_NUM_ID_82       6
#define TEXT_8F_NUM_ID_83       7
#define TEXT_8F_NUM_ID_84       8
#define TEXT_8F_NUM_ID_85       9
#define TEXT_8F_NUM_ID_86      10
#define TEXT_8F_NUM_ID_87      11
#define TEXT_8F_NUM_ID_88      12
#define TEXT_8F_NUM_ID_89      13
#define TEXT_8F_NUM_ID_8A      14
#define TEXT_8F_NUM_ID_8B      15
#define TEXT_8F_NUM_ID_8C      16
#define TEXT_8F_NUM_ID_8D      17
#define TEXT_8F_NUM_ID_8E      18
#define TEXT_8F_NUM_ID_8F      19
#define TEXT_8F_LAST_SEQ_BL0   20
#define TEXT_8F_LAST_SEQ_BL1   21
#define TEXT_8F_LAST_SEQ_BL2   22
#define TEXT_8F_LAST_SEQ_BL3   23
#define TEXT_8F_LAST_SEQ_BL4   24
#define TEXT_8F_LAST_SEQ_BL5   25
#define TEXT_8F_LAST_SEQ_BL6   26
#define TEXT_8F_LAST_SEQ_BL7   27
#define TEXT_8F_LANG_CODE_BL0  28
#define TEXT_8F_LANG_CODE_BL1  29
#define TEXT_8F_LANG_CODE_BL2  30
#define TEXT_8F_LANG_CODE_BL3  31
#define TEXT_8F_LANG_CODE_BL4  32
#define TEXT_8F_LANG_CODE_BL5  33
#define TEXT_8F_LANG_CODE_BL6  34
#define TEXT_8F_LANG_CODE_BL7  35

enum {
  TEXT_STATE_INIT,
  TEXT_STATE_INIT_FINISHED,
  TEXT_STATE_START_CONVERTING,
  TEXT_STATE_CONVERTING,
  TEXT_STATE_STARTED,
  TEXT_STATE_READ_8F_BL0,
  TEXT_STATE_READ_8F_BLSELECTED,
  TEXT_STATE_READ_80_81,
  TEXT_STATE_READ_PACKS,
  TEXT_STATE_ERROR = 0xFE,
  TEXT_STATE_FINISH = 0xFF
};

//FIFO pos
#define ID1_TEXT_PACK_TYPE        0
#define ID2_TEXT_TRACK_NO         1
#define ID3_TEXT_SEQ_NO           2
#define ID4_TEXT_BLOCK_NO         3
#ifndef RUN_FROM_ISR
#define TEXT_FIST_DATA_BYTE       4
#endif
//----------------------------------------------------------------------------
//------------------------    local vars  ------------------------------------
//----------------------------------------------------------------------------

#ifdef RUN_FROM_ISR
static uint8 cd_text_fifo[4];
#else
static uint8 cd_text_fifo[16];
#endif
static uint8 cd_text_current_state[4]; // WW040706a
static uint16 cd_text_data_index;       // Write pointer

static uint8 cd_text_pac_num[PAC_ID_MAX_TO_READ + 1];

static uint8 cd_text_write_idx;   // write index for pack transfer mode
static uint8 cd_text_read_idx;    // read index for pack transfer mode

static uint8 cd_text_state;
static uint16 cd_text_wait_for_pack_counter;
static uint8 cd_text_next_seq_no;
static uint8 cd_text_max_seq_no;

static uint16 cd_text_write_pos;   // For converting to pascalstrings
static uint8 cnt_i;
static uint8 cnt_j;

static struct
{
#ifndef RUN_FROM_ISR
  UInt new_data : 1;
#endif
  UInt find_next_seq_no : 1;
  UInt start_requested : 1;
  UInt buffer_full : 1;
  UInt read_packs_finished : 1;
}cd_text_flags;

void text_read_fifo_data(void);
void move_text(void);

//----------------------------------------------------------------------------
//------------------------    Function implementations   ---------------------
//----------------------------------------------------------------------------

/*----------------------------------------------------------------------------*/
/* Function:  clear_cd_text_data                                              */
/*                                                                            */
/*!\author    Wolfgang Werner
 * \brief     Clear's the cd_text_buffer array in several steps
 * \pre       first call from CDText_init function
 * \post      None
 * \param     void
 * \return    void
 * \warning   None
 * \remarks   None
*/
/*----------------------------------------------------------------------------*/
void clear_cd_text_data(void) /* BB040609e */  /* WW040701 */
{
#if (0 != PACKS_TO_CLEAR_IN_ONE_STEP)
  for (cnt_i = 0; (cnt_i < PACKS_TO_CLEAR_IN_ONE_STEP); cnt_i++) //[RB] for Accordo+
#else
  while (1)
#endif
  {
    cd_text_data[cd_text_data_index] = 0;
    cd_text_data_index += STORED_PACK_LEN;
    if (cd_text_data_index >= (CD_TEXT_BUFFERSIZE - CD_TEXT_DATA_OFFSET))
    {
      cd_text_state = TEXT_STATE_INIT_FINISHED;
      return;
    }
  }
}

/*----------------------------------------------------------------------------*/
/* Function:  text_idle                                                       */
/*                                                                            */
/*!\author    Wolfgang Werner
 * \brief     If cd_text_state != TEXT_STATE_FINISH end the text reading and
 *            set cd_text_state to TEXT_STATE_ERROR
 * \pre       None
 * \post      None
 * \param     void
 * \return    void
 * \warning   None
 * \remarks   None
*/
/*----------------------------------------------------------------------------*/
void text_idle(void)
{
  if (TEXT_STATE_FINISH != cd_text_state)
  {
    DISABLE_CDTEXT_INTERRUPT();
    cd_text_state = TEXT_STATE_ERROR;
  }
}

/*----------------------------------------------------------------------------*/
/* Function:  text_start_reading                                              */
/*                                                                            */
/*!\author    Wolfgang Werner
 * \brief     called from servo if read first TOC
 * \pre       None
 * \post      None
 * \param     void
 * \return    void
 * \warning   None
 * \remarks   None
*/
/*----------------------------------------------------------------------------*/
void text_start_reading(void)
{
  if (CNF_CDTEXT_ON)
  {
    cd_text_flags.start_requested = 1;
  }
}

/*----------------------------------------------------------------------------*/
/* Function:  text_get_status                                                 */
/*                                                                            */
/*!\author    Wolfgang Werner
 * \brief     Returns BUSY during reading
 * \pre       None
 * \post      None
 * \param     void
 * \return    RETVAL
 * \warning   None
 * \remarks   None
*/
/*----------------------------------------------------------------------------*/
RETVAL text_get_status(void)
{
  if (CNF_CDTEXT_ON)
  {
    if (!((TEXT_STATE_INIT_FINISHED == cd_text_state)||
          (TEXT_STATE_STARTED       == cd_text_state)||
          (TEXT_STATE_ERROR         == cd_text_state)||
          (TEXT_STATE_FINISH        == cd_text_state)))
    {
      return BUSY;
    }
  }
  return READY;
}

/*----------------------------------------------------------------------------*/
/* Function:  text_available                                                  */
/*                                                                            */
/*!\author    Wolfgang Werner
 * \brief     Return TRUE if all CD-Text read
 * \pre       None
 * \post      None
 * \param     void
 * \return    uint8
 * \warning   None
 * \remarks   None
*/
/*----------------------------------------------------------------------------*/
uint8 text_available(void)
{
  return (uint8)(TEXT_STATE_FINISH == cd_text_state);
}

#ifdef APM_PICKUP // [RB] unused in STM build

/*----------------------------------------------------------------------------*/
/* Function:  text_get_state                                                  */
/*                                                                            */
/*!\author    Wolfgang Werner
 * \brief     will be called from message handler and returns requested state value
 * \pre       None
 * \post      None
 * \param     uint8
 * \return    uint8
 * \warning   None
 * \remarks   None
*/
/*----------------------------------------------------------------------------*/
uint8 text_get_state(uint8 get_char_code)
{
  if (TEXT_STATE_FINISH == cd_text_state)
  {
    if (0 == get_char_code)
    {
      return cd_text_current_state[STATE_ID_LANGUAGE_CODE];
    }
    else
    {
      return cd_text_current_state[STATE_ID_CHARACTER_CODE];
    }
  }
  return 0;
}

/*----------------------------------------------------------------------------------*/
/* Function:  text_is_block_dbcc                                                    */
/*                                                                                  */
/*!\author    Bernard Bosnjak
 * \brief     returns requested dbcc bit value
 * \pre       None
 * \post      None
 * \param     void
 * \return    uint8
 * \warning   None
 * \remarks   None
*/
/*----------------------------------------------------------------------------------*/
uint8 text_is_block_dbcc(void)
{
  if (TEXT_STATE_FINISH == cd_text_state)
  {
    return cd_text_current_state[STATE_ID_DBCC];
  }
  return 0;
}

void text_read_buffer(uint16 index, uint8 *data_ptr)
{
  *data_ptr = cd_text_buffer[index];