dbgprc.c

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

      {
        if (cksum_verify(RS232_RxBuffer[BYTE_COUNT], RS232_RxBuffer))
        {
          addr = RS232_RxBuffer[3];
          data = dsp_read_ymem(addr);
          RS232_TxBuffer[ERROR_CODE] = NO_ERROR;
          RS232_TxBuffer[2] = (uint8)((data & 0xFF00) >> BIT_8);
          RS232_TxBuffer[3] = (uint8)(data & 0x00FF);
        }
        else
        {
          RS232_TxBuffer[ERROR_CODE] = INV_CKSUM;
        }
        RS232_TxBuffer[BYTE_COUNT] = READ_DSP_YMEM_ACK_LEN;
        tx_msg(READ_DSP_YMEM_ACK_LEN, RS232_TxBuffer, PCIF);
      }
      else
      {
      /* Error Msg: Invalid Length */
      }
      break;


    case TEST_MSG_OP_CODE:
    /* Rx Message */
    /* RS232_RxBuffer[0] -> Byte Count  */
    /* RS232_RxBuffer[1] -> Op Code     */
    /* RS232_RxBuffer[2] -> Test No     */
    /* RS232_RxBuffer[3] -> Parm MSB    */
    /* RS232_RxBuffer[4] -> Parm LSB    */
    /* RS232_RxBuffer[5] -> Checksum    */

    /* Tx Message */
    /* RS232_TxBuffer[0] <- Byte Count      */
    /* RS232_TxBuffer[1] <- Error Code      */
    /* RS232_TxBuffer[2] <- Ret Parm MSB    */
    /* RS232_TxBuffer[3] <- Ret Parm LSB    */
    /* RS232_TxBuffer[4] <- Checksum        */

      if(RS232_RxBuffer[BYTE_COUNT] == TEST_MSG_LEN)
      {
        /* [RB] To avoid issues related with task switching, some case below */
        /* send the ack immediately. This flag is used to avoid sending ack twice */
        /* In more detail: servo commands put the pcdeb to sleep immediately, so the */
        /* pcdeb does not send an ACK to the PC until the servo is finished with its work */
        /* This normally works, but in some cases (i.e. putting breakpoints) the PC */
        /* times out and resends the message. To avoid this, for Servo commands we issue */
        /* the ack _before_ sending the servo comamnd */
        t_bool tx_ack_done = FALSE;

        /* The Message Has Correct length */
        if(cksum_verify(RS232_RxBuffer[BYTE_COUNT], RS232_RxBuffer))
        {
          /* [RB] prepare for ack transmission */
          RS232_TxBuffer[BYTE_COUNT] = TEST_MSG_ACK_LEN;

          RS232_TxBuffer[ERROR_CODE] = NO_ERROR;
          switch (RS232_RxBuffer[2])
          {
#if (DEBUG_DSP != 0)
          case MC_PDM_OUT1:
          case MC_PDM_OUT2:
            output_signal = RS232_RxBuffer[3];
#endif
          case MC_CLV_BUFFER:
          case MC_ESP_BUFFER:
          case MC_INIT_ALL:
          case MC_STOP_ALL:
          case MC_ACT_ON:
          case MC_ACT_OFF:
          case MC_LASER_ON:
          case MC_LASER_OFF:
          case MC_FE_ADJUST:
          case MC_TT_ON:
          case MC_TT_OFF:
          case MC_FOCUS_ON:
          case MC_FOCUS_OFF:
          case MC_FOCUS_RAMPING:
          case MC_TE_ADJUST:
          case MC_TRACK_ON:
          case MC_TRACK_OFF:
          case MC_AGC_FOCUS:
          case MC_AGC_TRACKING:
          case MC_RELOCK_PLL:
          case MC_CLV_1X:
          case MC_CLV_2X:
          case MC_SCP_CLV_1X:
          case MC_SCP_CLV_2X:
          case MC_AUDIO_ON:
          case MC_AUDIO_OFF:
          case MC_CLV_OFF:
          case MC_SHORT_JUMP_FWD:
          case MC_SHORT_JUMP_BWD:
          case MC_LONG_JUMP_FWD:
          case MC_LONG_JUMP_BWD:
          case MC_SLEDGE_HOME:
          case MC_SLEDGE_FWD:
          case MC_SLEDGE_BACK:
          case MC_RAM_PROFILE:
          case MC_ROM_PROFILE:
            if (micro_command_result != IN_PROGRESS)
            {
              current_micro_command = RS232_RxBuffer[2];
              sm_state_1 = STATE_1;
              sm_state_2 = STATE_1;
              prev_sm_state_1 = STATE_1;
            }
            else
            {
              RS232_TxBuffer[ERROR_CODE] = MICRO_COMMAND_BUSY;
            }
            break;



          case SC_INIT:
            tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
            tx_ack_done = TRUE; // [RB]
            servo_cmd_event.command = SERVO_CMD_INIT;
            servo_cmd(&servo_cmd_event);
            break;

          case SC_INIT_FOR_NEW_DISC:
            tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
            tx_ack_done = TRUE; // [RB]
            servo_cmd_event.command = SERVO_CMD_INIT_FOR_NEW_DISC;
            servo_cmd(&servo_cmd_event);
            break;

          case SC_START:
            if (IS_LOADER_STOP_POSITION())
            {
              tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
              tx_ack_done = TRUE; // [RB]
              servo_cmd_event.command = SERVO_CMD_START;
              servo_cmd(&servo_cmd_event);
            }
            break;

          case SC_STOP:
            tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
            tx_ack_done = TRUE; // [RB]
            servo_cmd_event.command = SERVO_CMD_STOP;
            servo_cmd(&servo_cmd_event);
            break;

          case SC_SEEK_0_MIN:
          case SC_SEEK_10_MIN:
          case SC_SEEK_20_MIN:
          case SC_SEEK_30_MIN:
          case SC_SEEK_40_MIN:
          case SC_SEEK_50_MIN:
          case SC_SEEK_60_MIN:
          case SC_SEEK_70_MIN:
            break;

          case SC_SEEK_XX_MIN:
            if (IS_LOADER_STOP_POSITION())
            {
              tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
              tx_ack_done = TRUE; // [RB]
              debug_seek_param.start_mode |= SEEK_START_TRAGET_MSF;
              debug_seek_param.end_mode |= SEEK_PLAY_UNTIL_LEADINOUT;
              debug_seek_param.data_mode = SEEK_DATA_MSF_REACHED;
              debug_seek_param.target = RS232_RxBuffer[3] * 60 * 75;
              if (0 == debug_seek_param.target)
              {
                debug_seek_param.target = 150;
              }
              servo_cmd_event.command = SERVO_CMD_SEEK;
              servo_cmd_event.params.seek = debug_seek_param;
              servo_cmd(&servo_cmd_event);
            }
            break;

          case SC_PAUSE_ON:
            if (IS_LOADER_STOP_POSITION())
            {
              tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
              tx_ack_done = TRUE; // [RB]
              debug_seek_param.start_mode = 0;
              servo_cmd_event.command = SERVO_CMD_PAUSE;
              servo_cmd_event.params.pause = debug_seek_param;
              servo_cmd(&servo_cmd_event);
            }
            break;

          case SC_PAUSE_OFF:
            if (IS_LOADER_STOP_POSITION())
            {
              tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
              tx_ack_done = TRUE; // [RB]
              debug_seek_param.start_mode = 0;
              debug_seek_param.end_mode |= SEEK_PLAY_UNTIL_LEADINOUT;
              debug_seek_param.data_mode = SEEK_DATA_MSF_REACHED;
              debug_seek_param.target = target_T;
              servo_cmd_event.command = SERVO_CMD_SEEK;
              servo_cmd_event.params.seek = debug_seek_param;
              servo_cmd(&servo_cmd_event);
            }
            break;

          case SC_SET_SPEED_CLV_1X:
          case SC_SET_SPEED_CLV_2X:
            break;

          case SC_SET_SPEED_XX:
            tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
            tx_ack_done = TRUE; // [RB]
            servo_cmd_event.command = SERVO_CMD_SET_SPEED;
            servo_cmd_event.params.set_speed = RS232_RxBuffer[3];
            servo_cmd(&servo_cmd_event);
            break;

          case SC_LOADER_INIT:
            tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
            tx_ack_done = TRUE; // [RB]
            loader_cmd_event = LC_INIT;
            loader_cmd(&loader_cmd_event);
            break;

          case SC_INSERT:
            if (servo_fsm_state == IDLE)
            {
              tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
              tx_ack_done = TRUE; // [RB]
              loader_cmd_event = LC_INSERT;
              loader_cmd(&loader_cmd_event);
            }
            break;

          case SC_EJECT:
            if (servo_fsm_state == IDLE)
            {
              tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
              tx_ack_done = TRUE; // [RB]
              servo_misc_flags.field.init_for_new_disc_done = 0;
              loader_cmd_event = LC_EJECT;
              loader_cmd(&loader_cmd_event);
            }
            break;

          case SC_EMEJECT:
            if (servo_fsm_state == IDLE)
            {
              tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
              tx_ack_done = TRUE; // [RB]
              servo_misc_flags.field.init_for_new_disc_done = 0;
              loader_cmd_event = LC_EM_EJECT;
              loader_cmd(&loader_cmd_event);
            }
            break;

          case SC_LOADER_CFG:
            tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF); // [RB]
            tx_ack_done = TRUE; // [RB]
            mconfig_write_bits(CADDR_LOADER_CFG_2, RS232_RxBuffer[3], RS232_RxBuffer[4]);
            mconfig_update_params(CADDR_LOADER_CFG_2, 1);
            break;

          case SC_XFER_ENABLE1:
          case SC_CAP_WP:
            break;

          case PC_PLAY:
          case PC_STOP:
          case PC_PAUSE:
          case PC_PLAY_NEXT:
          case PC_SEARCH_FW:
          case PC_EJECT:
          case PC_PLAY_PREVIOUS:
          case PC_SEARCH_BW:
          case PC_LOAD:
            break;

#if (OS20_PROFILING==1)
          case START_PROFILING:
            Start_profiling();
            RS232_TxBuffer[ERROR_CODE] = 0x00;
            break;

          case STOP_PROFILING:
            Stop_profiling();
            RS232_TxBuffer[ERROR_CODE] = 0x00;
            break;
#endif

          default:
            RS232_TxBuffer[ERROR_CODE] = TEST_NOT_IMPLEMENTED;
            break;
          }
        }
        else
        {
          RS232_TxBuffer[ERROR_CODE] = INV_CKSUM;
        }
        if (tx_ack_done == FALSE)
        {
          RS232_TxBuffer[BYTE_COUNT] = TEST_MSG_ACK_LEN;
          tx_msg(TEST_MSG_ACK_LEN, RS232_TxBuffer, PCIF);
        }
      }
      else
      {
      /* Error Msg: Invalid Length */
      }
      break;

    case JITTER_MSG_OP_CODE:
    /* Rx Message */
    /* RS232_RxBuffer[0] -> Byte Count*/
    /* RS232_RxBuffer[1] -> Op Code   */
    /* RS232_RxBuffer[2] -> Checksum  */

    /* Tx Message */
    /* RS232_TxBuffer[0] <- Byte Count    */
    /* RS232_TxBuffer[1] <- Error Code    */
    /* RS232_TxBuffer[2] <- data_l Sid    */
    /* RS232_TxBuffer[3] <- data_m Sid    */
    /* RS232_TxBuffer[4] <- data_h Sid    */
    /* RS232_TxBuffer[5] <- T_pulse_l     */
    /* RS232_TxBuffer[6] <- T_pulse_m     */
    /* RS232_TxBuffer[7] <- T_pulse_h     */
    /* RS232_TxBuffer[8] <- Jitter_meas   */
    /* RS232_TxBuffer[9] -> Checksum  */

      if (RS232_RxBuffer[BYTE_COUNT] == JITTER_MSG_LEN)
      {
        if (cksum_verify(RS232_RxBuffer[BYTE_COUNT], RS232_RxBuffer))
        {
          uint32 pll_ratio;
          /* The Message Has Correct length */
          RS232_TxBuffer[ERROR_CODE] = NO_ERROR;
          RS232_TxBuffer[BYTE_COUNT] = JITTER_ACK_MSG_LEN;
          // ldata2 = T_ pulse * 2L / pll_ratio;
          pll_ratio = (freq_1T >> ACQ_CHA_CTRL1.field.dec_ratio); // pll_ratio;
          RS232_TxBuffer[2] = (uint8)(T_actual & 0x000000FFL);
          RS232_TxBuffer[3] = (uint8)(T_actual & 0x0000FF00L) >> 8;
          RS232_TxBuffer[4] = (uint8)(T_actual & 0x00FF0000L) >> 16;
          RS232_TxBuffer[5] = (uint8)(pll_ratio & 0x000000FFL);
          RS232_TxBuffer[6] = (uint8)((pll_ratio & 0x0000FF00L) >> 8);
          RS232_TxBuffer[7] = (uint8)((pll_ratio & 0x00FF0000L) >> 16);
       // RS232_TxBuffer[5] = (T_pulse & 0x000000FFL);
       // RS232_TxBuffer[6] = (T_pulse & 0x0000FF00L) >> 8;
       // RS232_TxBuffer[7] = (T_pulse & 0x00FF0000L) >> 16;
          RS232_TxBuffer[8] = ACQ_JITTER;
          RS232_TxBuffer[9] = ACQ_BOOST.all;
          tx_msg(JITTER_ACK_MSG_LEN, RS232_TxBuffer, PCIF);
        }
        else
        {
          RS232_TxBuffer[ERROR_CODE] = INV_CKSUM;
          RS232_TxBuffer[BYTE_COUNT] = JITTER_ACK_MSG_LEN;
          tx_msg(JITTER_ACK_MSG_LEN, RS232_TxBuffer, PCIF);
        }
      }
      else
      {
        /* Error Msg: Invalid Length */
        RS232_TxBuffer[BYTE_COUNT] = JITTER_ACK_MSG_LEN;
        RS232_TxBuffer[1] = ILL_CMND_ERR_CODE;
        tx_msg(JITTER_ACK_MSG_LEN, RS232_TxBuffer, PCIF);
      }
      break;

    default:
      RS232_TxBuffer[BYTE_COUNT] = ILL_CMND_MSG_LEN;
      RS232_TxBuffer[ERROR_CODE] = ILL_CMND_ERR_CODE;
      tx_msg(ILL_CMND_MSG_LEN, RS232_TxBuffer, PCIF);
      break;
    } /* switch(RS232_RxBuffer[OP_CODE]) */
  }
}


void tx_msg(uint8 msg_len, uint8 *tx_msg_buf_ptr, uint8 if_type)
{
  uint8 i;

  tx_msg_buf_ptr[msg_len] = 0x00;

  for (i = 0; i < msg_len ; i++)
  {
    tx_msg_buf_ptr[msg_len] += tx_msg_buf_ptr[i];
    tx_msg_buf_ptr[msg_len] &= 0xFF;
  }

  RS232_Send();
}


uint8 cksum_verify(uint8 byte_count, uint8 * msg_buf_ptr)
{
  uint8 i;
  uint8 cksum;

  cksum = 0x00;

  for (i = 0; i < byte_count; i++)
  {
    cksum += msg_buf_ptr[i];
  }

  cksum &= 0xFF;

  if (cksum == msg_buf_ptr[byte_count])
  {
    return SUCCEEDED;
  }
  else
  {
    return FAILURE;
  }
}

#endif // (DEBUG_INCLUDE_PCDEB == 1)