cddevice.c

本程序为ST公司开发的源代码

/**************************************************
 *
 * cddevice.c
 *
 * CVS ID:   $Id: cddevice.c,v 1.26 2007/01/24 16:45:05 trubac Exp $
 * Author:   Ondrej Trubac [OT] - STM
 * Date:     $Date: 2007/01/24 16:45:05 $
 * Revision: $Revision: 1.26 $
 *
 * Description:
 *
 *
 ***************************************************
 *
 * COPYRIGHT (C) ST Microelectronics  2005
 *            All Rights Reserved
 *
 ***************************************************
 *
 * STM CVS Log:
 *
 * $Log: cddevice.c,v $
 * Revision 1.26  2007/01/24 16:45:05  trubac
 * Filesystem supports 15000 files
 * String reverse page offset is in nodetype.b[1]
 *
 * Revision 1.25  2007/01/18 15:01:31  trubac
 * Preparation for 15000 files
 *
 * Revision 1.24  2006/11/25 08:13:26  belardi
 * Ununsed function removal to free code space
 *
 * Revision 1.23  2006/10/20 15:08:36  longauer
 * VAT works; + code reorganization
 *
 * Revision 1.22  2006/10/20 12:32:08  belardi
 * Changed cast from uint16* to int16* to remove compiler warning
 *
 * Revision 1.21  2006/10/18 08:33:36  trubac
 * fix of CD_set_bd_type with no external memory
 *
 * Revision 1.20  2006/10/17 09:57:07  trubac
 * new TOC info comparing
 *
 * Revision 1.19  2006/10/05 07:27:45  trubac
 * Implementing TOC info at the end of string pool
 *
 * Revision 1.18  2006/09/15 19:44:33  belardi
 * Merged the m8_cav2_cm80506_cs3563.
 * - removed xtoc from XItem, created temporary XTOC variable
 * - introduced APM cddb algorithm
 *
 *
 ***************************************************/
#include <stdio.h>
#include "gendef.h"
#include "accordoptypes.h"    //"aptypes.h"
#include "apdevsys.h"
#include "debug.h"
#include "cddevice.h"
#include "xfile.h"
#include "toc.h"
#ifdef APM_PICKUP
#include "crc32.h"
#endif

t_XBTOC *XB_TOC;  //todo move is at end of string pool

extern TOC_DATA_STRUCT TOC_data;

GRESULT CD_SetDeviceId(DUID id)
{
  CD_DeviceDescriptor *cdd;

  cdd = (CD_DeviceDescriptor *) SYS_DeviceDescriptor(id);
  cdd->did = id;

  return S_OK;
}

t_XItem CD_LastSession(t_bool set_invalid_flag)
{
  t_XItem tr;

  for (tr = XAR_GetMaxTrack(); tr >= XAR_GetMinTrack(); tr--)
  {
    if ((XAR_XNodeType(tr) == TRACK_ROM)
     && !(X_array[tr].data.xtrack.flags & XTR_FLAG_FSINVALID))
    {
      if (FALSE != set_invalid_flag)
      {
        X_array[tr].data.xtrack.flags |= XTR_FLAG_FSINVALID;
      }
      return tr;
    }
  }
  return XITEM_INVALID;
}

int32 CD_LastSessionLBA(void)
{
  t_XItem tr;

  if (!(XB_TOC->CDinfo & FIRST_TOC_READABLE))
  {
    return CDT_2SEC;
  }
  tr = CD_LastSession(FALSE);
  if (tr != XITEM_INVALID)
  {
      return XAR_GetFileLBA(tr);
  }
  return -1;
}

#if (HAVE_UDF==1)
int32 CD_LastSessionLBAEndAddress(void)
{
  t_XItem tr;

  if (XB_TOC->CDinfo & FIRST_TOC_READABLE)
  {
    tr = CD_LastSession(FALSE);
    if (tr != XITEM_INVALID)
    {
        return XAR_GetFileLBA(tr) + XAR_FileTotalSize(tr) - 1;
    }
  }
  return -1;
}
#endif //HAVE_UDF


int cddb_sum(int n)
{
  int ret;

  /* For backward compatibility this algorithm must not change */

  ret = 0;

  while (n > 0)
  {
    ret = ret + (n % 10);
    n = n / 10;
  }

  return ret;
}

uint32 cddb_discid(void)
{
  int i, t = 0;
  int n = 0;

  /* For backward compatibility this algorithm must not change */

  for (i = toc_get_min_track(); i <= toc_get_max_track(); i++)
  {
    n += cddb_sum((toc_get_track_min(i) * 60) + toc_get_track_sec(i));
  }

  t = ((toc_get_leadout_min() * 60) + toc_get_leadout_sec()) - \
  ((toc_get_track_min(toc_get_min_track()) * 60) + toc_get_track_sec(toc_get_min_track()));

  return ((n % 0xff) << 24 | t << 8 | toc_get_max_track());
}

#ifdef APM_PICKUP
uint32 crc32_discid(void)
{
  int i;
  uint32 crc = CRC32_START_VALUE;

  /* For backward compatibility this algorithm must not change */

  for (i = toc_get_min_track(); i <= toc_get_max_track(); i++)
  {
    crc = CRC32_Calc(crc, i);
    crc = CRC32_Calc(crc, toc_get_track_min(i));
    crc = CRC32_Calc(crc, toc_get_track_sec(i));
    crc = CRC32_Calc(crc, toc_get_track_frame(i));
  }
  crc = CRC32_Calc(crc, toc_get_leadout_min());
  crc = CRC32_Calc(crc, toc_get_leadout_sec());
  crc = CRC32_Calc(crc, toc_get_leadout_frame());

  return crc;
}
#endif

#ifdef APM_PICKUP // [RB] unused in STM build
void CD_DiscardDISCID(void)
{
  if ((XAR_NodeType(0) == XTYPE_VOLUME) && (X_array[0].data.xvolume.fs_type == FS_TOC))
  {
    XB_TOC->cddb_discid = 0;
#ifdef APM_PICKUP
    XB_TOC->crc32_discid = 0;
#endif
  }
}
#endif

void CD_UpdateDISCID(void)
{
  
#if (HAVE_EXTERNAL_XARRAY==1)      	
    writeSDRAM32((int16*)&XB_TOC->cddb_discid,XB_TOC->toc_cddb_discid);
    writeSDRAM32((int16*)&XB_TOC->crc32_discid,XB_TOC->toc_crc32_discid);
#else
    XB_TOC->cddb_discid=XB_TOC->toc_cddb_discid;
    XB_TOC->crc32_discid=XB_TOC->toc_crc32_discid;
#endif
	
}

void CD_UpdateTOCDISCID(void)
{
#if (HAVE_EXTERNAL_XARRAY==1)
  writeSDRAM32((int16*)&XB_TOC->toc_cddb_discid,cddb_discid());
#ifdef APM_PICKUP  
  writeSDRAM32((int16*)&XB_TOC->toc_crc32_discid,crc32_discid());
#endif  

#else

  XB_TOC->toc_cddb_discid = cddb_discid();
#ifdef APM_PICKUP  
  XB_TOC->toc_crc32_discid = crc32_discid();
#endif

#endif  
}

GRESULT CD_IsDISCIDValid(void)
{
    // check discid and CRC in XB_TOC
  if (XB_TOC->cddb_discid == XB_TOC->toc_cddb_discid)
  {
#ifdef APM_PICKUP
	if(XB_TOC->crc32_discid != XB_TOC->toc_crc32_discid)
		return S_FALSE;
#endif    
	return S_TRUE;
  }

  return S_FALSE;  
}

#define IS_NEXT_TRACK_IN_NEW_SESSION(x)   (toc_is_track_startsession((x)+1))
#define IS_TRACK_IN_FIRST_SESSION(x)      (TOC_data.max_track_in_1_toc >= (x))

/******************************************************************************/
/* Function:  get_track_endtime                                               */
/*                                                                            */
/*! \brief
 *  \param    t_track track
 *  \return   t_time
 *  \remark
 */
/******************************************************************************/

#define DEBUG_PAUSE_AREA CDT_PAUSE

// TODO set DEBUG_PAUSE_AREA to 0 in final release
// used today to debug FBW in pause area

t_time get_track_endtime(t_track track)
{
  if (track >= toc_get_max_track())
  {
    return toc_get_leadout_time();
  }
  else
  {
    if (track < toc_get_min_track())
    {
      track = toc_get_min_track();
    }

    if (IS_NEXT_TRACK_IN_NEW_SESSION(track))
    {
      if (IS_TRACK_IN_FIRST_SESSION(track))
      {
        return (toc_get_track_time(track + 1) - CDT_PAUSE_FIRST_LEADOUT);
      }
      else
      {
        return (toc_get_track_time(track + 1) - CDT_PAUSE_LEADOUT);
      }
    }
    else
    {
#ifdef TRACK_ENDTIME_INCLUDE_PAUSE
      return (toc_get_track_time(track + 1));
#else
      return (toc_get_track_time(track + 1) - CDT_PAUSE + DEBUG_PAUSE_AREA);
#endif
    }
  }
}


void CD_UpdateTracksInfo(void)
{

  int trk, trkmin, trkmax;
  t_XNode node;

  trkmin = toc_get_min_track();
  trkmax = toc_get_max_track();
  node.nodetype.i = UNUSED_NODE;
  node.data.xtrack.name = 0xffff;
  //node.data.xtrack.min_track = trkmin;
  //node.data.xtrack.max_track = trkmax;  
#if (HAVE_EXTERNAL_XARRAY==1)
  node.nodetype.b[1] = 0xff;
  writeSDRAM32((int16*)&XB_TOC->leadoutlba,toc_get_leadout_time());
#else
  XB_TOC->leadoutlba = toc_get_leadout_time();
#endif
  //*(uint16*)&XB_TOC->min_track = trkmin;	// strange way in which SDRAM works
  XB_TOC->min_track = trkmin;
  //*(uint16*)&XB_TOC->max_track = trkmax;
  XB_TOC->max_track = trkmax;
  //*(uint16*)&XB_TOC->CDinfo = CDinfo;
  XB_TOC->CDinfo = CDinfo;
  
  
  for (trk = 1; trk < trkmin; trk++)
  {
    XAR_WriteNode(trk,&node);
    //X_array[0].data.xvolume.nodes_num++;
  }
  
  for (trk = trkmin ; trk <= trkmax; trk++)
  {
    if (toc_is_track_rom(trk))
    {
      node.nodetype.i = TRACK_ROM;
    }
    else
    {
      node.nodetype.i = TRACK_CDDA;
    }
    node.data.xtrack.lba = toc_get_track_time(trk);
    node.data.xtrack.size = get_track_endtime(trk) - node.data.xtrack.lba;
    node.data.xtrack.trtype = toc_get_track_type(trk);
    node.data.xtrack.flags = toc_is_track_preemphases(trk) ? 0x01 : 0;
    node.data.xtrack.flags |= toc_is_track_startsession(trk) ? 0x02 : 0;

    XAR_WriteNode(trk, &node);
    
  }
  
}

t_XItem CD_track_from_time(int32 lba)
{
  int high, low;
  int i;
  int32 compare;

  lba += CDT_2SEC;

  for (low = XAR_GetMinTrack(), high = XAR_GetMaxTrack() + 1; (high - low) > 1;)
  {
    i = ((high + low) >> 1);

    compare = (int32)XAR_GetFileLBA(i) - (int32)lba;
    if (0 == compare)
    {
      return (t_XItem) i;
    }
    else if (compare > 0)
    {
      high = i;
    }
    else
    {
      low = i;
    }
  }
  return (t_XItem) low;
}

/******************************************************************************/
/* Function:  CD_get_bd_type                                                  */
/*                                                                            */
/*! \brief    get the sector type for the parameter
 *  \param    target_lba the LBA to search in the TOC
 *  \return   one of the Block Decoder initiaization values
 *  \remark   Only returns 0x02, 0x05 or 0x08
 */
/******************************************************************************/
uint8 CD_get_bd_type(t_XItem track)
{
  if (XAR_XNodeType(track) == TRACK_ROM)
  {
    if (X_array[track].data.xtrack.trtype == 0x20)
    {
      return 0x05; // CDROM XA (mode 2) form 1
    }
    return 0x02; // CDROM mode 1
  }
  return 0x08; // CDDA
}

void update_cdinfo(void)
{
  t_XItem trk;
  
  uint16 cdinfo = XB_TOC->CDinfo & (~(HAVE_DATA_TRACK | HAVE_AUDIO_TRACK));
  for (trk = XAR_GetMinTrack(); trk <= XAR_GetMaxTrack(); trk++)
  {
    if (XAR_XNodeType(trk) == TRACK_ROM)
    {
      cdinfo |= HAVE_DATA_TRACK;
    }
    else
    {
      cdinfo |= HAVE_AUDIO_TRACK;
    }
  }

  XB_TOC->CDinfo = cdinfo;
}

uint8 CD_set_bd_type(t_XItem track, uint8 type)
{
 t_XNode node;

 node = X_array[track];
 
  switch (type)
  {
  case 0x02:
    //XAR_ChangeXNodeType(track, TRACK_ROM);
    node.nodetype.i &= ~0xFC;
    node.nodetype.i |= (0xFC & TRACK_ROM);
    node.data.xtrack.trtype = 0x00;
    break;
  case 0x05:
    //XAR_ChangeXNodeType(track, TRACK_ROM);
    //X_array[track].data.xtrack.trtype = 0x20;
    node.nodetype.i &= ~0xFC;
    node.nodetype.i |= (0xFC & TRACK_ROM);
    node.data.xtrack.trtype = 0x20;
    break;
  case 0x08:
  default:
    //XAR_ChangeXNodeType(track, TRACK_CDDA);
    node.nodetype.i &= ~0xFC;
    node.nodetype.i |= (0xFC & TRACK_CDDA);
    node.data.xtrack.trtype = 0x00;
    break;
  }

  XAR_WriteNode(track,&node);

  update_cdinfo();
  return type;
}