mbus.c

Nokia手机M2Bus通讯协议底层程序.对手机编程开发人员有用

    fprintf(rfile,"MSID: ");

    for (i=0;i<U32replysize-3;i++)
      fprintf(rfile,"%02X",AU8buffer[i]);

    fprintf(rfile,"\n");
  }

  if (!MBUS_SecurityCommand(&MBUS_getMCUchecksum, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"MCU checksum: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getASICcmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"ASIC: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getCOBBAcmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"COBBA: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getinternalDSPcmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"DSP internal sw: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getexternalDSPcmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"DSP external sw: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getsecuritycodecmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"Security code: %s\n",AU8buffer);

  simlockinfo = (tSIMLOCKINFO *)&AU8buffer[0];
  if (!MBUS_SecurityCommand(&MBUS_getsimlockinfocmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"Simlock info:\n");

  for (i=0;i<MBUS_MAX_SIMLOCKS;i++)
  {
     fprintf(rfile,"Simlock %d is a %s lock and it's %s (", MBUS_SIMLOCKINDEX[i], (simlockinfo->U8lockstype & (1 << i) ? "user" : "factory"), (simlockinfo->U8locksclosed & (1 << i) ? "closed" : "open") );
     U8flag = (MBUS_SIMLOCKPOS[i] & 0x01 ? 0x0F : 0xF0);
     for (j=0,k=MBUS_SIMLOCKPOS[i] >> 1;j<(UINT32)MBUS_SIMLOCKLEN[i];j++)
     {
       U8char = simlockinfo->U8locksinfo[k];
       if (U8flag == 0xF0)
       {
         fprintf(rfile,"%X", (U8char & U8flag) >> 4);
         U8flag = 0x0F;
       }
       else
       {
         fprintf(rfile,"%X", U8char & U8flag);
         U8flag = 0xF0;
         k++;
       }
     }
     fprintf(rfile,")\n");
  }

  if (!MBUS_SecurityCommand(&MBUS_getordernumbercmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"Order number: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getproductsncmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"Product serial number: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getbasicproductcodecmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"Basic product code: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getmanufacturemonthcmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"Manufacture month: %s\n",AU8buffer);

  if (!MBUS_SecurityCommand(&MBUS_getpurchasedatecmd, AU8buffer, sizeof(AU8buffer), &U32replysize))
  {
    fclose(rfile);
    return FALSE;
  }

  fprintf(rfile,"Purchase date: %s\n",(strlen((char *)AU8buffer)==0 ? "Not available" : (char *)AU8buffer));

  fclose(rfile);

  return TRUE;
}


/********************************************************
*                                                       *
* FUNCTION NAME:                                        *
*                                                       *
* ARGUMENTS:                                            *
*                                                       *
* ARGUMENT NAME:                                        *
*                                                       *
* TYPE:                                                 *
*                                                       *
* I/O:                                                  *
*                                                       *
* DESCRIPTION                                           *
*                                                       *
*                                                       *
* RETURNS:                                              *
*                                                       *
*********************************************************/

BOOL MBUS_GetVersion(UINT8 *pAU8buffer,UINT32 U32bufferlen)
{
  UINT32 U32versionsize;

  if (!mbus_config.Binitialized)
  {
    HDBGSTR("MBUS_GetVersion : MBUS is not initialized");
    return FALSE;
  }

  if (!MBUS_SetServiceMode())
  {
    MDBGSTR("MBUS_GetVersion : cannot set service mode");
    return FALSE;
  }

  if (!MBUS_SecurityCommand(&MBUS_getversioncmd, pAU8buffer, U32bufferlen, &U32versionsize))
  {
    MDBGSTR("MBUS_GetVersion : cannot send command");
    return FALSE;
  }

  return TRUE;
}


/********************************************************
*                                                       *
* FUNCTION NAME:                                        *
*                                                       *
* ARGUMENTS:                                            *
*                                                       *
* ARGUMENT NAME:                                        *
*                                                       *
* TYPE:                                                 *
*                                                       *
* I/O:                                                  *
*                                                       *
* DESCRIPTION                                           *
*                                                       *
*                                                       *
* RETURNS:                                              *
*                                                       *
*********************************************************/

static BOOL MBUS_ResetGivenSettings(const tMBUSCMD *mbuscmd,UINT8 U8multiplier)
{
  UINT8 AU8buffer[1024];
  UINT32 U32replysize;
  BOOL Bsuccess;

  if (U8multiplier>0)
  {
    mbus_config.newcommtimeouts.ReadTotalTimeoutConstant = U8multiplier*mbus_config.U16comdelay;
    SetCommTimeouts(hComm, &mbus_config.newcommtimeouts);
  }

  Bsuccess = MBUS_SecurityCommand(mbuscmd, AU8buffer, sizeof(AU8buffer), &U32replysize);

  if (U8multiplier>0)
  {
    mbus_config.newcommtimeouts.ReadTotalTimeoutConstant = mbus_config.U16comdelay;
    SetCommTimeouts(hComm, &mbus_config.newcommtimeouts);
  }

  if (!Bsuccess)
  {
    LDBGSTR1("MBUS_ResetGivenSettings : cannot apply '%s'",mbuscmd->AU8name);
  }

  return Bsuccess;
}


/********************************************************
*                                                       *
* FUNCTION NAME:                                        *
*                                                       *
* ARGUMENTS:                                            *
*                                                       *
* ARGUMENT NAME:                                        *
*                                                       *
* TYPE:                                                 *
*                                                       *
* I/O:                                                  *
*                                                       *
* DESCRIPTION                                           *
*                                                       *
*                                                       *
* RETURNS:                                              *
*                                                       *
*********************************************************/

BOOL MBUS_ResetSettings(eMBUS_RESET_TYPE reset_type)
{
  UINT8 AU8buffer[1024];
  UINT32 U32replysize;
  BOOL Bsuccess;

  if (!mbus_config.Binitialized)
  {
    HDBGSTR("MBUS_ResetSettings : MBUS is not initialized");
    return FALSE;
  }

  if (!MBUS_SetServiceMode())
  {
    return FALSE;
  }

  if (reset_type==MBUS_RESET_TYPE_PHONE || reset_type==MBUS_RESET_TYPE_ALL)
  {
    if (!MBUS_ResetGivenSettings(&MBUS_resetphonesetcmd,0))
    {
      return FALSE;
    }
  }

  if (reset_type==MBUS_RESET_TYPE_UIF || reset_type==MBUS_RESET_TYPE_ALL)
  {
    if (!MBUS_ResetGivenSettings(&MBUS_resetuifsetcmd,2))
    {
      return FALSE;
    }
  }

  if (reset_type==MBUS_RESET_TYPE_SCM || reset_type==MBUS_RESET_TYPE_ALL)
  {
    if (!MBUS_ResetGivenSettings(&MBUS_resetallsetcmd,2))
    {
      return FALSE;
    }
  }

  if (reset_type==MBUS_RESET_TYPE_DEV || reset_type==MBUS_RESET_TYPE_ALL)
  {
    if (!MBUS_ResetGivenSettings(&MBUS_resetdevsetcmd,0))
    {
      return FALSE;
    }
  }

  if (reset_type==MBUS_RESET_TYPE_FACTORY || reset_type==MBUS_RESET_TYPE_ALL)
  {
    if (!MBUS_ResetGivenSettings(&MBUS_resetfactorysetcmd,5))
    {
      return FALSE;
    }
  }

  return TRUE;
}

/********************************************************
*                                                       *
* FUNCTION NAME:                                        *
*                                                       *
* ARGUMENTS:                                            *
*                                                       *
* ARGUMENT NAME:                                        *
*                                                       *
* TYPE:                                                 *
*                                                       *
* I/O:                                                  *
*                                                       *
* DESCRIPTION                                           *
*                                                       *
*                                                       *
* RETURNS:                                              *
*                                                       *
*********************************************************/

BOOL MBUS_ResetPhone(void)
{
  UINT8 AU8buffer[1024];
  UINT32 U32replysize;
  BOOL Bsuccess;

  if (!mbus_config.Binitialized)
  {
    HDBGSTR("MBUS_ResetPhone : MBUS is not initialized");
    return FALSE;
  }

  if (!MBUS_SetServiceMode())
  {
    return FALSE;
  }

  Bsuccess = MBUS_SecurityCommand(&MBUS_resetphonecmd, AU8buffer, sizeof(AU8buffer), &U32replysize);

  if (!Bsuccess) 
  {
    LDBGSTR("MBUS_ResetPhone : reset failed");
  }

  return Bsuccess;
}