filesys.c

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

#else
          song_info->extent_lba = (X_array[song_info->extent_index].data.xfile.lba_msp << 16)
                                + X_array[song_info->extent_index].data.xfile.lba_lsp;
#endif
          return S_OK;
        }
        song_info->extent_size = X_array[song_info->extent_index].data.xfile.size;
      }
      while (diff > song_info->extent_size);

      song_info->extent_position = diff;
      song_info->position = offset;
      if (song_info->type != TRACK_CDDA)
            #if HAVE_EXTERNAL_XARRAY
        song_info->extent_lba = X_array[song_info->extent_index].data.xfile.lba;
#else
      song_info->extent_lba = (X_array[song_info->extent_index].data.xfile.lba_msp << 16)
                            + X_array[song_info->extent_index].data.xfile.lba_lsp;
#endif
      return S_OK;
    }
    else
    {
      song_info->position = offset;
      song_info->extent_position += diff;
      if (song_info->type != TRACK_CDDA)
            #if HAVE_EXTERNAL_XARRAY
        song_info->extent_lba = X_array[song_info->extent_index].data.xfile.lba;
#else
      song_info->extent_lba = (X_array[song_info->extent_index].data.xfile.lba_msp << 16)
                            + X_array[song_info->extent_index].data.xfile.lba_lsp;
#endif
      return S_OK;
    }
  }
  else // offset<song_info->position
  {
    if (1) //offset<=(song_info->position/2))   // go from beginning
    {
      song_info->position = 0;
      song_info->extent_index = song_info->xid;
      song_info->extent_position = 0;
      if (song_info->type != TRACK_CDDA)
        song_info->extent_size = X_array[song_info->extent_index].data.xfile.size;
      while (offset > song_info->position)
      {
        if (offset < (song_info->position + song_info->extent_size))
        {
          song_info->extent_position = offset - song_info->position;
          song_info->position = offset;
          if (song_info->type != TRACK_CDDA)
                    #if HAVE_EXTERNAL_XARRAY
            song_info->extent_lba = X_array[song_info->extent_index].data.xfile.lba;
#else
          song_info->extent_lba = (X_array[song_info->extent_index].data.xfile.lba_msp << 16)
                                + X_array[song_info->extent_index].data.xfile.lba_lsp;
#endif
          return S_OK;
        }
        song_info->position += song_info->extent_size;
        if (song_info->type == TRACK_CDDA)
          song_info->extent_index = 0;
        else
          song_info->extent_index = X_array[song_info->extent_index].data.xfile.next_extent \
                                  & 0x7FFF ;  // O.T. mask off UDF simple file flag
        if (!song_info->extent_index)
        {
          //memcpy( song_info, &oldsi,sizeof(t_SongInfos));
          filesys_restore_si(song_info);
          return E_FAIL;   // seek stopped by missing extent ;
        }
        song_info->extent_size = X_array[song_info->extent_index].data.xfile.size;
      }
      if (song_info->type != TRACK_CDDA)
            #if HAVE_EXTERNAL_XARRAY
        song_info->extent_lba = X_array[song_info->extent_index].data.xfile.lba;
#else
      song_info->extent_lba = (X_array[song_info->extent_index].data.xfile.lba_msp << 16)
                            + X_array[song_info->extent_index].data.xfile.lba_lsp;
#endif
      return S_OK;
    }
    else    // go backward from current extent
    {
    }
  }
  if (song_info->type != TRACK_CDDA)
    #if HAVE_EXTERNAL_XARRAY
    song_info->extent_lba = X_array[song_info->extent_index].data.xfile.lba;
#else
  song_info->extent_lba = (X_array[song_info->extent_index].data.xfile.lba_msp << 16)
                        + X_array[song_info->extent_index].data.xfile.lba_lsp;
#endif

  return S_OK;
}


// IO_READ is used only by FILESYS task
GRESULT IO_Read(uint32 flags)
{
  extern t_fsm controller_CD_data_for_TASK_fsm;
#if (0 != HAVE_USB)
  extern t_fsm controller_USB_data_for_TASK_fsm;
#endif
#if (0 != HAVE_SDC)
  extern t_fsm controller_SDC_data_for_TASK_fsm;
#endif /* HAVE_SDC */

  event_set_req_filesys(READY);
  event_out_shedule(FILESYS_REQ_EVENT);

  do
  {
    OSAL_wait_thread(OSAL_THREAD_FilesysTask);

    //event_in_shedule(FILESYS_CMD_EVENT); 
    // look who woked us up
    if (filesys_inevent & FILESYS_DATA_READY_EVENT)
    {
      //DISABLE_INTERRUPTS();
      event_disable_scheduling();
      filesys_inevent &= ~FILESYS_DATA_READY_EVENT;
      event_enable_scheduling();
      //ENABLE_INTERRUPTS();

      switch (FS_XFER_command_event.did)
      {
      case DEV_CD_ID:
        if (controller_CD_data_for_TASK_fsm.state == FSM_ERROR)
          return E_FAIL;
        else
          return S_OK;
#if (0 != HAVE_USB)
      case DEV_USB_ID:
        if (controller_USB_data_for_TASK_fsm.state == FSM_ERROR)
        {
          if(controller_USB_data_for_TASK_fsm.error_reason == E_USB_FORCED_UNPLUG)
            return E_FORCED_UNPLUG;
          else
            return E_FAIL;
        }
        else
          return S_OK;
#endif
#if (0 != HAVE_SDC)
      case DEV_SDC_ID:
        if (FSM_ERROR == controller_SDC_data_for_TASK_fsm.state)
        {  
          if(controller_SDC_data_for_TASK_fsm.error_reason == E_FORCED_UNPLUG)
            return E_FORCED_UNPLUG;
          else
            return E_FAIL;
        }
        else
          return S_OK;
#endif /* HAVE_SDC */
      }
    }
    else
    {
      filesys_process_preevents();
      //if ((filesys_inevent & FILESYS_STOP_COMMAND_EVENT)) // && (fs_stop_params.flags & FS_STOP_MOUNT))
      if(filesys_fsm_stop.state == FSM_RUN)
      {
        event_in_shedule(FILESYS_CMD_EVENT);
        event_in_clear(FILESYS_CMD_EVENT);
        filesys_outevent |= FS_MOUNT_RESUME;
        return E_FORCED_UNPLUG;
      }
      
      /*else
      {
        filesys_process_preevents();
        event_in_clear(FILESYS_CMD_EVENT);
      }*/
      
      //filesys_outevent |= FS_MOUNT_RESUME;
    }
  }
  while (1);
}

#if (HAVE_FSHRINK==1)
uint32 filesys_shrink_name(int16 mode,uint8 *shrbuf, uint16 len)
{
  uint8 *front,*end,*misc;
  int xlen = 0,p;

  if((mode <= 0) || (mode >= len))
    return 0;

  front = shrbuf;
  end = shrbuf + len - 1;

  while(xlen<mode)
  {
    p = 0;
    misc = front;
    if(*misc < 128)
    {
      p = 1;
      misc++;
    }
    else
    {
    misc++;
    p = 1;
    while( ((*misc) & 0xc0) == 0x80)
    {
      p++;
      misc++;
    }

    if(p > 4)
      break;
    }
    if((xlen + p) <= mode)
    {
      front = misc;
      xlen += p;
    }
    else
        break;

    p = 0;
    misc = end;
    if(*misc < 128)
    {
      p = 1;
      misc--;
    }
    else
    {
      misc--;
      p = 1;
      while( ((*misc) & 0xc0) == 0x80)
      {
        p++;
        misc--;
      }

      p++;
      misc--;

      if( p> 4)
        break;
    }

    if((xlen + p) <= mode)
    {
      end = misc;
      xlen += p;
    }
    else
        break;
  }

//  if(front>end)
//    return 0;

  misc = shrbuf + len ;
  end++;
  while(end < misc)
  {
    *front = *end;
    front++;
    end++;
  }

  return xlen;
}

GRESULT filesys_next_shrink_mode(void)
{
  int16 dir_sm0 = dir_shrink_mode;
  int16 file_sm0 = file_shrink_mode;
  int i, j, len, mode, newlen, diff, first,offs;


  uint8 *iptr, *lastptr, *name, *pptr, *nptr;
  uint8 shrbuf[256];
  int shrinked = 0;    // number of freed bytes

  if(dir_shrink_mode <= 0)
    dir_shrink_mode = DIR_SHRINK_MODE_MIN + 6 * DIR_SHRINK_MODE_STEP;

  if(dir_shrink_mode > DIR_SHRINK_MODE_MIN)
  {
    dir_shrink_mode -= DIR_SHRINK_MODE_STEP;
    if(dir_shrink_mode < DIR_SHRINK_MODE_MIN)
      dir_shrink_mode = DIR_SHRINK_MODE_MIN;
  }
  else
  {
    if(file_shrink_mode <= 0)
      file_shrink_mode = FILE_SHRINK_MODE_MIN + 6 * FILE_SHRINK_MODE_STEP;

    if(file_shrink_mode > FILE_SHRINK_MODE_MIN)
    {
      file_shrink_mode -= FILE_SHRINK_MODE_STEP;
      if(file_shrink_mode < FILE_SHRINK_MODE_MIN)
        file_shrink_mode = FILE_SHRINK_MODE_MIN;
    }

  }

  if((dir_sm0 == dir_shrink_mode) && (file_sm0 == file_shrink_mode))
    return E_FAIL;  // no shrinking is possible

  lastptr = NULL;

  first = XAR_VolumeNode(2);
  if(first < 0)
    return first;

  for(i = X_NEXTFREE_ITEM - 1; i > first; i--)
  {
    name = filesys_get_name(i);
    if(name==NULL)
      continue;
    len = filesys_name_length(i);
#if HAVE_EXTERNAL_XARRAY
    pptr = name - (1 & len);
#else
    pptr = name;
#endif

    if(lastptr==NULL)
      lastptr = pptr; // latest string chunk

    if((XAR_XNodeType(i) == DATA_FILE)||(XAR_NodeType(i)==XTYPE_VOLUME))
        continue;

    if(XAR_NodeType(i)==XTYPE_DATA_FILE)
      mode = file_shrink_mode;
    else
      mode = dir_shrink_mode;

    memcpy(shrbuf, name, len);  // copy name to temporary buffer

    newlen = filesys_shrink_name(mode, shrbuf, len);
    if(newlen)
    {

      X_array[i].nodetype.i |= XFLAG_NAME_TRUNCATED;
      name += (len - newlen);

#if HAVE_EXTERNAL_XARRAY
      nptr = name - (1 & newlen);
#else
      nptr = name;
#endif
      filesys_update_name_length(i, newlen);

#if HAVE_EXTERNAL_XARRAY
      // copy to SDRAM with padding 0 if newlen is odd
      memcpy16(name, shrbuf, newlen);
#else
      memcpy(name, shrbuf, newlen);
#endif
      diff = nptr - pptr;

      shrinked += diff;

      if((diff) && (lastptr != pptr))
      {
      // shift strings up
#if HAVE_EXTERNAL_XARRAY
        iptr = nptr - 2;
        do
        {
          *(uint16*)iptr = *(uint16*)(iptr - diff);
            iptr -= 2;
        }while (iptr >= (lastptr + diff));
#else
        iptr = nptr-1;
        do
        {
          *iptr = *(iptr - diff);
          iptr--;
        }while (iptr >= (lastptr + diff));
#endif

        for(j = i + 1; j < X_NEXTFREE_ITEM; j++)
        {
          switch( XAR_NodeType(j))
          {
          case XTYPE_VOLUME:
#if(HAVE_EXTERNAL_XARRAY == 1)
            offs = X_array[j].data.xvolume.name + ( X_array[j].nodetype.b[1] << 16); 
            if(offs != 0xffffff)
            {
                offs -= diff;
                X_array[j].data.xvolume.name = offs & 0xffff;
                X_array[j].nodetype.i = X_array[j].nodetype.b[0] | ((offs&0xff0000)>>8);
                
            }
            
#else         
            if(X_array[j].data.xvolume.name != 0xffff)
              X_array[j].data.xvolume.name -= diff;
#endif
            break;
          case XTYPE_DIRECTORY:
#if(HAVE_EXTERNAL_XARRAY == 1)
            offs = X_array[j].data.xdir.name + ( X_array[j].nodetype.b[1] << 16); 
            if(offs != 0xffffff)
            {
                offs -= diff;
                X_array[j].data.xdir.name = offs & 0xffff;
                X_array[j].nodetype.i = X_array[j].nodetype.b[0] | ((offs&0xff0000)>>8);
                
            }
            
#else         
            if(X_array[j].data.xdir.name != 0xffff)
              X_array[j].data.xdir.name -= diff;
#endif         
            break;
             
          case XTYPE_DATA_FILE:
#if(HAVE_EXTERNAL_XARRAY == 1)
            offs = X_array[j].data.xfile.name + ( X_array[j].nodetype.b[1] << 16); 
            if(offs != 0xffffff)
            {
                offs -= diff;
                X_array[j].data.xfile.name = offs & 0xffff;
                X_array[j].nodetype.i = X_array[j].nodetype.b[0] | ((offs&0xff0000)>>8);
                
            }
            
#else         
              if(X_array[j].data.xfile.name != 0xffff)
              X_array[j].data.xfile.name -= diff;
#endif          
      
            break;
          default:
            break;
          }

//          if(*(PACKED uint16*)nptr != 0xffff)
//          {
//            *(PACKED uint16*)nptr -= diff;  // update string pointer
//          }
        }
      }

      lastptr += diff;
#if HAVE_EXTERNAL_XARRAY      
      writeSDRAM32((int16*)&X_POOL_TOP,X_POOL_TOP- diff);
#else      
      X_POOL_TOP -= diff;
#endif      
    }
  }

  return shrinked;
}
#endif