⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 libdrive.lst

📁 威望公司MP3 + USB MCU 的参考软件
💻 LST
📖 第 1 页 / 共 4 页
字号:
 444   2      //              buffer = buffer;
 445   2                      return FS_SCAN_FAIL;
 446   2      //        drv->FatRead = NULL;
 447   2      //        drv->FatWrite = NULL;
 448   2              }
 449   1          else if(!memcomp(buffer + 0x36, "FAT16", 5))
 450   1              {
 451   2      //              buffer = buffer;
 452   2                      drv->Flag.Fat32 = 0;
 453   2      //        drv->FatRead = ReadFat16;
 454   2      //        drv->FatWrite = WriteFat16;
 455   2              }
 456   1          else if(!memcomp(buffer + 0x52, "FAT32", 5))    
 457   1              {
 458   2      //              buffer = buffer;        
 459   2                      drv->Flag.Fat32 = 1;
 460   2      //        drv->FatRead = ReadFat32;
 461   2      //        drv->FatWrite = WriteFat32;
 462   2              }
 463   1          else
 464   1              {
 465   2                      //OsTempMemRelease((DWORD)buffer);
 466   2              return FS_SCAN_FAIL;
 467   2              }
 468   1              
 469   1              //OsTempMemRelease((DWORD)buffer);
 470   1          if(BootRecordRead(drv, 0) != FS_SUCCEED)     // parsing the partition boot sector
 471   1              return DRIVE_ACCESS_FAIL;
C51 COMPILER V8.01   LIBDRIVE                                                              04/17/2008 09:46:00 PAGE 9   

 472   1              
 473   1          //DriveCounter ++;                                  // increase to next drive
 474   1          
 475   1      //    drv->Partition = 0;              
 476   1          drv->Flag.Present = 1;
 477   1          
 478   1          return FS_SUCCEED;
 479   1      }
 480          #endif
 481          
 482          // scan the partition table of the device.
 483          // note that only HD support multiple partition
 484          // and the maximum number is MAX_PARTITION_NUM
 485          static BYTE PartitionScan(DRIVE *drv)
 486          {
 487   1      #if 0
                      PARTITION *par;
                      BYTE * buffer;//DWORD buffer;
                      //BYTE dev;
                      UDWORD work_lba, base_lba, temp_lba;
                      BYTE flag;//SDWORD flag;
                      //UDWORD parCounter;
              
                      work_lba = 0;                     
                      base_lba = 0;
                      //parCounter = 0;        // use to count the partition in a device
                      //dev = drv->DevID;
              
                      buffer = DBUF;    
              
                      //Get the MBR, MBR_LBA=0,获取存储设备的主引导记录
                      if(DriveRead(drv, (BYTE *)buffer, work_lba, 0) != FS_SUCCEED){
                              return 0;
                      }
                      //判断MBR的结束标志0x55aa是否正确。
                      if(*(WORD *)(buffer + 0x1fe) != 0x55aa){
                          return 0;
                      }
              
                      //PARTITION Table的起始地址
                      par = (PARTITION *)(buffer + PARTITION_OFFSET);
                      //while(1)      {            
                              flag = 1;            // preset to supported flag type
                              //确定分区类型,确定相应的读写函数
                              switch(par->Type){
                              #if 0   
                                  case 1:                        // FAT12 type
                                      //drv->FatRead = NULL;
                                      //drv->FatWrite = NULL;
                                      drv->Flag.Fat32 = 0;
                                       UartOutText("FAT12 \r\n");     
                                      break;
                               #endif   
                                  case 4: case 6: case 14:    // FAT16 type
                                      //drv->FatRead = ReadFat16;
                                      //drv->FatWrite = WriteFat16;
                                      drv->Flag.Fat32 = 0;
                                       UartOutText("FAT16 \r\n");        
                                      break;
                                          
                                  case 11: case 12:            // FAT32 type
                                      //drv->FatRead = ReadFat32;
C51 COMPILER V8.01   LIBDRIVE                                                              04/17/2008 09:46:00 PAGE 10  

                                      //drv->FatWrite = WriteFat32;
                                      drv->Flag.Fat32 = 1;
                                       UartOutText("FAT32 \r\n");                                     
                                      break;
              #if 0
                              //扩展分区                
                                  case 5: case 15:               // DOS extended type
                                       UartOutText("DOS extended type \r\n");                             
                                       
                                      //// IF the extended partition need to be last ?
                                      work_lba = base_lba + LoadAlien32(&par->Start);
                                  
                                      // if base_lba zero mean this extended partition is the first
                                      // extended partition, then it would be the base partition of
                                      // the following extended partitions
                                      if(!base_lba)    base_lba = work_lba;
                                          
                                      DriveRead(drv, (BYTE *)buffer, work_lba);
              
                                      // if not formated sector, then ending the scanning
                                      if(*((WORD *)(buffer + 0x1fe)) != 0x55aa){
                                          return parCounter;
                                       }
                                          
                                      // reset the partition table point
                                      par = (PARTITION *)(buffer + PARTITION_OFFSET - 0x10);  
                                      flag = 0;
                                      break;
              #endif              
                                  default:                    // not support type        
                                      flag = 0;
                                      }
                                      
                              if(flag){     
                              #if 0   
                                 drv->wMp3Idx = 0;    
                                 if((par->res1==MP3_IDX_FLAG1)&&(par->res2==MP3_IDX_FLAG2)){
                                         drv->wMp3Idx = (par->res3<<8)|(par->res4);
                                 }
                              #endif  
                                  // parsing the partition boot sector,解析分区的起始扇区。        
                                  //读取分析系统引导记录DBR,DBR_LBA=MBR.PT[0].RelativeSectors
                                  LoadAlien32(&par->Start, &temp_lba); 
                                  temp_lba += work_lba;// + LoadAlien32(&par->Start);            
                                  if(BootRecordRead(drv, temp_lba) != FS_SUCCEED){
                                      return 0;//return parCounter;
                                  }
                                      
                                  // set and increase the partition counter
                                  //drv->Partition = parCounter;
                                  //parCounter ++;
                                      
                                  // increase to next drive
                                  //drv->Flag.Present = 1;
                                  //DriveCounter ++;
                                  //drv ++;
                                      
                                  // copy the device point from next drive
                                  //if(!drv->Flag.Present)        drv->DevID = dev;
                                  //if(parCounter >= MAX_PARTITION_NUM)       return parCounter;
                                  
                              }
C51 COMPILER V8.01   LIBDRIVE                                                              04/17/2008 09:46:00 PAGE 11  

                              // only HD support multiple partition
                              return 1;//return parCounter;
                      //}
              #else
 600   1              PARTITION * data par;
 601   1              BYTE * data buffer;//DWORD buffer;
 602   1              UDWORD temp_lba;
 603   1      
 604   1              buffer = DBUF;    
 605   1              
 606   1              UartOutText("\rPartitionScan(), before DriveRead()\r\n\r\n\r\n");
 607   1      
 608   1              //Get the MBR, MBR_LBA=0,获取存储设备的主引导记录
 609   1              DriveRead((BYTE *)buffer, 0, 0);
 610   1              //UartOutText1((BYTE *)buffer, 512);
 611   1      
 612   1              //判断MBR的结束标志0x55aa是否正确。
 613   1              if(*(WORD *)(buffer + 0x1fe) != 0x55aa){
 614   2                  return 0;
 615   2              }
 616   1      
 617   1              //PARTITION Table的起始地址
 618   1              par = (PARTITION *)(buffer + PARTITION_OFFSET);
 619   1      
 620   1      #if 0
                      {
                              BYTE i;
              
                              for(i=0; i<4; i++){
                                      UartOutText("\r\nPartition Info: \r\n");
                                      UartOutText("-I-: par->Active 0x"); UartOutValue(par->Active, 2);       
                                      UartOutText("-I-: par->Size 0x"); UartOutValue(par->Size, 8);   
                                      UartOutText("-I-: par->Start 0x"); UartOutValue(par->Start, 8);                         
                                      UartOutText("-I-: par->Type 0x"); UartOutValue(par->Type, 2);
                                      
                                      par += sizeof(PARTITION);
                              }
              
              
                              par = (PARTITION *)(buffer + PARTITION_OFFSET);
                      }
              #endif
 638   1      
 639   1              //确定分区类型,确定相应的读写函数
 640   1              switch(par->Type){
 641   2                      case 4: case 6: case 14:    // FAT16 type
 642   2                              drv->Flag.Fat32 = 0;
 643   2                              //LoadAlien32(&par->Start, &temp_lba); 
 644   2                              UartOutText("FAT16 \r\n");         
 645   2                              break;
 646   2                              
 647   2                      case 11: case 12://case 1:            // FAT32 type
 648   2                              drv->Flag.Fat32 = 1;
 649   2                              UartOutText("FAT32 \r\n");                                      
 650   2                              //LoadAlien32(&par->Start, &temp_lba); 
 651   2                              break;
 652   2      
 653   2                      default:                    // not support type
 654   2                              UartOutText("part type"); UartOutValue(par->Type, 2);
 655   2                              //drv->Flag.Fat32 = 1;
 656   2                              //temp_lba = 0x00;
 657   2                              //break; 
C51 COMPILER V8.01   LIBDRIVE                                                              04/17/2008 09:46:00 PAGE 12  

 658   2                              return 0;
 659   2              }
 660   1                              
 661   1              // parsing the partition boot sector,解析分区的起始扇区。        
 662   1              //读取分析系统引导记录DBR,DBR_LBA=MBR.PT[0].RelativeSectors
 663   1              
 664   1              LoadAlien32(&par->Start, &temp_lba); 
 665   1              if(BootRecordRead(drv, temp_lba) != FS_SUCCEED){
 666   2                      return 0;//return parCounter;
 667   2              }
 668   1      
 669   1              // only HD support multiple partition
 670   1              return 1;//return parCounter;
 671   1      #endif
 672   1              
 673   1      }
 674          
 675          //This function will startup a read operation at address lba, only one sector each time 
 676          BYTE DriveRead(BYTE* buffer, UDWORD lba, BYTE offset)
 677          {

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -