bulk_only.lst

基于MCU的U盘源码

 130                                                                  0,//write enabled
 131                                                                  0,0,0,0,//reserved
 132                                                                  0x1c,0x06,0,0x05,0,0,0,0
 133          
 134          };
 135          unsigned char B_Mode_Sense_ZERO[]={0x00,0x06,//Mode Data Length
 136                                                                  0x00,   //Medium Type Code
 137                                                                  0,//write enabled
 138                                                                  0,0,0,0//reserved
 139          };
 140          unsigned char bulk_CSW[]={0x55,0x53,0x42,0x53,  // bytes 4 dCSWSignature
 141                                                  0x00,0x00,0x00,0x00,    //bytes 4  dCSWTag
 142                                                  0,0,0,0,                //bytes 4 dDataResiduce
 143                                                  0x00};                  //bCSWStatus  00=good state.
 144                                                  
 145          
 146          typedef struct _STRUCT_CBW
 147          {
 148                  unsigned char dCBWSignature[4];
 149                  unsigned char dCBWTag[4];       //dCBWTag of CBW
 150                  long unsigned int dCBWDataTransferLength;//dCBWDataTransferLength of CBW
 151                  unsigned char bmCBWFlags;
 152                  unsigned char bCBWLUN;
 153                  unsigned char bCBWCBLength;
 154                  unsigned char CBWCB[12];//for UFI Command all have 12bit
 155          } struct_CBW;
 156          
 157          struct_CBW bulk_CBW;
 158          
 159          void InterpretCBW()
 160          {
 161                  int i;
 162          
 163                  
 164                  bulk_CSW[4]                             =       EpBuf[4];
 165                  bulk_CSW[5]                             =       EpBuf[5];
 166                  bulk_CSW[6]                             =       EpBuf[6];
 167                  bulk_CSW[7]                             =       EpBuf[7];
 168                  
 169                  for(i=0;i<4;i++) bulk_CBW.dCBWDataTransferLength = (bulk_CBW.dCBWDataTransferLength<<8) +*(EpBuf+11-i);
 170          //      bulk_CBW.bmCBWFlags                     =       *(EpBuf+12);
 171          //      bulk_CBW.bCBWLUN                                =       *(EpBuf+13)&0x0f;
 172          //      bulk_CBW.bCBWCBLength                   =       *(EpBuf+14)&0x1f;
 173          
 174                  for(i=0;i<12;i++)
 175                  bulk_CBW.CBWCB  [i]                             =       EpBuf[i+15];
 176          
 177                  switch(bulk_CBW.CBWCB[0]){
C51 COMPILER V7.09   BULK_ONLY                                                             05/11/2005 17:30:28 PAGE 4   

 178                          case 0x04                                               :UFI_Reserved();break;
 179                          case Inquiry                                            :UFI_Inquiry();break;
 180                          case 0x55                                               :UFI_Reserved();break;
 181                          case Mode_Sense                                 :UFI_Mode_Sense();break;
 182                          case Read10                                             :UFI_Read10();break;
 183                          case 0xA8                                               :UFI_Reserved();break;
 184                          case Read_Capacity                              :UFI_Read_Capacity();break;
 185                          case Read_Format_Capacities             :UFI_Read_Format_Capacities();break;
 186                          case 0x03                                               :UFI_Reserved();break;
 187                          case 0x01                                               :UFI_Reserved();break;
 188                          case 0x2B                                               :UFI_Reserved();break;
 189                          case 0x1D                                               :UFI_Reserved();break;
 190                          case 0x1B                                               :UFI_Reserved();break;
 191                          case Test_Unit_Ready                            :UFI_Test_Unit_Ready();break;
 192                          case Verify                                             :UFI_Verify();break;
 193                          case Write10                                            :UFI_Write10();break;
 194                          case 0xAA                                               :UFI_Reserved();break;
 195                          case 0x2E                                               :UFI_Reserved();break;
 196                          case Medium_Removal                             :UFI_Medium_Removal();break;
 197                          default                                                 :UFI_Reserved();break;
 198                  }
 199                          
 200          }
 201          
 202          void UFI_Inquiry()
 203          {
 204                  unsigned char Logical_Unit_Number,Page_Code,Allocation_Length;
 205          //      Logical_Unit_Number = bulk_CBW.CBWCB[1]&0xe0;
 206          //      Page_Code = bulk_CBW.CBWCB[2];
 207          //      Allocation_Length = bulk_CBW.CBWCB[4];
 208          
 209                  if(bulk_CBW.CBWCB[4]==0)
 210                          return;
 211          //      Uart_Printf("\nInquiryData %d bytes have benn Send!",sizeof(InquiryData));
 212                  if(sizeof(B_InquiryData) > 0x40) {
 213                          dDataResiduce=bulk_CBW.dCBWDataTransferLength-0x40;
 214                          bulk_state = BULK_REQEST_TRANS;
 215                          pCurrentBuf = B_InquiryData;
 216                          D12_WriteEndpoint(5, 64, B_InquiryData);
 217                          nBufCount +=0x40;
 218                          Uart_Printf("\nData Can't Be Transmitted in one time!");
 219                          }
 220                  else {
 221                          bulk_state = BULK_DATA_END;
 222                          D12_WriteEndpoint(5, sizeof(B_InquiryData), B_InquiryData);
 223                          dDataResiduce = 0;
 224                          }
 225                  
 226          }
 227          void UFI_Read_Format_Capacities()
 228          {
 229                  unsigned char i,*pchar;
 230                  
 231                  if(bulk_CBW.CBWCB[7]==0 && bulk_CBW.CBWCB[8]==0)
 232                          return;
 233                  if(sizeof(B_Read_Format_capacities) > 0x40) {
 234                          dDataResiduce=bulk_CBW.dCBWDataTransferLength-0x40;
 235                          bulk_state = BULK_REQEST_TRANS;
 236                          pCurrentBuf = B_Read_Format_capacities;
 237                          D12_WriteEndpoint(5, 64, B_Read_Format_capacities);
 238                          nBufCount +=0x40;
 239                          Uart_Printf("\nData Can't Be Transmitted in one time!");
C51 COMPILER V7.09   BULK_ONLY                                                             05/11/2005 17:30:28 PAGE 5   

 240                          }
 241                  else {
 242                          bulk_state = BULK_DATA_END;
 243                          D12_WriteEndpoint(5, sizeof(B_Read_Format_capacities), B_Read_Format_capacities);
 244                          dDataResiduce = 0;
 245                          
 246                          }
 247          }
 248          void UFI_Read_Capacity()
 249          {
 250                  if(sizeof(B_Read_Canpacity) > 0x40) {
 251                          dDataResiduce=bulk_CBW.dCBWDataTransferLength-0x40;
 252                          bulk_state = BULK_REQEST_TRANS;
 253                          pCurrentBuf = B_Read_Canpacity;
 254                          D12_WriteEndpoint(5, 64, B_Read_Canpacity);
 255                          nBufCount +=0x40;
 256                          Uart_Printf("\nData Can't Be Transmitted in one time!");
 257                          }
 258                  else {
 259                          bulk_state = BULK_DATA_END;
 260                          D12_WriteEndpoint(5, sizeof(B_Read_Canpacity), B_Read_Canpacity);
 261                          dDataResiduce = 0;
 262                          }
 263                  
 264          }
 265          
 266          void UFI_Read10()
 267          {
 268                  int i;
 269                  for(i=0;i<4;i++) Logical_Block_Address = (Logical_Block_Address<<8) +bulk_CBW.CBWCB[2+i];       //要传的数据的