lcc_task.c

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

        if ((error = ffs_stat(name, &stat)) == EFFS_OK) {//TISH040218
        error = ffs_fread(name, &pwr_cfg->temp, PWR_TEMP_CFG_SIZE);
        }
    } else {
        // Find out which <n> and read /pwr/bat/bat<n>.cfg
        // We know that at least one battery configuration file exists
        // Pick the file that matches the bat_id measured earlier

        for (i = 1; i <= 5; i++) {
            cfg_id = i + '0';
            build_name("/pwr/bat/bat", &cfg_id, 12, ".cfg", name);
            if ((error = ffs_stat(name, &stat)) == EFFS_OK) {//TISH040218
            error = ffs_fread(name, &pwr_cfg->bat, PWR_BAT_CFG_SIZE);
            }
            // Found the right battery id??
            if ((pwr_cfg->data.bat_id >= pwr_cfg->bat.id_low) &&
                (pwr_cfg->data.bat_id <= pwr_cfg->bat.id_high)) {
                ttw(ttr(TTrInitLow, "Chose %s" NL, name));
                // Save the configuration number in the name
                pwr_ctrl->cfg_id = i;
                pwr_cfg->data.cfg_id = cfg_id;
                pwr_ctrl->flag_bat_unknown = 0;

                // Read the corresponding temperature configuration
                build_name("/pwr/bat/temp", &pwr_cfg->data.cfg_id, 13, ".cfg", name);
                if ((error = ffs_stat(name, &stat)) == EFFS_OK) {//TISH040218
                error = ffs_fread(name, &pwr_cfg->temp, PWR_TEMP_CFG_SIZE);
                }
                break;
            }
        }

        // Check if a matching battery configuration was found
        if ((pwr_cfg->data.cfg_id < '1') || (pwr_cfg->data.cfg_id > '5')) {
            pwr_cfg->data.cfg_id = '1';
            pwr_ctrl->cfg_id = 1;
            ttr(TTrWarning, "No matching battery configuration id - Defaults to %d" NL, pwr_ctrl->cfg_id);

            // Flag that battery configuration was unknown
            // Inform the MMI later when it has registered
            pwr_ctrl->flag_bat_unknown = 1;
        }
    }

    ttw(ttr(TTrInit, "pwr_read_files(%d)" NL, 0xFF));
    return RV_OK;
}


// Read calibration files only
T_RVM_RETURN pwr_read_cal_files()
{
    T_FFS_SIZE error;
    T_FFS_STAT stat;  //TISH040218

    // Read /pwr/vbat.cal
  if ((error = ffs_stat("/pwr/vbat.cal", &stat)) == EFFS_OK) {//TISH040218
    error = ffs_fread("/pwr/vbat.cal", &pwr_cfg->cal.vbat, sizeof(pwr_cfg->cal.vbat));
    ttw(ttr(TTrInitLow, "Read /pwr/vbat.cal(%d)" NL, error));
    ttw(ttr(TTrInitLow, "pwr_cfg->cal.vbat.alfa_num=%d" NL, pwr_cfg->cal.vbat.alfa_num));
    ttw(ttr(TTrInitLow, "pwr_cfg->cal.vbat.alfa_denom=%d" NL, pwr_cfg->cal.vbat.alfa_denom));
    ttw(ttr(TTrInitLow, "pwr_cfg->cal.vbat.beta=%d" NL, pwr_cfg->cal.vbat.beta));
  }
    // TISH031218: Added by Jason
    return RV_OK;
}

// This function reads the FFS pwr configuration file
// It is invoked when a charger is plugged
//                               /pwr/chg/chg<n>.cfg    MANDATORY
T_RVM_RETURN pwr_read_chg_files()
{
    T_FFS_SIZE error;
    char name[20];
    uint8 i;
    char chg_id;
    T_FFS_STAT stat; //TISH040218

    ttw(ttr(TTrInit, "pwr_read_chg_files(%d)" NL, 0));

    if (pwr_cfg->data.cforce > 0) {
        // Brute force charger configuration
        build_name("/pwr/chg/chg", &pwr_cfg->data.chg_cfg_id, 12, ".cfg", name);
        if ((error = ffs_stat(name, &stat)) == EFFS_OK) {//TISH040218
        error = ffs_fread(name, &pwr_cfg->chg, PWR_CHG_CFG_SIZE);
        ttw(ttr(TTrInitLow,"error = %d" NL, error));

        // Readout /pwr/chg/chg<N>.cfg
        ttw(ttr(TTrInitLow,"chg.cfg: type: %d" NL, pwr_cfg->chg.type));
        ttw(ttr(TTrInitLow,"ichg_max: %d" NL, pwr_cfg->chg.ichg_max));
        ttw(ttr(TTrInitLow,"vchg_low: %d" NL, pwr_cfg->chg.vchg_low));
        ttw(ttr(TTrInitLow,"vchg_high: %d" NL, pwr_cfg->chg.vchg_high));
        }
    } else {
        // Find out which <n> and read /pwr/chg/chg<n>.cfg
        // We know that at least one charger configuration file exists
        // Pick the file that matches the chg_id measured earlier

        for (i = 1; i <= 5; i++) {
            chg_id = i + '0';
            build_name("/pwr/chg/chg", &chg_id, 12, ".cfg", name);
            if ((error = ffs_stat(name, &stat)) == EFFS_OK) {//TISH040218
            error = ffs_fread(name, &pwr_cfg->chg, PWR_CHG_CFG_SIZE);
            ttw(ttr(TTrInitLow,"error = %d" NL, error));

            // Readout /pwr/chg/chg<N>.cfg
            ttw(ttr(TTrInitLow,"chg.cfg: type: %d" NL, pwr_cfg->chg.type));
            ttw(ttr(TTrInitLow,"ichg_max: %d" NL, pwr_cfg->chg.ichg_max));
            ttw(ttr(TTrInitLow,"vchg_low: %d" NL, pwr_cfg->chg.vchg_low));
            ttw(ttr(TTrInitLow,"vchg_high: %d" NL, pwr_cfg->chg.vchg_high));
            }

            // Found the right charger id??
            if ((pwr_cfg->data.chg_id > pwr_cfg->chg.vchg_low) &&
                (pwr_cfg->data.chg_id < pwr_cfg->chg.vchg_high)) {
                ttw(ttr(TTrInitLow, "Chose %s" NL, name));
                // Save the configuration number in the name
                pwr_ctrl->chg_cfg_id = i;
                pwr_cfg->data.chg_cfg_id = chg_id;
                pwr_ctrl->flag_chg_unknown = 0;

                break;
            }
        }

        // Check if a matching charger configuration was found
        if ((pwr_cfg->data.chg_cfg_id < '1') || (pwr_cfg->data.chg_cfg_id > '5')) {
            pwr_cfg->data.chg_cfg_id = '1';
            pwr_ctrl->chg_cfg_id = 1;
            ttr(TTrWarning, "No matching charger configuration id - Defaults to %d" NL, pwr_ctrl->chg_cfg_id);

            // Flag that charger configuration was unknown
            // Inform the MMI later when it has registered
            pwr_ctrl->flag_chg_unknown = 1;
        }
    }
    ttw(ttr(TTrInit, "pwr_read_chg_files(%d)" NL, 0xFF));
}

void *pwr_malloc(int size)
{
    void *addr;

    if (rvf_get_buf(pwr_ctrl->prim_id, size, &addr) == RVF_RED) {
        ttr(TTrFatal, "PWR FATAL: No Memory (%d)" NL, pwr_ctrl->state);
        return NULL;
    }

    return addr;
}

void pwr_free(void *addr)
{
    int error;

    ttw(ttr(TTrEvent, "pwr_free (%d)" NL, 0));
    if ((error = rvf_free_buf(addr)) != RV_OK) {
        ttr(TTrFatal, "PWR FATAL: pwr_free (%d)" NL, error);
    }
}

void pwr_task()
{
    void                 *request;
    struct pwr_req_s     *pwr_request;
    int    error;

    ttw(ttr(TTrEnv, "pwr_task(%d)" NL, 0));

    while (1)
    {
        rvf_wait(RVF_TASK_MBOX_0_EVT_MASK, 0);
        request  = rvf_read_mbox(RVF_TASK_MBOX_0);
        pwr_request = (struct pwr_req_s *)request;

        if (request != NULL) 
	 {
            ttw(ttr(TTrEvent,    "Received Event(%d)" NL, pwr_request->header.msg_id));
            ttw(ttr(TTrEventLow, "src_addr_id(%d)" NL, pwr_request->header.src_addr_id));
            ttw(ttr(TTrEventLow, "dest_addr_id(%d)" NL, pwr_request->header.dest_addr_id));

            switch (pwr_request->header.msg_id) {
            case PWR_CHARGER_PLUGGED_IND:
                // Sometimes (low voltage - init) receiving a ghost charger plug although interrupts are disabled
                pwr_free(request);
                break;
            case PWR_CHARGER_UNPLUGGED_IND:
                error = process_abb_chg_unplugged_ind(pwr_request);
                break;
            case PWR_TM_READ_REQ  :
                error = process_pwr_tm_read_request(request);
                break;
            case PWR_TM_WRITE_REQ :
                error = process_pwr_tm_write_request(request);
                break;
            case PWR_ADC_IND :
                error = process_spi_adc_indication(request);
                break;

            // Timers

            case TIMER_T1_EXPIRED:
                error = process_pwr_handle_T1_expiration(request);
                break;
            case TIMER_T2_EXPIRED:
                error = process_pwr_handle_T2_expiration(request);
                break;
            case TIMER_T3_EXPIRED:
                error = process_pwr_handle_T3_expiration(request);
                break;
            case TIMER_T4_EXPIRED:
                error = process_pwr_handle_T4_expiration(request);
                break;
            case TIMER_MOD_CYCLE_EXPIRED:
                error = process_pwr_handle_mod_cycle_expiration(request);
                break;
            case TIMER_MMI_INFO_EXPIRED:
                error = process_pwr_handle_mmi_info_expiration(request);
                break;
            default :
                {
                ttr(TTrFatal, "PWR FATAL: Unknown Event: %d" NL, pwr_request->header.msg_id);
                ttr(TTrFatal, "                   State: %d" NL, pwr_ctrl->state);
                // Exception Handling - Unknown Event
                }
            }
        }
	 else 
	 {
            // Exception Handling - NULL pointer
            ttr(TTrFatal, "PWR FATAL: NULL pointer (%d)" NL, pwr_ctrl->state);
        }
    }
    ttw(ttr(TTrEnv, "pwr_task(%d)" NL, 0xFF));
}