em.c

GSM手机设计软件代码

  TRACE_FUNCTION ("em_trace_ubyte");

  sprintf (buf, "before %d %d ubyte", ev_first_read, ev_first_write);
  TRACE_EVENT (buf);
#endif

  if (ev_enabled)
  {
    // get memory if needed
    em_get_size (3);
    // write subclass
    ev_buffer[ev_first_write++] = subclass + 0x40;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write type
    ev_buffer[ev_first_write++] = type;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write parameter
    ev_buffer[ev_first_write++] = para_ubyte;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    ev_size -= 3;
  }
#if defined (WIN32)
  sprintf (buf, "after %d %d ubyte", ev_first_read, ev_first_write);
  TRACE_EVENT (buf);
#endif
}

GLOBAL void em_trace_ushort (UBYTE  class,
                             UBYTE  subclass,
                             UBYTE  type,
                             USHORT para_ushort)
{
#if defined (WIN32)
  char buf[60];

  TRACE_FUNCTION ("em_trace_ushort");
  
  sprintf (buf, "before %d %d ushort", ev_first_read, ev_first_write);
  TRACE_EVENT (buf);
#endif

  if (ev_enabled)
  {
    // get memory if needed
    em_get_size (4);
    // write subclass
    ev_buffer[ev_first_write++] = subclass + 0x80;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write type
    ev_buffer[ev_first_write++] = type;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write parameter
    ev_buffer[ev_first_write++] = para_ushort >> 8;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write parameter
    ev_buffer[ev_first_write++] = para_ushort & 8;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    ev_size -= 4;
  }
#if defined (WIN32)
  sprintf (buf, "after %d %d ushort", ev_first_read, ev_first_write);
  TRACE_EVENT (buf);
#endif
}


GLOBAL void em_trace_array  (UBYTE    class,
                             UBYTE    subclass,
                             UBYTE    type,
                             UBYTE  * array,
                             UBYTE    length)
{
  UBYTE i;
#if defined (WIN32)
  char buf[60];

  TRACE_FUNCTION ("em_trace_array");
  
  sprintf (buf, "before %d %d array", ev_first_read, ev_first_write);
  TRACE_EVENT (buf);
#endif

  if (ev_enabled)
  {
    // get memory if needed
    em_get_size ((UBYTE)(length+3));
    // write subclass
    ev_buffer[ev_first_write++] = subclass + 0xC0;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write type
    ev_buffer[ev_first_write++] = type;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write length
    ev_buffer[ev_first_write++] = length;
    if (ev_first_write >= EV_BUFFER_SIZE)
      ev_first_write -= EV_BUFFER_SIZE;
    // write parameter
    for (i=0;i<length;i++)
    {
      ev_buffer[ev_first_write++] = array[i];
      if (ev_first_write >= EV_BUFFER_SIZE)
        ev_first_write -= EV_BUFFER_SIZE;
    }
    ev_size -= (length+3);
  }
#if defined (WIN32)
  sprintf (buf, "after %d %d array", ev_first_read, ev_first_write);
  TRACE_EVENT (buf);
  sprintf (buf, "%x %x %x %x %x",
                ev_buffer[0],
                ev_buffer[1],
                ev_buffer[2],
                ev_buffer[3],
                ev_buffer[4]);
  TRACE_EVENT (buf);
#endif
}


LOCAL void em_get_size (UBYTE size)
{
  while (ev_size < size)
  {
    /*
     * increase ev_first_read to get memory
     */
    switch (ev_buffer [ev_first_read & 0xC0])
    {
      case 0x00:   
        // single entry
        ev_size += 2;
        ev_first_read += 2;
        break;
      case 0x40:   
        // ubyte entry
        ev_size += 3;
        ev_first_read += 3;
        break;
      case 0x80:   
        // ushort entry
        ev_size += 3;
        ev_first_read += 3;
        break;
      case 0xC0:   
        // array entry
        // skip to length
        ev_first_read += 2;
        if (ev_first_read >= EV_BUFFER_SIZE)
          ev_first_read -= EV_BUFFER_SIZE;
        ev_first_read += (1+ev_buffer[ev_first_read]);
        break;
    }
    // align if at the end of the buffer
    if (ev_first_read >= EV_BUFFER_SIZE)
      ev_first_read -= EV_BUFFER_SIZE;
  }
}

LOCAL UBYTE em_check_em_class_infra_data (UBYTE          em_subclass,
                                          UBYTE          em_type,
                                          em_data_type * out_em_data)
{
  switch (em_subclass)
  {
    case EM_SUBCLASS_SC_INFO:
      return (em_check_em_subclass_sc_info (em_type, out_em_data));
    case EM_SUBCLASS_NC_INFO:
      return (em_check_em_subclass_nc_info (em_type, out_em_data));
    case EM_SUBCLASS_LUP_AND_PAG:
      return (em_check_em_subclass_lup_and_pag (em_type, out_em_data));
    default:
      return EM_INVALID_SUBCLASS;
  }
}

LOCAL UBYTE em_check_em_subclass_sc_info (UBYTE          em_type,
                                          em_data_type * out_em_data)
{
  T_EM_NC_DATA em_nc_data;
  /*
   * ret   0   not available
   *       1   idle mode
   *       2   dedicated mode
   */
  UBYTE        ret;

  out_em_data->em_class    = EM_CLASS_INFRA_DATA;
  out_em_data->em_subclass = EM_SUBCLASS_SC_INFO;
  out_em_data->em_type     = em_type;

  ret = em_get_nc_data (&em_nc_data, 6);  // serving cell data
  
  switch (em_type)
  {
    case EM_IN_SC_BCCH_ARFCN:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3x",em_nc_data.arfcn);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_C1:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3d",em_nc_data.c1);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_C2:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3d",em_nc_data.c2);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_BSIC:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3x",em_nc_data.bsic);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_LAC:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3x",em_nc_data.lac);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_BA:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3d",em_nc_data.cba);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_BQ:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3d",em_nc_data.cbq);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_TIL_STATE:
#if !defined(FF_GTI)
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3d",em_nc_data.til_state);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
#endif  /* !FF_GTI */
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_RX:
      if (ret EQ 1)
      {
        sprintf ((char *)out_em_data->em_parameter,"%3d",em_nc_data.rxlev);
        out_em_data->em_length = strlen ((char *)out_em_data->em_parameter);
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;

    case EM_IN_SC_NMR_RAW:
      if (em_get_network_meas (out_em_data->em_parameter) EQ 1)
      {
        out_em_data->em_length = 16;
        return DRV_OK;
      }
      else
        return EM_DATA_NOT_AVAIL;
      break;
  
    case EM_IN_SC_BCCH_LIST_RAW:
      if (em_get_bcch_chan_list (out_em_data) NEQ 1)
        return DRV_OK;
      else
        return EM_DATA_NOT_AVAIL;
      break;

    default:
      return EM_INVALID_TYPE;
  }
}

LOCAL UBYTE em_check_em_subclass_nc_info (UBYTE          em_type,
                                          em_data_type * out_em_data)
{
  T_EM_NC_DATA em_nc_data;
  /*
   * ret   0   not available
   *       1   idle mode
   *       2   dedicated mode
   */
  UBYTE        ret;
  UBYTE        cell_id;

  out_em_data->em_class    = EM_CLASS_INFRA_DATA;
  out_em_data->em_subclass = EM_SUBCLASS_NC_INFO;
  out_em_data->em_type     = em_type;

  switch( em_type )
  {
    case EM_IN_NC_BCCH_1:
    case EM_IN_NC_RX_1:
    case EM_IN_NC_C1_1:
    case EM_IN_NC_C2_1:
    case EM_IN_NC_BSIC_1:
    case EM_IN_NC_CID_1:
    case EM_IN_NC_FN_OFFSET_1:
    case EM_IN_NC_TA_OFFSET_1:
    case EM_IN_NC_LAC_1:
    case EM_IN_NC_BA_1:
    case EM_IN_NC_BQ_1:
    case EM_IN_NC_TIL_STATE_1:
          cell_id = 0;
    break;

    case EM_IN_NC_BCCH_2:
    case EM_IN_NC_RX_2:
    case EM_IN_NC_C1_2:
    case EM_IN_NC_C2_2:
    case EM_IN_NC_BSIC_2:
    case EM_IN_NC_CID_2: