www.pudn.com > efs.rar > fs_ftl_device.c

/***********************************************************************
 * fs_ftl_device.c
 *
 * FTL device operation wrappers and counters.
 * Copyright (C) 2006 QUALCOMM, Inc.
 *
 ***********************************************************************/

/*===========================================================================

                        EDIT HISTORY FOR MODULE

  This section contains comments describing changes made to the module.
  Notice that changes are listed in reverse chronological order.

  $Header: //depot/asic/MSMSHARED/services/efs/MSM_EFS.01.02/fs_ftl_device.c#1 $ $DateTime: 2006/10/12 21:20:47 $ $Author: davidb $

when         who   what, where, why
----------   ---   ---------------------------------------------------------
2006-09-12    yg   Create

===========================================================================*/

#include "comdef.h"
#include "fs_ftl_device.h"
#include "assert.h"
#include "flash.h"

#ifdef FEATURE_EFS_FTL

static uint32 ftl_read_color_counters[NUM_FTL_OP_CATEGORIES];
static uint32 ftl_write_color_counters[NUM_FTL_OP_CATEGORIES];
static uint32 ftl_copy_color_counters[NUM_FTL_OP_CATEGORIES];
static uint32 ftl_erase_color_counters[NUM_FTL_OP_CATEGORIES];

static uint32 ftl_read_sector_counters[NUM_FTL_OP_CATEGORIES];
static uint32 ftl_write_sector_counters[NUM_FTL_OP_CATEGORIES];
static uint32 ftl_copy_sector_counters[NUM_FTL_OP_CATEGORIES];

void
ftl_device_reset_counters (void)
{
  int i;

  for (i = 0; i < NUM_FTL_OP_CATEGORIES; ++i)
  {
    ftl_write_color_counters[i] = 0;
    ftl_read_color_counters[i] = 0;
    ftl_copy_color_counters[i] = 0;
    ftl_erase_color_counters[i] = 0;

    ftl_write_sector_counters[i] = 0;
    ftl_read_sector_counters[i] = 0;
    ftl_copy_sector_counters[i] = 0;
  }

}

void
ftl_device_get_stats (ftl_dev_stat_type* op_stats,
                      fs_ftl_op_category category)
{
  ASSERT (category < NUM_FTL_OP_CATEGORIES);

  if (op_stats)
  {
    op_stats->ftl_write_op_count = ftl_write_color_counters[category];
    op_stats->ftl_read_op_count = ftl_read_color_counters[category];
    op_stats->ftl_copy_op_count = ftl_copy_color_counters[category];
    op_stats->ftl_erase_op_count = ftl_erase_color_counters[category];

    op_stats->ftl_write_sector_count = ftl_write_sector_counters[category];
    op_stats->ftl_read_sector_count = ftl_read_sector_counters[category];
    op_stats->ftl_copy_sector_count = ftl_copy_sector_counters[category];
  }

}

int
ftl_device_write_counter (uint32 sector, uint32 count,
                          fs_ftl_op_category category)
{
  ASSERT (category < NUM_FTL_OP_CATEGORIES);
  (void) sector;
  ftl_write_color_counters[category]++;
  ftl_write_sector_counters[category] += count;
  return ftl_write_color_counters[category];
}

int
ftl_device_read_counter (uint32 sector, uint32 count,
                         fs_ftl_op_category category)
{
  ASSERT (category < NUM_FTL_OP_CATEGORIES);
  (void) sector;
  ftl_read_color_counters[category]++;
  ftl_read_sector_counters[category] += count;
  return ftl_read_color_counters[category];
}

uint32
ftl_dev_block_count (fs_device_t dev)
{
  return dev->block_count (dev);
}

uint32
ftl_dev_block_size (fs_device_t dev)
{
  return dev->block_size (dev);
}

uint32
ftl_dev_page_size (fs_device_t dev)
{
  return dev->page_size (dev);
}

int
ftl_dev_bad_block_check (fs_device_t dev, block_id block)
{
  return dev->bad_block_check (dev, block);
}

int
ftl_dev_mark_block_bad (fs_device_t dev, block_id block)
{
  return dev->mark_block_bad (dev, block);
}

int
ftl_dev_write_page (fs_device_t dev, page_id page, void* data)
{
  ftl_write_sector_counters[FTL_OP_FLASH]++;
  ftl_write_color_counters[FTL_OP_FLASH]++;
  return dev->write_page (dev, page, data);
}

int
ftl_dev_erase_block (fs_device_t dev, block_id block)
{
  ftl_erase_color_counters[FTL_OP_FLASH]++;
  return dev->erase_block (dev, block);
}

int
ftl_dev_read_page (fs_device_t dev, page_id page, void* data)
{
  ftl_read_sector_counters[FTL_OP_FLASH]++;
  ftl_read_color_counters[FTL_OP_FLASH]++;
  return dev->read_page (dev, page, data);
}

int
ftl_dev_is_erased (fs_device_t dev, page_id page)
{
  return dev->is_erased (dev, page);
}

int
ftl_dev_copy_page (fs_device_t dev, page_id src_page, page_id dst_page)
{
  ftl_copy_sector_counters[FTL_OP_FLASH]++;
  ftl_copy_color_counters[FTL_OP_FLASH]++;
  return dev->copy_page (dev, src_page, dst_page);
}

int
ftl_dev_get_spare_corrected_bytes (fs_device_t dev)
{
  return dev->get_spare_corrected_bytes (dev);
}

int
ftl_dev_write_page_and_udata (fs_device_t dev, page_id page, void* data,
                              void* spare_data, uint32 len)
{
  ftl_write_sector_counters[FTL_OP_FLASH]++;
  ftl_write_color_counters[FTL_OP_FLASH]++;
  return dev->write_page_and_udata (dev, page, data, spare_data, len);
}

int
ftl_dev_read_spare_udata (fs_device_t dev, page_id page,
                          void* spare_ptr, uint32 len)
{
  return dev->read_spare_udata (dev, page, spare_ptr, len);
}

#else
extern int __dont_complain_about_empty_file;
#endif  /*   FEATURE_EFS_FTL  */