cphs_mod.c

是一个手机功能的模拟程序

  }
  /*else
    cphs_data->dvData[0] = 0xF0 | cphs_data->dvData[0];*/

  if (fax EQ CPHS_LINEFLAG_SET   OR
      fax EQ CPHS_LINEFLAG_NOT_SET  )
  {  cphs_data->dvData[0] &= 0xF0;			//zero low nibble
    cphs_data->dvData[1] += fax&0x0F;              /* low Nibble */
  	}
 /* else
    cphs_data->dvData[1] |= 0x0F;*/

  if (data EQ CPHS_LINEFLAG_SET   OR
      data EQ CPHS_LINEFLAG_NOT_SET  )
  {	cphs_data->dvData[1] &= 0x0F;			//zero high nibble
    cphs_data->dvData[1] += (data << 4)&0xF0;     /* high Nibble */
  }
  /*else
    cphs_data->dvData[1] = 0xF0 | cphs_data->dvData[1];*/
	sprintf(debug, "Divert Data:%x%x", cphs_data->dvData[0], cphs_data->dvData[1]);
	TRACE_EVENT(debug);
  /* Read call forwarding flag to determine the size */
  cphs_data->simStatus = SIMOP_WRITE_OK;
  if (!Cphs_read_sim_dat(SIM_CPHS_CFF, NOT_PRESENT_8BIT, CPHS_CFF_SIZE))
  {	TRACE_EVENT("Mailbox SIM write failed");
    return SIMOP_WRITE_ERR;
    //cphs_sign_exec(E_CPHS_SET_DV_STAT, &result);
  }
/* PATCH VO 22.01.01 end */
  return cphs_data->cphsStatus;
}

/*CPHS_RET cphs_set_als_status (T_CPHS_ALS_INFO status)
{
  UBYTE result;
  //T_MFW_SIM_PIN_STATUS pinStatus;

  //TRACE_EVENT ("cphs_set_als_status()");

  /* check PIN 2 requirement */
  /*pinStatus.type = MFW_SIM_PIN2;
  sim_pin_status(&pinStatus);
  if (pinStatus.set NEQ MFW_SIM_NO_PIN)
    return MFW_SIM_PIN2_REQ;

  /* check given parameter */
  /*if (status NEQ MFW_LINE_LOCKED  AND
      status NEQ MFW_LINE_UNLOCKED     )
  {
    result = MFW_SIMOP_WRITE_ERR;
    //cphs_sign_exec(E_CPHS_SET_ALS_STATUS, &result);
    return CPHS_ERR;
  }*/

 /* cphs_data->alsData = (UBYTE)status.locked;*/

    /* write lock status in EEPROM */
    //MC cphs_write_eeprom_alss(&result);
    //cphs_sign_exec(E_CPHS_SET_LINE, &result);
//  }
/*  return CPHS_IS_OK;
}*/

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| STATE  : code                         ROUTINE: Cphs_read_sim_dat     |
+----------------------------------------------------------------------+


   PURPOSE :   Request to read SIM card.

*/

BOOL Cphs_read_sim_dat(USHORT data_id, UBYTE len, UBYTE max_length)
{
  T_ACI_RETURN res;

  TRACE_FUNCTION ("Cphs_read_sim_dat()");

  res = cmhSIM_ReadTranspEF ( CMD_SRC_NONE,
                              AT_CMD_NONE,
                              data_id,
                              0,
                              max_length,
                              NULL,
                              Cphs_read_sim_dat_cb);
  if (res NEQ AT_EXCT)
    return FALSE;

  return TRUE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| STATE  : code                         ROUTINE: Cphs_read_sim_dat_cb  	|
+----------------------------------------------------------------------+


   PURPOSE :   Call back for SIM read.

*/

void Cphs_read_sim_dat_cb(SHORT table_id)
{
  UBYTE        dataLen;
  UBYTE        result;


  switch (simShrdPrm.atb[table_id].reqDataFld)
  {
    case SIM_CPHS_CINF:	/* CPHS information */
      if (!cphs_data->cphsUpdate)
        Cphs_read_information(simShrdPrm.atb[table_id].errCode,
                              simShrdPrm.atb[table_id].exchData,
                              simShrdPrm.atb[table_id].dataLen);
/*#ifdef SIM_TOOLKIT
      else
        Cphs_update_info_cnf(simShrdPrm.atb[table_id].errCode,
                             simShrdPrm.atb[table_id].exchData,
                             simShrdPrm.atb[table_id].dataLen);
#endif*/
      break;

    case SIM_CPHS_ONSTR:  /* operator name string */

      Cphs_read_ons(simShrdPrm.atb[table_id].errCode,
                    simShrdPrm.atb[table_id].exchData,
                    simShrdPrm.atb[table_id].dataLen);
      break;

    case SIM_CPHS_ONSHF:	/* operator name short form */

      Cphs_read_onsf(simShrdPrm.atb[table_id].errCode,
                     simShrdPrm.atb[table_id].exchData,
                     simShrdPrm.atb[table_id].dataLen);
      Cphs_get_mailbox_status();//get next item
      break;

    case SIM_CPHS_VMW:	/* voice message waiting flag */

      if (cphs_data->simStatus EQ SIMOP_WRITE_OK)
      {
        /* Determine the size of this field, and write the data.
           When the writing is not possible, write this voice
           message waiting flag in EEPROM.                     */
        cphs_data->simStatus = SIMOP_UNKNOWN;
        if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
        {
          dataLen = simShrdPrm.atb[table_id].dataLen;
          /* Write voice message waiting flag.
             When this writing failed, send event with "write error" parameter to MMI */
          if (!Cphs_write_sim_dat(SIM_CPHS_VMW, cphs_data->mbsData, dataLen))
          {
            cphs_data->mbStatus.result    = SIMOP_WRITE_ERR;

            cphs_data->mbStatus.line1 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->mbStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->mbStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->mbStatus.data = CPHS_FLAG_NOT_PRESENT;
          }
        }
        else
        {
          cphs_data->mbStatus.result = SIMOP_WRITE_ERR;
          //cphs_sign_exec(E_CPHS_SET_VC_STAT, &result);
          cphs_data->mbStatus.line1 = CPHS_FLAG_NOT_PRESENT;
		  cphs_data->mbStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->mbStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->mbStatus.data = CPHS_FLAG_NOT_PRESENT;
        }
      }
      else
/* PATCH VO 22.01.01 end */
      {
      	Cphs_read_mbs (simShrdPrm.atb[table_id].errCode,
                       simShrdPrm.atb[table_id].exchData,
                       simShrdPrm.atb[table_id].dataLen);
      	Cphs_get_csp();
      }
      break;

    case SIM_CPHS_CFF:	/* call forwarding flag */
/* PATCH VO 22.01.01 */
      if (cphs_data->simStatus EQ SIMOP_WRITE_OK)
      {
        /* Determine the size of this field, and write the data.
           When the writing is not possible, write this voice
           message waiting flag in EEPROM.                     */
        cphs_data->simStatus = SIMOP_UNKNOWN;
        if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
        {
          dataLen = simShrdPrm.atb[table_id].dataLen;
          /* Write call forwarding flag.
             When this writing failed, send event with "write error" parameter to MMI */
         if (!Cphs_write_sim_dat(SIM_CPHS_CFF, cphs_data->dvData, dataLen))
          { TRACE_EVENT("Divert write failed");
            cphs_data->dvStatus.result    = SIMOP_WRITE_ERR;
             cphs_data->dvStatus.line1 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->dvStatus.data = CPHS_FLAG_NOT_PRESENT;
          }
        }
        else
        {TRACE_EVENT("Sim error while writing");
          cphs_data->dvStatus.result = SIMOP_WRITE_ERR;
            cphs_data->dvStatus.line1 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.line2 = CPHS_FLAG_NOT_PRESENT;
			cphs_data->dvStatus.fax = CPHS_FLAG_NOT_PRESENT;
            cphs_data->dvStatus.data = CPHS_FLAG_NOT_PRESENT;
        }
      }
      else
/* PATCH VO 22.01.01 end */
      	{Cphs_get_mailbox();
      		Cphs_read_cff (simShrdPrm.atb[table_id].errCode,
                     simShrdPrm.atb[table_id].exchData,
                     simShrdPrm.atb[table_id].dataLen);
      	}
      break;



    case SIM_CPHS_CSP:	/* customer service profile */
      Cphs_read_csp (simShrdPrm.atb[table_id].errCode,
                     simShrdPrm.atb[table_id].exchData,
                     simShrdPrm.atb[table_id].dataLen);
      //All CPHS data fields have now been read
      //so call callback function to alert client layer

      break;

    default:
      break;
  }
  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| STATE  : code                         ROUTINE: Cphs_read_sim_rcd     	|
+----------------------------------------------------------------------+


   PURPOSE :   Request to read SIM card.

*/

BOOL Cphs_read_sim_rcd(USHORT data_id, UBYTE rcd_num, UBYTE len)
{
  T_ACI_RETURN res;
  UBYTE        dataLen;

  TRACE_FUNCTION ("Cphs_read_sim_rcd()");

  if (rcd_num EQ 1)
      dataLen  = UCHAR_MAX;
    else
      dataLen  = len;

  res = cmhSIM_ReadRecordEF ( CMD_SRC_NONE,
                              AT_CMD_NONE,
                              data_id,
                              rcd_num,
                              dataLen,
                              NULL,
                              Cphs_read_sim_rcd_cb);

  if (res NEQ AT_EXCT)
    return FALSE;

  return TRUE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               							|
| STATE  : code                         ROUTINE: Cphs_read_sim_rcd_cb  	|
+----------------------------------------------------------------------+


   PURPOSE :   Request to read SIM card.

*/

void Cphs_read_sim_rcd_cb (SHORT table_id)
{
  UBYTE dataLen;
  char debug[25];
sprintf(debug, "SIM Error code!!!%d", simShrdPrm.atb[table_id].errCode);

  TRACE_FUNCTION ("Cphs_read_sim_rcd_cb()");
  TRACE_EVENT(debug);

  switch (simShrdPrm.atb[table_id].reqDataFld)
  {
    case SIM_CPHS_MBXN: /* mailbox numbers */
      if (cphs_data->simStatus EQ SIMOP_WRITE_OK)
      {
        /* Determine the size of record, and write a new record.
           When the writing is not possible, write this mailbox
           number in EEPROM.                                 */
        cphs_data->simStatus = SIMOP_UNKNOWN;
        if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR )
        {
          dataLen = simShrdPrm.atb[table_id].dataLen;
          /* allocate mbnData (sizeof(dataLen)) */
          Cphs_build_mbn_data(cphs_data->mbnData, dataLen);
          if (!Cphs_write_sim_rcd(SIM_CPHS_MBXN, cphs_data->vcEntry->index,
                                cphs_data->mbnData, dataLen))
            Cphs_write_eeprom_mailbox(cphs_data->vcEntry);
        }
        else
          Cphs_write_eeprom_mailbox(cphs_data->vcEntry);
      }
      else
        Cphs_read_mbn(table_id);

      break;

    case SIM_CPHS_INFN: /* information numbers */
      if (simShrdPrm.atb[table_id].recNr EQ 1)
      {

        if ((cphs_data->startIdx EQ 1) AND (cphs_data->simStatus EQ SIMOP_READ_OK))
          Cphs_read_info_num(table_id);
        else

          Cphs_read_first_info_num(table_id);
      }
      else
        Cphs_read_info_num(table_id);
      break;

    case SIM_CPHS_INFN2:	 /* information numbers 2 - 7F10 'EA01' selected if SIM_CPHS_INFN '6F19' isn't there*/
      if (simShrdPrm.atb[table_id].recNr EQ 1)
      {

        if ((cphs_data->startIdx EQ 1) AND (cphs_data->simStatus EQ SIMOP_READ_OK))
          Cphs_read_info_num(table_id);
        else
        Cphs_read_first_info_num(table_id);
      }
      else
        Cphs_read_info_num(table_id);
      break;

    default:
      break;
  }
  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module   							            |
| STATE  : code                         ROUTINE: Cphs_write_sim_rcd    	|
+----------------------------------------------------------------------+


   PURPOSE :   Request to write SIM card.

*/

BOOL Cphs_write_sim_rcd(USHORT data_id, UBYTE rcd_num,
                        UBYTE *data,    UBYTE dataLen)
{
  T_ACI_RETURN res;

  TRACE_FUNCTION ("Cphs_read_sim_rcd()");

  res = cmhSIM_WriteRecordEF (CMD_SRC_NONE,
                              AT_CMD_NONE,
                              data_id,
                              rcd_num,
                              dataLen,
                              data,
                              Cphs_write_sim_rcd_cb);

  if (res NEQ AT_EXCT)
    return FALSE;

  return TRUE;
}

/*
+----------------------------------------------------------------------+
| MODULE: CPHS standalone module               |
| STATE  : code                         ROUTINE: Cphs_write_sim_rcd_cb |
+----------------------------------------------------------------------+


   PURPOSE :   callback of SIM card writing.

*/

void Cphs_write_sim_rcd_cb (SHORT table_id)
{
  UBYTE result;
char debug[30];
  TRACE_FUNCTION ("Cphs_write_sim_rcd_cb()");