app_asyncfile.c

最新MTK手机软件源码

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2005
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/

/*****************************************************************************
 *
 * Filename:
 * ---------
 * applib_asyncfile.c
 *
 * Project:
 * --------
 *   Maui
 *
 * Description:
 * ------------
 *   This file is intends for async file operations.
 *
 * Author:
 * -------
 * -------
 *
 *============================================================================
 *             HISTORY
 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *------------------------------------------------------------------------------
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 *------------------------------------------------------------------------------
 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *============================================================================
 ****************************************************************************/
#define  _APP_ASYNCFILE_C

#include "kal_release.h"
#include "stacklib.h"
#include "event_shed.h" /* event schedulet */
#include "stack_timer.h"
#include "fs_errcode.h"
#include "fs_type.h"
#include "app_asyncfile.h"

#include "stack_common.h"
#include "stack_msgs.h"
#include "stack_config.h"
#include "app_ltlcom.h"

#include "app_str.h"
#include "FS_func.h"

extern task_indx_type mod_task_g[RPS_TOTAL_STACK_MODULES];

void applib_async_file_task_write_continue(applib_async_file_task_struct *op);
void applib_async_file_task_read_continue(applib_async_file_task_struct *op);


/*****************************************************************************
 * FUNCTION
 *  transferFsError
 * DESCRIPTION
 *  
 * PARAMETERS
 *  fs_err      [IN]        
 * RETURNS
 *  
 *****************************************************************************/
static kal_int32 transferFsError(kal_int32 fs_err)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    switch (fs_err)
    {
        case FS_NO_ERROR:
            return APPLIB_ASYNC_FILE_OK;
        case FS_FILE_NOT_FOUND:
        case FS_INVALID_FILENAME:
            return APPLIB_ASYNC_FILE_ERROR_PATH;    /* Note that applications might check this error code */

        case FS_ACCESS_DENIED:
            return APPLIB_ASYNC_FILE_ERROR_ACCESS;

        case FS_MEDIA_CHANGED:
            return APPLIB_ASYNC_FILE_ERROR_ACCESS;

        case FS_TOO_MANY_FILES:
            return APPLIB_ASYNC_FILE_ERROR_ACCESS;

        case FS_DISK_FULL:
        case FS_APP_QUOTA_FULL:
            return APPLIB_ASYNC_FILE_ERROR_FULL;    /* Note that applications might check this error code */

        case FS_FILE_EXISTS:
            return APPLIB_ASYNC_FILE_ERROR_EXIST;   /* Note that applications might check this error code */

            /* File System is busy now, return immediately with cause "DELAY" */
        case FS_FLASH_ERASE_BUSY:
        case FS_LOCK_MUTEX_FAIL:
            return APPLIB_ASYNC_FILE_ERROR_DELAYED;
        default:
            return APPLIB_ASYNC_FILE_ERROR_INVALID;
    }
}


/*****************************************************************************
 * FUNCTION
 *  applib_async_file_task_internal_write
 * DESCRIPTION
 *  
 * PARAMETERS
 *  op      [?]     
 * RETURNS
 *  void
 *****************************************************************************/
static void applib_async_file_task_internal_write(applib_async_file_task_struct *op)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 ret;
    kal_uint32 wr_no;
    kal_uint32 length;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (op == NULL)
    {
        ASSERT(0);
    }

    length = op->buffer - op->pos + op->dataLen;
    while (1)
    {
        if (length == 0)
        {
            op->callback(APPLIB_ASYNC_FILE_OK, op->totalLen, op->arg_in_callback);
            return;
        }

        wr_no = 0;
    #ifndef __MTK_TARGET__
        if (length > 512)
        {
            ret = FS_Write(op->fileHandle, op->pos, 512, &wr_no);
            ret = FS_FLASH_ERASE_BUSY;
        }
        else
        {
            ret = FS_Write(op->fileHandle, op->pos, length, &wr_no);
        }
    #else /* __MTK_TARGET__ */ 
        ret = FS_Write(op->fileHandle, op->pos, length, &wr_no);
    #endif /* __MTK_TARGET__ */ 
        if (wr_no > 0)
        {
            op->totalLen += (unsigned long)wr_no;
            op->pos += wr_no;
            length -= wr_no;
        }
        switch (transferFsError(ret))
        {
                /* File system busy */
            case APPLIB_ASYNC_FILE_ERROR_DELAYED:
            {
                if (applib_callout_active(op->fs_timer))
                {
                    ASSERT(0);
                }
                op->fs_timer.c_flags |= APPLIB_CALLOUT_ACTIVE;
                op->fs_timer.event_id = evshed_set_event(
                                            op->es,
                                            (kal_timer_func_ptr) applib_async_file_task_write_continue,
                                            op,
                                            APPLIB_FILE_TIMEOUT);
                return;
            }
            default:
                if (ret < 0)
                {
                    op->callback(transferFsError(ret), op->totalLen, op->arg_in_callback);
                    return;
                }
        }

    }
}


/*****************************************************************************
 * FUNCTION
 *  applib_async_file_task_internal_read
 * DESCRIPTION
 *  
 * PARAMETERS
 *  op      [?]     
 * RETURNS
 *  void
 *****************************************************************************/
static void applib_async_file_task_internal_read(applib_async_file_task_struct *op)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int32 ret;
    kal_uint32 rd_no;
    kal_uint32 length;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (op == NULL)
    {
        ASSERT(0);
    }

    length = op->buffer + op->dataLen - op->pos;
    while (1)
    {
        if (length == 0)
        {
            op->callback(APPLIB_ASYNC_FILE_OK, op->totalLen, op->arg_in_callback);
            return;
        }

        rd_no = 0;

    #ifndef __MTK_TARGET__
        if (length > 512)
        {
            ret = FS_Read(op->fileHandle, op->pos, 512, &rd_no);
            ret = FS_FLASH_ERASE_BUSY;
        }
        else
        {
            ret = FS_Read(op->fileHandle, op->pos, length, &rd_no);
        }
    #else /* __MTK_TARGET__ */ 
        ret = FS_Read(op->fileHandle, op->pos, length, &rd_no);
    #endif /* __MTK_TARGET__ */ 

        if (rd_no > 0)
        {
            op->totalLen += (unsigned long)rd_no;
            op->pos += rd_no;
            length -= rd_no;
        }
        switch (transferFsError(ret))
        {
                /* File system busy */
            case APPLIB_ASYNC_FILE_ERROR_DELAYED:
            {
                if (applib_callout_active(op->fs_timer))
                {
                    ASSERT(0);
                }
                op->fs_timer.c_flags |= APPLIB_CALLOUT_ACTIVE;
                op->fs_timer.event_id = evshed_set_event(
                                            op->es,
                                            (kal_timer_func_ptr) applib_async_file_task_read_continue,
                                            op,
                                            APPLIB_FILE_TIMEOUT);
                return;
            }

            default:
                if (ret < 0)
                {
                    op->callback(transferFsError(ret), op->totalLen, op->arg_in_callback);
                    return;
                }
        }

    }
}


/*****************************************************************************
 * FUNCTION
 *  applib_async_file_task_start
 * DESCRIPTION
 *  
 * PARAMETERS
 *  op              [?]         
 *  mod_id          [IN]        
 *  filename        [?]         
 *  access_mode     [IN]        
 *  es              [?]         
 *  callback        [IN]        
 *  return_arg      [?]         
 * RETURNS
 *  
 *****************************************************************************/
kal_bool applib_async_file_task_start(
            applib_async_file_task_struct *op,
            module_type mod_id,
            kal_wchar *filename,
            applib_async_file_mode_enum access_mode,
            event_scheduler *es,
            applib_aysnc_file_task_callback_fn callback,
            void *return_arg)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    int fileHandle;
    int openMode;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (op == NULL || filename == NULL)
    {
        return NULL;
    }

    kal_mem_set(op, 0, sizeof(applib_async_file_task_struct));

    switch (access_mode)
    {
        case APPLIB_ASYNC_FILE_MODE_READ:
            openMode = APPLIB_ASYNC_FILE_READ | FS_NONBLOCK_MODE | FS_OPEN_SHARED;
            break;

        case APPLIB_ASYNC_FILE_MODE_READ_WRITE:
        case APPLIB_ASYNC_FILE_MODE_WRITE:
            openMode = APPLIB_ASYNC_FILE_WRITE | APPLIB_ASYNC_FILE_CREATE | FS_NONBLOCK_MODE;
            break;

        default:
            openMode = APPLIB_ASYNC_FILE_WRITE | APPLIB_ASYNC_FILE_CREATE | FS_NONBLOCK_MODE;
            break;
    }

    fileHandle = FS_Open(filename, openMode);
    if (fileHandle < 0)
    {
        return KAL_FALSE;
    }
    op->mod_id = mod_id;
    op->isFSopen = KAL_TRUE;
    op->fileHandle = fileHandle;
    op->es = es;
    op->callback = callback;
    op->arg_in_callback = return_arg;

    return KAL_TRUE;
}