mem_task.c

ATMEL 89c51sndc mp3外接硬盘源码

/*C**************************************************************************
* NAME:         mem_task.c
*----------------------------------------------------------------------------
* Copyright (c) 2002 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      snd1c-demo-hdd-0_2_0      
* REVISION:     1.1     
*----------------------------------------------------------------------------
* PURPOSE:
* This file contains the memory task and attached routines
*
* NOTES:
* Global Variables:
*   - gl_memory:    bit in bdata space
*   - gl_mem_tick:  byte in data space
*****************************************************************************/

/*_____ I N C L U D E S ____________________________________________________*/

#include "config.h"                         /* system configuration */
#include "..\display\disp.h"                /* display definition */
#include "..\file\file.h"                   /* file definition */
#include "lib_mem\hdd\ata.h"                /* ata definition */
#include "lib_mem\hdd\ide.h"                /* definition definition */
#include "mem_task.h"                       /* memory task definition */

/*_____ M A C R O S ________________________________________________________*/


/*_____ D E F I N I T I O N ________________________________________________*/

extern  bdata   bit     gl_memory;          /* selected memory */
extern  data    Byte    gl_mem_tick;        /* memory tick counter */

static  Byte    mem_state;                  /* task state */
static  bit     mem_force_mmc;

/*_____ D E C L A R A T I O N ______________________________________________*/



/*F**************************************************************************
* NAME: mem_task_init
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Memory task initialization
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_task_init (void)
{
  mem_state = MEM_INIT;
}


/*F**************************************************************************
* NAME: mem_task
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE: 
*   Memory management task
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   STATES:
*   MEM_INIT            memories initialization
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_task (void)
{
  switch (mem_state)
  {
    case MEM_INIT:
    {
      hdd_init();                           /* device initialization */
      mem_state = MEM_HDD_INIT;
      break;
    }

    case MEM_HDD_INIT:
    {
      ata_identify_device();
      if (File_mount() == OK)
      {
        mem_state = MEM_HDD_IDLE;
      }
      else
      {
        mem_state = MEM_HDD_ERR_FMT;
      }
      break;
    }

    case MEM_HDD_IDLE:
    {
      break;
    }

    case MEM_HDD_ERR_FMT:
    {
      break;
    }
  }
}


/*F**************************************************************************
* NAME: mem_status
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   memory status:  MEM_BUSY:   install in progress
*                   MEM_READY:  install done
*                   MEM_FORMAT: install done but memory not formated
*----------------------------------------------------------------------------
* PURPOSE: 
*   Return memory status
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
Byte mem_status (void)
{
  if (mem_state == MEM_HDD_IDLE)
  {
    return (MEM_READY);
  }
  if (mem_state == MEM_HDD_ERR_FMT)
  {
    return (MEM_FORMAT);
  }
  else
  {
    return (MEM_BUSY);
  }
}


/*F**************************************************************************
* NAME: mem_check_card
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   OK: card present or on-board memory
*   KO: card not present
*----------------------------------------------------------------------------
* PURPOSE: 
*   Start card status checking
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
bit mem_check_card (void)
{
  switch (mem_state)
  {
    default:
    {
      return OK;
    }
  }
}


/*F**************************************************************************
* NAME: mem_card_select
*----------------------------------------------------------------------------
* PARAMS:
*   force:  - TRUE:  continue selecting MMC1 in case of error
*           - FALSE: select next device in case of error
*
* return:
*----------------------------------------------------------------------------
* PURPOSE:
*   Mass storage memory selection
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*   Call from mass storage routines:
*     - when Test_Unit returns not ready
*     - when exiting download mode for mounting new FAT
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_card_select (bit force)
{
  if (force);
}


/*F**************************************************************************
* NAME: mem_select_next
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*----------------------------------------------------------------------------
* PURPOSE:
*   Select next on-board or card memory
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
void mem_select_next (void)
{
  switch (mem_state)
  {
    case MEM_HDD_IDLE:
    case MEM_HDD_ERR_FMT:
    {
      mem_state = MEM_HDD_INIT;
      break;
    }
  }
}


/*F**************************************************************************
* NAME: mem_select_format
*----------------------------------------------------------------------------
* PARAMS:
*
* return:
*   File system mount status
*----------------------------------------------------------------------------
* PURPOSE:
*   Re-mount memory after format or mass storage update 
*----------------------------------------------------------------------------
* EXAMPLE:
*----------------------------------------------------------------------------
* NOTE:
*----------------------------------------------------------------------------
* REQUIREMENTS:
*****************************************************************************/
bit mem_select_format (void)
{
  gl_mem_tick = MEM_WRITE_TIME;

  switch (mem_state)
  {
    case MEM_HDD_ERR_FMT:
    case MEM_HDD_IDLE:
    {
      while (gl_mem_tick != MEM_TIME_OUT)
      {
        if (File_mount() == OK)             /* check if format ok */
        {
          mem_state = MEM_HDD_IDLE;
          return OK;
        }
      }
      return KO;
    }

    default:
    {
      return KO;
    }
  }
}