| #include <linux/slab.h> |
| #include "usb.h" |
| #include "scsiglue.h" |
| #include "smcommon.h" |
| #include "smil.h" |
| |
| int Check_D_LogCHS (WORD *,BYTE *,BYTE *); |
| void Initialize_D_Media (void); |
| void PowerOff_D_Media (void); |
| int Check_D_MediaPower (void); |
| int Check_D_MediaExist (void); |
| int Check_D_MediaWP (void); |
| int Check_D_MediaFmt (struct us_data *); |
| int Check_D_MediaFmtForEraseAll (struct us_data *); |
| int Conv_D_MediaAddr (struct us_data *, DWORD); |
| int Inc_D_MediaAddr (struct us_data *); |
| int Check_D_FirstSect (void); |
| int Check_D_LastSect (void); |
| int Media_D_ReadOneSect (struct us_data *, WORD, BYTE *); |
| int Media_D_WriteOneSect (struct us_data *, WORD, BYTE *); |
| int Media_D_CopyBlockHead (struct us_data *); |
| int Media_D_CopyBlockTail (struct us_data *); |
| int Media_D_EraseOneBlock (void); |
| int Media_D_EraseAllBlock (void); |
| |
| int Copy_D_BlockAll (struct us_data *, DWORD); |
| int Copy_D_BlockHead (struct us_data *); |
| int Copy_D_BlockTail (struct us_data *); |
| int Reassign_D_BlockHead (struct us_data *); |
| |
| int Assign_D_WriteBlock (void); |
| int Release_D_ReadBlock (struct us_data *); |
| int Release_D_WriteBlock (struct us_data *); |
| int Release_D_CopySector (struct us_data *); |
| |
| int Copy_D_PhyOneSect (struct us_data *); |
| int Read_D_PhyOneSect (struct us_data *, WORD, BYTE *); |
| int Write_D_PhyOneSect (struct us_data *, WORD, BYTE *); |
| int Erase_D_PhyOneBlock (struct us_data *); |
| |
| int Set_D_PhyFmtValue (struct us_data *); |
| int Search_D_CIS (struct us_data *); |
| int Make_D_LogTable (struct us_data *); |
| void Check_D_BlockIsFull (void); |
| |
| int MarkFail_D_PhyOneBlock (struct us_data *); |
| |
| DWORD ErrXDCode; |
| DWORD ErrCode; |
| //BYTE SectBuf[SECTSIZE]; |
| static BYTE WorkBuf[SECTSIZE]; |
| static BYTE Redundant[REDTSIZE]; |
| static BYTE WorkRedund[REDTSIZE]; |
| //WORD Log2Phy[MAX_ZONENUM][MAX_LOGBLOCK]; |
| static WORD *Log2Phy[MAX_ZONENUM]; // 128 x 1000, Log2Phy[MAX_ZONENUM][MAX_LOGBLOCK]; |
| static BYTE Assign[MAX_ZONENUM][MAX_BLOCKNUM/8]; |
| static WORD AssignStart[MAX_ZONENUM]; |
| WORD ReadBlock; |
| WORD WriteBlock; |
| DWORD MediaChange; |
| static DWORD SectCopyMode; |
| |
| //BIT Control Macro |
| static BYTE BitData[] = { 0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 } ; |
| #define Set_D_Bit(a,b) (a[(BYTE)((b)/8)]|= BitData[(b)%8]) |
| #define Clr_D_Bit(a,b) (a[(BYTE)((b)/8)]&=~BitData[(b)%8]) |
| #define Chk_D_Bit(a,b) (a[(BYTE)((b)/8)] & BitData[(b)%8]) |
| |
| //extern PBYTE SMHostAddr; |
| BYTE IsSSFDCCompliance; |
| BYTE IsXDCompliance; |
| |
| |
| // |
| ////Power Control & Media Exist Check Function |
| ////----- Init_D_SmartMedia() -------------------------------------------- |
| //int Init_D_SmartMedia(void) |
| //{ |
| // int i; |
| // |
| // EMCR_Print("Init_D_SmartMedia start\n"); |
| // for (i=0; i<MAX_ZONENUM; i++) |
| // { |
| // if (Log2Phy[i]!=NULL) |
| // { |
| // EMCR_Print("ExFreePool Zone = %x, Addr = %x\n", i, Log2Phy[i]); |
| // ExFreePool(Log2Phy[i]); |
| // Log2Phy[i] = NULL; |
| // } |
| // } |
| // |
| // Initialize_D_Media(); |
| // return(NO_ERROR); |
| //} |
| |
| //----- SM_FreeMem() ------------------------------------------------- |
| int SM_FreeMem(void) |
| { |
| int i; |
| |
| pr_info("SM_FreeMem start\n"); |
| for (i=0; i<MAX_ZONENUM; i++) |
| { |
| if (Log2Phy[i]!=NULL) |
| { |
| pr_info("Free Zone = %x, Addr = %p\n", i, Log2Phy[i]); |
| kfree(Log2Phy[i]); |
| Log2Phy[i] = NULL; |
| } |
| } |
| return(NO_ERROR); |
| } |
| |
| ////----- Pwoff_D_SmartMedia() ------------------------------------------- |
| //int Pwoff_D_SmartMedia(void) |
| //{ |
| // PowerOff_D_Media(); |
| // return(NO_ERROR); |
| //} |
| // |
| ////----- Check_D_SmartMedia() ------------------------------------------- |
| //int Check_D_SmartMedia(void) |
| //{ |
| // if (Check_D_MediaExist()) |
| // return(ErrCode); |
| // |
| // return(NO_ERROR); |
| //} |
| // |
| ////----- Check_D_Parameter() -------------------------------------------- |
| //int Check_D_Parameter(PFDO_DEVICE_EXTENSION fdoExt,WORD *pcyl,BYTE *phead,BYTE *psect) |
| //{ |
| // if (Check_D_MediaPower()) |
| // return(ErrCode); |
| // |
| // if (Check_D_MediaFmt(fdoExt)) |
| // return(ErrCode); |
| // |
| // if (Check_D_LogCHS(pcyl,phead,psect)) |
| // return(ErrCode); |
| // |
| // return(NO_ERROR); |
| //} |
| |
| //SmartMedia Read/Write/Erase Function |
| //----- Media_D_ReadSector() ------------------------------------------- |
| int Media_D_ReadSector(struct us_data *us, DWORD start,WORD count,BYTE *buf) |
| { |
| WORD len, bn; |
| |
| //if (Check_D_MediaPower()) ; ¦b 6250 don't care |
| // return(ErrCode); |
| //if (Check_D_MediaFmt(fdoExt)) ; |
| // return(ErrCode); |
| if (Conv_D_MediaAddr(us, start)) |
| return(ErrCode); |
| |
| while(1) |
| { |
| len = Ssfdc.MaxSectors - Media.Sector; |
| if (count > len) |
| bn = len; |
| else |
| bn = count; |
| //if (Media_D_ReadOneSect(fdoExt, SectBuf)) |
| //if (Media_D_ReadOneSect(fdoExt, count, buf)) |
| if (Media_D_ReadOneSect(us, bn, buf)) |
| { |
| ErrCode = ERR_EccReadErr; |
| return(ErrCode); |
| } |
| |
| Media.Sector += bn; |
| count -= bn; |
| |
| if (count<=0) |
| break; |
| |
| buf += bn * SECTSIZE; |
| |
| if (Inc_D_MediaAddr(us)) |
| return(ErrCode); |
| } |
| |
| return(NO_ERROR); |
| } |
| // here |
| //----- Media_D_CopySector() ------------------------------------------ |
| int Media_D_CopySector(struct us_data *us, DWORD start,WORD count,BYTE *buf) |
| { |
| //DWORD mode; |
| //int i; |
| WORD len, bn; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| /* pr_info("Media_D_CopySector !!!\n"); */ |
| if (Conv_D_MediaAddr(us, start)) |
| return(ErrCode); |
| |
| while(1) |
| { |
| if (Assign_D_WriteBlock()) |
| return(ERROR); |
| |
| len = Ssfdc.MaxSectors - Media.Sector; |
| if (count > len) |
| bn = len; |
| else |
| bn = count; |
| |
| //if (Ssfdc_D_CopyBlock(fdoExt,count,buf,Redundant)) |
| if (Ssfdc_D_CopyBlock(us,bn,buf,Redundant)) |
| { |
| ErrCode = ERR_WriteFault; |
| return(ErrCode); |
| } |
| |
| Media.Sector = 0x1F; |
| //if (Release_D_ReadBlock(fdoExt)) |
| if (Release_D_CopySector(us)) |
| { |
| if (ErrCode==ERR_HwError) |
| { |
| ErrCode = ERR_WriteFault; |
| return(ErrCode); |
| } |
| } |
| count -= bn; |
| |
| if (count<=0) |
| break; |
| |
| buf += bn * SECTSIZE; |
| |
| if (Inc_D_MediaAddr(us)) |
| return(ErrCode); |
| |
| } |
| return(NO_ERROR); |
| } |
| |
| //----- Release_D_CopySector() ------------------------------------------ |
| int Release_D_CopySector(struct us_data *us) |
| { |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| Log2Phy[Media.Zone][Media.LogBlock]=WriteBlock; |
| Media.PhyBlock=ReadBlock; |
| |
| if (Media.PhyBlock==NO_ASSIGN) |
| { |
| Media.PhyBlock=WriteBlock; |
| return(SMSUCCESS); |
| } |
| |
| Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock); |
| Media.PhyBlock=WriteBlock; |
| |
| return(SMSUCCESS); |
| } |
| /* |
| //----- Media_D_WriteSector() ------------------------------------------ |
| int Media_D_WriteSector(PFDO_DEVICE_EXTENSION fdoExt, DWORD start,WORD count,BYTE *buf) |
| { |
| int i; |
| WORD len, bn; |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| //if (Check_D_MediaPower()) |
| // return(ErrCode); |
| // |
| //if (Check_D_MediaFmt(fdoExt)) |
| // return(ErrCode); |
| // |
| //if (Check_D_MediaWP()) |
| // return(ErrCode); |
| |
| if (Conv_D_MediaAddr(fdoExt, start)) |
| return(ErrCode); |
| |
| //ENE_Print("Media_D_WriteSector --- Sector = %x\n", Media.Sector); |
| if (Check_D_FirstSect()) |
| { |
| if (Media_D_CopyBlockHead(fdoExt)) |
| { |
| ErrCode = ERR_WriteFault; |
| return(ErrCode); |
| } |
| } |
| |
| while(1) |
| { |
| if (!Check_D_FirstSect()) |
| { |
| if (Assign_D_WriteBlock()) |
| return(ErrCode); |
| } |
| |
| len = Ssfdc.MaxSectors - Media.Sector; |
| if (count > len) |
| bn = len; |
| else |
| bn = count; |
| //for(i=0;i<SECTSIZE;i++) |
| // SectBuf[i]=*buf++; |
| |
| //if (Media_D_WriteOneSect(fdoExt, SectBuf)) |
| if (Media_D_WriteOneSect(fdoExt, bn, buf)) |
| { |
| ErrCode = ERR_WriteFault; |
| return(ErrCode); |
| } |
| |
| Media.Sector += bn - 1; |
| |
| if (!Check_D_LastSect()) |
| { |
| if (Release_D_ReadBlock(fdoExt)) |
| |
| { if (ErrCode==ERR_HwError) |
| { |
| ErrCode = ERR_WriteFault; |
| return(ErrCode); |
| } |
| } |
| } |
| |
| count -= bn; |
| |
| if (count<=0) |
| break; |
| |
| buf += bn * SECTSIZE; |
| |
| //if (--count<=0) |
| // break; |
| |
| if (Inc_D_MediaAddr(fdoExt)) |
| return(ErrCode); |
| } |
| |
| if (!Check_D_LastSect()) |
| return(NO_ERROR); |
| |
| if (Inc_D_MediaAddr(fdoExt)) |
| return(ErrCode); |
| |
| if (Media_D_CopyBlockTail(fdoExt)) |
| { |
| ErrCode = ERR_WriteFault; |
| return(ErrCode); |
| } |
| |
| return(NO_ERROR); |
| } |
| // |
| ////----- Media_D_EraseBlock() ------------------------------------------- |
| //int Media_D_EraseBlock(PFDO_DEVICE_EXTENSION fdoExt, DWORD start,WORD count) |
| //{ |
| // if (Check_D_MediaPower()) |
| // return(ErrCode); |
| // |
| // if (Check_D_MediaFmt(fdoExt)) |
| // return(ErrCode); |
| // |
| // if (Check_D_MediaWP()) |
| // return(ErrCode); |
| // |
| // if (Conv_D_MediaAddr(start)) |
| // return(ErrCode); |
| // |
| // while(Check_D_FirstSect()) { |
| // if (Inc_D_MediaAddr(fdoExt)) |
| // return(ErrCode); |
| // |
| // if (--count<=0) |
| // return(NO_ERROR); |
| // } |
| // |
| // while(1) { |
| // if (!Check_D_LastSect()) |
| // if (Media_D_EraseOneBlock()) |
| // if (ErrCode==ERR_HwError) |
| // { |
| // ErrCode = ERR_WriteFault; |
| // return(ErrCode); |
| // } |
| // |
| // if (Inc_D_MediaAddr(fdoExt)) |
| // return(ErrCode); |
| // |
| // if (--count<=0) |
| // return(NO_ERROR); |
| // } |
| //} |
| // |
| ////----- Media_D_EraseAll() --------------------------------------------- |
| //int Media_D_EraseAll(PFDO_DEVICE_EXTENSION fdoExt) |
| //{ |
| // if (Check_D_MediaPower()) |
| // return(ErrCode); |
| // |
| // if (Check_D_MediaFmtForEraseAll(fdoExt)) |
| // return(ErrCode); |
| // |
| // if (Check_D_MediaWP()) |
| // return(ErrCode); |
| // |
| // if (Media_D_EraseAllBlock()) |
| // return(ErrCode); |
| // |
| // return(NO_ERROR); |
| //} |
| |
| //SmartMedia Write Function for One Sector Write Mode |
| //----- Media_D_OneSectWriteStart() ------------------------------------ |
| int Media_D_OneSectWriteStart(PFDO_DEVICE_EXTENSION fdoExt,DWORD start,BYTE *buf) |
| { |
| // int i; |
| // SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| // ADDRESS_T bb = (ADDRESS_T) &Media; |
| // |
| // //if (Check_D_MediaPower()) |
| // // return(ErrCode); |
| // //if (Check_D_MediaFmt(fdoExt)) |
| // // return(ErrCode); |
| // //if (Check_D_MediaWP()) |
| // // return(ErrCode); |
| // if (Conv_D_MediaAddr(fdoExt, start)) |
| // return(ErrCode); |
| // |
| // if (Check_D_FirstSect()) |
| // if (Media_D_CopyBlockHead(fdoExt)) |
| // { |
| // ErrCode = ERR_WriteFault; |
| // return(ErrCode); |
| // } |
| // |
| // if (!Check_D_FirstSect()) |
| // if (Assign_D_WriteBlock()) |
| // return(ErrCode); |
| // |
| // //for(i=0;i<SECTSIZE;i++) |
| // // SectBuf[i]=*buf++; |
| // |
| // //if (Media_D_WriteOneSect(fdoExt, SectBuf)) |
| // if (Media_D_WriteOneSect(fdoExt, buf)) |
| // { |
| // ErrCode = ERR_WriteFault; |
| // return(ErrCode); |
| // } |
| // |
| // if (!Check_D_LastSect()) |
| // { |
| // if (Release_D_ReadBlock(fdoExt)) |
| // if (ErrCode==ERR_HwError) |
| // { |
| // ErrCode = ERR_WriteFault; |
| // return(ErrCode); |
| // } |
| // } |
| |
| return(NO_ERROR); |
| } |
| |
| //----- Media_D_OneSectWriteNext() ------------------------------------- |
| int Media_D_OneSectWriteNext(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf) |
| { |
| // int i; |
| // SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| // ADDRESS_T bb = (ADDRESS_T) &Media; |
| // |
| // if (Inc_D_MediaAddr(fdoExt)) |
| // return(ErrCode); |
| // |
| // if (!Check_D_FirstSect()) |
| // if (Assign_D_WriteBlock()) |
| // return(ErrCode); |
| // |
| // //for(i=0;i<SECTSIZE;i++) |
| // // SectBuf[i]=*buf++; |
| // |
| // //if (Media_D_WriteOneSect(fdoExt, SectBuf)) |
| // if (Media_D_WriteOneSect(fdoExt, buf)) |
| // { |
| // ErrCode = ERR_WriteFault; |
| // return(ErrCode); |
| // } |
| // |
| // if (!Check_D_LastSect()) |
| // { |
| // if (Release_D_ReadBlock(fdoExt)) |
| // if (ErrCode==ERR_HwError) |
| // { |
| // ErrCode = ERR_WriteFault; |
| // return(ErrCode); |
| // } |
| // } |
| |
| return(NO_ERROR); |
| } |
| |
| //----- Media_D_OneSectWriteFlush() ------------------------------------ |
| int Media_D_OneSectWriteFlush(PFDO_DEVICE_EXTENSION fdoExt) |
| { |
| if (!Check_D_LastSect()) |
| return(NO_ERROR); |
| |
| if (Inc_D_MediaAddr(fdoExt)) |
| return(ErrCode); |
| |
| if (Media_D_CopyBlockTail(fdoExt)) |
| { |
| ErrCode = ERR_WriteFault; |
| return(ErrCode); |
| } |
| |
| return(NO_ERROR); |
| } |
| // |
| ////LED Tern On/Off Subroutine |
| ////----- SM_EnableLED() ----------------------------------------------- |
| //void SM_EnableLED(PFDO_DEVICE_EXTENSION fdoExt, BOOLEAN enable) |
| //{ |
| // if (fdoExt->Drive_IsSWLED) |
| // { |
| // if (enable) |
| // Led_D_TernOn(); |
| // else |
| // Led_D_TernOff(); |
| // } |
| //} |
| // |
| ////----- Led_D_TernOn() ------------------------------------------------- |
| //void Led_D_TernOn(void) |
| //{ |
| // if (Check_D_CardStsChg()) |
| // MediaChange=ERROR; |
| // |
| // Cnt_D_LedOn(); |
| //} |
| // |
| ////----- Led_D_TernOff() ------------------------------------------------ |
| //void Led_D_TernOff(void) |
| //{ |
| // if (Check_D_CardStsChg()) |
| // MediaChange=ERROR; |
| // |
| // Cnt_D_LedOff(); |
| //} |
| // |
| ////SmartMedia Logical Format Subroutine |
| ////----- Check_D_LogCHS() ----------------------------------------------- |
| //int Check_D_LogCHS(WORD *c,BYTE *h,BYTE *s) |
| //{ |
| // switch(Ssfdc.Model) { |
| // case SSFDC1MB: *c=125; *h= 4; *s= 4; break; |
| // case SSFDC2MB: *c=125; *h= 4; *s= 8; break; |
| // case SSFDC4MB: *c=250; *h= 4; *s= 8; break; |
| // case SSFDC8MB: *c=250; *h= 4; *s=16; break; |
| // case SSFDC16MB: *c=500; *h= 4; *s=16; break; |
| // case SSFDC32MB: *c=500; *h= 8; *s=16; break; |
| // case SSFDC64MB: *c=500; *h= 8; *s=32; break; |
| // case SSFDC128MB: *c=500; *h=16; *s=32; break; |
| // default: *c= 0; *h= 0; *s= 0; ErrCode = ERR_NoSmartMedia; return(ERROR); |
| // } |
| // |
| // return(SMSUCCESS); |
| //} |
| // |
| ////Power Control & Media Exist Check Subroutine |
| ////----- Initialize_D_Media() ------------------------------------------- |
| //void Initialize_D_Media(void) |
| //{ |
| // ErrCode = NO_ERROR; |
| // MediaChange = ERROR; |
| // SectCopyMode = COMPLETED; |
| // Cnt_D_Reset(); |
| //} |
| // |
| ////----- PowerOff_D_Media() --------------------------------------------- |
| //void PowerOff_D_Media(void) |
| //{ |
| // Cnt_D_PowerOff(); |
| //} |
| // |
| ////----- Check_D_MediaPower() ------------------------------------------- |
| //int Check_D_MediaPower(void) |
| //{ |
| // //usleep(56*1024); |
| // if (Check_D_CardStsChg()) |
| // MediaChange = ERROR; |
| // //usleep(56*1024); |
| // if ((!Check_D_CntPower())&&(!MediaChange)) // ¦³ power & Media ¨S³Q change, «h return success |
| // return(SMSUCCESS); |
| // //usleep(56*1024); |
| // |
| // if (Check_D_CardExist()) // Check if card is not exist, return err |
| // { |
| // ErrCode = ERR_NoSmartMedia; |
| // MediaChange = ERROR; |
| // return(ERROR); |
| // } |
| // //usleep(56*1024); |
| // if (Cnt_D_PowerOn()) |
| // { |
| // ErrCode = ERR_NoSmartMedia; |
| // MediaChange = ERROR; |
| // return(ERROR); |
| // } |
| // //usleep(56*1024); |
| // Ssfdc_D_Reset(fdoExt); |
| // //usleep(56*1024); |
| // return(SMSUCCESS); |
| //} |
| // |
| ////-----Check_D_MediaExist() -------------------------------------------- |
| //int Check_D_MediaExist(void) |
| //{ |
| // if (Check_D_CardStsChg()) |
| // MediaChange = ERROR; |
| // |
| // if (!Check_D_CardExist()) |
| // { |
| // if (!MediaChange) |
| // return(SMSUCCESS); |
| // |
| // ErrCode = ERR_ChangedMedia; |
| // return(ERROR); |
| // } |
| // |
| // ErrCode = ERR_NoSmartMedia; |
| // |
| // return(ERROR); |
| //} |
| // |
| ////----- Check_D_MediaWP() ---------------------------------------------- |
| //int Check_D_MediaWP(void) |
| //{ |
| // if (Ssfdc.Attribute &MWP) |
| // { |
| // ErrCode = ERR_WrtProtect; |
| // return(ERROR); |
| // } |
| // |
| // return(SMSUCCESS); |
| //} |
| */ |
| //SmartMedia Physical Format Test Subroutine |
| //----- Check_D_MediaFmt() --------------------------------------------- |
| int Check_D_MediaFmt(struct us_data *us) |
| { |
| pr_info("Check_D_MediaFmt\n"); |
| //ULONG i,j, result=FALSE, zone,block; |
| |
| //usleep(56*1024); |
| if (!MediaChange) |
| return(SMSUCCESS); |
| |
| MediaChange = ERROR; |
| SectCopyMode = COMPLETED; |
| |
| //usleep(56*1024); |
| if (Set_D_PhyFmtValue(us)) |
| { |
| ErrCode = ERR_UnknownMedia; |
| return(ERROR); |
| } |
| |
| //usleep(56*1024); |
| if (Search_D_CIS(us)) |
| { |
| ErrCode = ERR_IllegalFmt; |
| return(ERROR); |
| } |
| |
| |
| MediaChange = SMSUCCESS; |
| return(SMSUCCESS); |
| } |
| /* |
| ////----- Check_D_BlockIsFull() ---------------------------------- |
| //void Check_D_BlockIsFull() |
| //{ |
| // ULONG i, block; |
| // |
| // if (IsXDCompliance || IsSSFDCCompliance) |
| // { |
| // // If the blocks are full then return write-protect. |
| // block = Ssfdc.MaxBlocks/8; |
| // for (Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++) |
| // { |
| // if (Log2Phy[Media.Zone]==NULL) |
| // { |
| // if (Make_D_LogTable()) |
| // { |
| // ErrCode = ERR_IllegalFmt; |
| // return; |
| // } |
| // } |
| // |
| // for (i=0; i<block; i++) |
| // { |
| // if (Assign[Media.Zone][i] != 0xFF) |
| // return; |
| // } |
| // } |
| // Ssfdc.Attribute |= WP; |
| // } |
| //} |
| // |
| // |
| ////----- Check_D_MediaFmtForEraseAll() ---------------------------------- |
| //int Check_D_MediaFmtForEraseAll(PFDO_DEVICE_EXTENSION fdoExt) |
| //{ |
| // MediaChange = ERROR; |
| // SectCopyMode = COMPLETED; |
| // |
| // if (Set_D_PhyFmtValue(fdoExt)) |
| // { |
| // ErrCode = ERR_UnknownMedia; |
| // return(ERROR); |
| // } |
| // |
| // if (Search_D_CIS(fdoExt)) |
| // { |
| // ErrCode = ERR_IllegalFmt; |
| // return(ERROR); |
| // } |
| // |
| // return(SMSUCCESS); |
| //} |
| */ |
| //SmartMedia Physical Address Control Subroutine |
| //----- Conv_D_MediaAddr() --------------------------------------------- |
| int Conv_D_MediaAddr(struct us_data *us, DWORD addr) |
| { |
| DWORD temp; |
| //ULONG zz; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| temp = addr/Ssfdc.MaxSectors; |
| Media.Zone = (BYTE) (temp/Ssfdc.MaxLogBlocks); |
| |
| if (Log2Phy[Media.Zone]==NULL) |
| { |
| if (Make_D_LogTable(us)) |
| { |
| ErrCode = ERR_IllegalFmt; |
| return(ERROR); |
| } |
| } |
| |
| Media.Sector = (BYTE) (addr%Ssfdc.MaxSectors); |
| Media.LogBlock = (WORD) (temp%Ssfdc.MaxLogBlocks); |
| |
| if (Media.Zone<Ssfdc.MaxZones) |
| { |
| Clr_D_RedundantData(Redundant); |
| Set_D_LogBlockAddr(Redundant); |
| Media.PhyBlock = Log2Phy[Media.Zone][Media.LogBlock]; |
| return(SMSUCCESS); |
| } |
| |
| ErrCode = ERR_OutOfLBA; |
| return(ERROR); |
| } |
| |
| //----- Inc_D_MediaAddr() ---------------------------------------------- |
| int Inc_D_MediaAddr(struct us_data *us) |
| { |
| WORD LogBlock = Media.LogBlock; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| if (++Media.Sector<Ssfdc.MaxSectors) |
| return(SMSUCCESS); |
| |
| if (Log2Phy[Media.Zone]==NULL) |
| { |
| if (Make_D_LogTable(us)) |
| { |
| ErrCode = ERR_IllegalFmt; |
| return(ERROR); |
| } |
| } |
| |
| Media.Sector=0; |
| Media.LogBlock = LogBlock; |
| |
| if (++Media.LogBlock<Ssfdc.MaxLogBlocks) |
| { |
| Clr_D_RedundantData(Redundant); |
| Set_D_LogBlockAddr(Redundant); |
| Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock]; |
| return(SMSUCCESS); |
| } |
| |
| Media.LogBlock=0; |
| |
| if (++Media.Zone<Ssfdc.MaxZones) |
| { |
| if (Log2Phy[Media.Zone]==NULL) |
| { |
| if (Make_D_LogTable(us)) |
| { |
| ErrCode = ERR_IllegalFmt; |
| return(ERROR); |
| } |
| } |
| |
| Media.LogBlock = 0; |
| |
| Clr_D_RedundantData(Redundant); |
| Set_D_LogBlockAddr(Redundant); |
| Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock]; |
| return(SMSUCCESS); |
| } |
| |
| Media.Zone=0; |
| ErrCode = ERR_OutOfLBA; |
| |
| return(ERROR); |
| } |
| /* |
| //----- Check_D_FirstSect() -------------------------------------------- |
| int Check_D_FirstSect(void) |
| { |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| if (!Media.Sector) |
| return(SMSUCCESS); |
| |
| return(ERROR); |
| } |
| |
| //----- Check_D_LastSect() --------------------------------------------- |
| int Check_D_LastSect(void) |
| { |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| if (Media.Sector<(Ssfdc.MaxSectors-1)) |
| return(ERROR); |
| |
| return(SMSUCCESS); |
| } |
| */ |
| //SmartMedia Read/Write Subroutine with Retry |
| //----- Media_D_ReadOneSect() ------------------------------------------ |
| int Media_D_ReadOneSect(struct us_data *us, WORD count, BYTE *buf) |
| { |
| DWORD err, retry; |
| |
| if (!Read_D_PhyOneSect(us, count, buf)) |
| return(SMSUCCESS); |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| if (ErrCode==ERR_DataStatus) |
| return(ERROR); |
| |
| #ifdef RDERR_REASSIGN |
| if (Ssfdc.Attribute &MWP) |
| { |
| if (ErrCode==ERR_CorReadErr) |
| return(SMSUCCESS); |
| return(ERROR); |
| } |
| |
| err=ErrCode; |
| for(retry=0; retry<2; retry++) |
| { |
| if (Copy_D_BlockAll(us, (err==ERR_EccReadErr)?REQ_FAIL:REQ_ERASE)) |
| { |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| continue; |
| } |
| |
| ErrCode = err; |
| if (ErrCode==ERR_CorReadErr) |
| return(SMSUCCESS); |
| return(ERROR); |
| } |
| |
| MediaChange = ERROR; |
| #else |
| if (ErrCode==ERR_CorReadErr) return(SMSUCCESS); |
| #endif |
| |
| return(ERROR); |
| } |
| /* |
| //----- Media_D_WriteOneSect() ----------------------------------------- |
| int Media_D_WriteOneSect(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf) |
| { |
| DWORD retry; |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| if (!Write_D_PhyOneSect(fdoExt, count, buf)) |
| return(SMSUCCESS); |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| |
| for(retry=1; retry<2; retry++) |
| { |
| if (Reassign_D_BlockHead(fdoExt)) |
| { |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| continue; |
| } |
| |
| if (!Write_D_PhyOneSect(fdoExt, count, buf)) |
| return(SMSUCCESS); |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| } |
| |
| if (Release_D_WriteBlock(fdoExt)) |
| return(ERROR); |
| |
| ErrCode = ERR_WriteFault; |
| MediaChange = ERROR; |
| return(ERROR); |
| } |
| |
| //SmartMedia Data Copy Subroutine with Retry |
| //----- Media_D_CopyBlockHead() ---------------------------------------- |
| int Media_D_CopyBlockHead(PFDO_DEVICE_EXTENSION fdoExt) |
| { |
| DWORD retry; |
| |
| for(retry=0; retry<2; retry++) |
| { |
| if (!Copy_D_BlockHead(fdoExt)) |
| return(SMSUCCESS); |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| } |
| |
| MediaChange = ERROR; |
| return(ERROR); |
| } |
| |
| //----- Media_D_CopyBlockTail() ---------------------------------------- |
| int Media_D_CopyBlockTail(PFDO_DEVICE_EXTENSION fdoExt) |
| { |
| DWORD retry; |
| |
| if (!Copy_D_BlockTail(fdoExt)) |
| return(SMSUCCESS); |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| |
| for(retry=1; retry<2; retry++) |
| { |
| if (Reassign_D_BlockHead(fdoExt)) |
| { |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| continue; |
| } |
| |
| if (!Copy_D_BlockTail(fdoExt)) |
| return(SMSUCCESS); |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| } |
| |
| if (Release_D_WriteBlock(fdoExt)) |
| return(ERROR); |
| |
| ErrCode = ERR_WriteFault; |
| MediaChange = ERROR; |
| return(ERROR); |
| } |
| // |
| ////----- Media_D_EraseOneBlock() ---------------------------------------- |
| //int Media_D_EraseOneBlock(void) |
| //{ |
| // WORD LogBlock = Media.LogBlock; |
| // WORD PhyBlock = Media.PhyBlock; |
| // SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| // ADDRESS_T bb = (ADDRESS_T) &Media; |
| // |
| // if (Media.PhyBlock==NO_ASSIGN) |
| // return(SMSUCCESS); |
| // |
| // if (Log2Phy[Media.Zone]==NULL) |
| // { |
| // if (Make_D_LogTable()) |
| // { |
| // ErrCode = ERR_IllegalFmt; |
| // return(ERROR); |
| // } |
| // } |
| // Media.LogBlock = LogBlock; |
| // Media.PhyBlock = PhyBlock; |
| // |
| // Log2Phy[Media.Zone][Media.LogBlock]=NO_ASSIGN; |
| // |
| // if (Erase_D_PhyOneBlock(fdoExt)) |
| // { |
| // if (ErrCode==ERR_HwError) |
| // return(ERROR); |
| // if (MarkFail_D_PhyOneBlock()) |
| // return(ERROR); |
| // |
| // ErrCode = ERR_WriteFault; |
| // return(ERROR); |
| // } |
| // |
| // Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock); |
| // Media.PhyBlock=NO_ASSIGN; |
| // return(SMSUCCESS); |
| //} |
| // |
| ////SmartMedia Erase Subroutine |
| ////----- Media_D_EraseAllBlock() ---------------------------------------- |
| //int Media_D_EraseAllBlock(void) |
| //{ |
| // WORD cis=0; |
| // |
| // SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| // ADDRESS_T bb = (ADDRESS_T) &Media; |
| // |
| // MediaChange = ERROR; |
| // Media.Sector = 0; |
| // |
| // for(Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++) |
| // for(Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++) { |
| // if (Ssfdc_D_ReadRedtData(Redundant)) |
| // { |
| // Ssfdc_D_Reset(fdoExt); |
| // return(ERROR); |
| // } |
| // |
| // Ssfdc_D_Reset(fdoExt); |
| // if (!Check_D_FailBlock(Redundant)) |
| // { |
| // if (cis) |
| // { |
| // if (Ssfdc_D_EraseBlock(fdoExt)) |
| // { |
| // ErrCode = ERR_HwError; |
| // return(ERROR); |
| // } |
| // |
| // if (Ssfdc_D_CheckStatus()) |
| // { |
| // if (MarkFail_D_PhyOneBlock()) |
| // return(ERROR); |
| // } |
| // |
| // continue; |
| // } |
| // |
| // if (Media.PhyBlock!=CisArea.PhyBlock) |
| // { |
| // ErrCode = ERR_IllegalFmt; |
| // return(ERROR); |
| // } |
| // |
| // cis++; |
| // } |
| // |
| // } |
| // return(SMSUCCESS); |
| //} |
| */ |
| //SmartMedia Physical Sector Data Copy Subroutine |
| //----- Copy_D_BlockAll() ---------------------------------------------- |
| int Copy_D_BlockAll(struct us_data *us, DWORD mode) |
| { |
| BYTE sect; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| sect=Media.Sector; |
| |
| if (Assign_D_WriteBlock()) |
| return(ERROR); |
| if (mode==REQ_FAIL) |
| SectCopyMode=REQ_FAIL; |
| |
| for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++) |
| { |
| if (Copy_D_PhyOneSect(us)) |
| { |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| if (Release_D_WriteBlock(us)) |
| return(ERROR); |
| |
| ErrCode = ERR_WriteFault; |
| Media.PhyBlock=ReadBlock; |
| Media.Sector=sect; |
| |
| return(ERROR); |
| } |
| } |
| |
| if (Release_D_ReadBlock(us)) |
| return(ERROR); |
| |
| Media.PhyBlock=WriteBlock; |
| Media.Sector=sect; |
| return(SMSUCCESS); |
| } |
| /* |
| //----- Copy_D_BlockHead() --------------------------------------------- |
| int Copy_D_BlockHead(PFDO_DEVICE_EXTENSION fdoExt) |
| { |
| BYTE sect; |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| sect=Media.Sector; |
| if (Assign_D_WriteBlock()) |
| return(ERROR); |
| |
| for(Media.Sector=0; Media.Sector<sect; Media.Sector++) |
| { |
| if (Copy_D_PhyOneSect(fdoExt)) |
| { |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| if (Release_D_WriteBlock(fdoExt)) |
| return(ERROR); |
| |
| ErrCode = ERR_WriteFault; |
| Media.PhyBlock=ReadBlock; |
| Media.Sector=sect; |
| |
| return(ERROR); |
| } |
| } |
| |
| Media.PhyBlock=WriteBlock; |
| Media.Sector=sect; |
| return(SMSUCCESS); |
| } |
| |
| //----- Copy_D_BlockTail() --------------------------------------------- |
| int Copy_D_BlockTail(PFDO_DEVICE_EXTENSION fdoExt) |
| { |
| BYTE sect; |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| for(sect=Media.Sector; Media.Sector<Ssfdc.MaxSectors; Media.Sector++) |
| { |
| if (Copy_D_PhyOneSect(fdoExt)) |
| { |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| |
| Media.PhyBlock=WriteBlock; |
| Media.Sector=sect; |
| |
| return(ERROR); |
| } |
| } |
| |
| if (Release_D_ReadBlock(fdoExt)) |
| return(ERROR); |
| |
| Media.PhyBlock=WriteBlock; |
| Media.Sector=sect; |
| return(SMSUCCESS); |
| } |
| |
| //----- Reassign_D_BlockHead() ----------------------------------------- |
| int Reassign_D_BlockHead(PFDO_DEVICE_EXTENSION fdoExt) |
| { |
| DWORD mode; |
| WORD block; |
| BYTE sect; |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| mode=SectCopyMode; |
| block=ReadBlock; |
| sect=Media.Sector; |
| |
| if (Assign_D_WriteBlock()) |
| return(ERROR); |
| |
| SectCopyMode=REQ_FAIL; |
| |
| for(Media.Sector=0; Media.Sector<sect; Media.Sector++) |
| { |
| if (Copy_D_PhyOneSect(fdoExt)) |
| { |
| if (ErrCode==ERR_HwError) |
| return(ERROR); |
| if (Release_D_WriteBlock(fdoExt)) |
| return(ERROR); |
| |
| ErrCode = ERR_WriteFault; |
| SectCopyMode=mode; |
| WriteBlock=ReadBlock; |
| ReadBlock=block; |
| Media.Sector=sect; |
| Media.PhyBlock=WriteBlock; |
| |
| return(ERROR); |
| } |
| } |
| |
| if (Release_D_ReadBlock(fdoExt)) |
| return(ERROR); |
| |
| SectCopyMode=mode; |
| ReadBlock=block; |
| Media.Sector=sect; |
| Media.PhyBlock=WriteBlock; |
| return(SMSUCCESS); |
| } |
| */ |
| //SmartMedia Physical Block Assign/Release Subroutine |
| //----- Assign_D_WriteBlock() ------------------------------------------ |
| int Assign_D_WriteBlock(void) |
| { |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| ReadBlock=Media.PhyBlock; |
| |
| for(WriteBlock=AssignStart[Media.Zone]; WriteBlock<Ssfdc.MaxBlocks; WriteBlock++) |
| { |
| if (!Chk_D_Bit(Assign[Media.Zone],WriteBlock)) |
| { |
| Set_D_Bit(Assign[Media.Zone],WriteBlock); |
| AssignStart[Media.Zone]=WriteBlock+1; |
| Media.PhyBlock=WriteBlock; |
| SectCopyMode=REQ_ERASE; |
| //ErrXDCode = NO_ERROR; |
| return(SMSUCCESS); |
| } |
| } |
| |
| for(WriteBlock=0; WriteBlock<AssignStart[Media.Zone]; WriteBlock++) |
| { |
| if (!Chk_D_Bit(Assign[Media.Zone],WriteBlock)) |
| { |
| Set_D_Bit(Assign[Media.Zone],WriteBlock); |
| AssignStart[Media.Zone]=WriteBlock+1; |
| Media.PhyBlock=WriteBlock; |
| SectCopyMode=REQ_ERASE; |
| //ErrXDCode = NO_ERROR; |
| return(SMSUCCESS); |
| } |
| } |
| |
| WriteBlock=NO_ASSIGN; |
| ErrCode = ERR_WriteFault; |
| // For xD test |
| //Ssfdc.Attribute |= WP; |
| //ErrXDCode = ERR_WrtProtect; |
| return(ERROR); |
| } |
| |
| //----- Release_D_ReadBlock() ------------------------------------------ |
| int Release_D_ReadBlock(struct us_data *us) |
| { |
| DWORD mode; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| mode=SectCopyMode; |
| SectCopyMode=COMPLETED; |
| |
| if (mode==COMPLETED) |
| return(SMSUCCESS); |
| |
| Log2Phy[Media.Zone][Media.LogBlock]=WriteBlock; |
| Media.PhyBlock=ReadBlock; |
| |
| if (Media.PhyBlock==NO_ASSIGN) |
| { |
| Media.PhyBlock=WriteBlock; |
| return(SMSUCCESS); |
| } |
| |
| if (mode==REQ_ERASE) |
| { |
| if (Erase_D_PhyOneBlock(us)) |
| { |
| if (ErrCode==ERR_HwError) return(ERROR); |
| if (MarkFail_D_PhyOneBlock(us)) return(ERROR); |
| } |
| else |
| Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock); |
| } |
| else if (MarkFail_D_PhyOneBlock(us)) |
| return(ERROR); |
| |
| Media.PhyBlock=WriteBlock; |
| return(SMSUCCESS); |
| } |
| |
| //----- Release_D_WriteBlock() ----------------------------------------- |
| int Release_D_WriteBlock(struct us_data *us) |
| { |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| SectCopyMode=COMPLETED; |
| Media.PhyBlock=WriteBlock; |
| |
| if (MarkFail_D_PhyOneBlock(us)) |
| return(ERROR); |
| |
| Media.PhyBlock=ReadBlock; |
| return(SMSUCCESS); |
| } |
| |
| //SmartMedia Physical Sector Data Copy Subroutine |
| //----- Copy_D_PhyOneSect() -------------------------------------------- |
| int Copy_D_PhyOneSect(struct us_data *us) |
| { |
| int i; |
| DWORD err, retry; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| /* pr_info("Copy_D_PhyOneSect --- Secotr = %x\n", Media.Sector); */ |
| if (ReadBlock!=NO_ASSIGN) |
| { |
| Media.PhyBlock=ReadBlock; |
| for(retry=0; retry<2; retry++) |
| { |
| if (retry!=0) |
| { |
| Ssfdc_D_Reset(us); |
| if (Ssfdc_D_ReadCisSect(us,WorkBuf,WorkRedund)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| |
| if (Check_D_CISdata(WorkBuf,WorkRedund)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| } |
| |
| if (Ssfdc_D_ReadSect(us,WorkBuf,WorkRedund)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| if (Check_D_DataStatus(WorkRedund)) |
| { err=ERROR; break; } |
| if (!Check_D_ReadError(WorkRedund)) |
| { err=SMSUCCESS; break; } |
| if (!Check_D_Correct(WorkBuf,WorkRedund)) |
| { err=SMSUCCESS; break; } |
| |
| err=ERROR; |
| SectCopyMode=REQ_FAIL; |
| } |
| } |
| else |
| { |
| err=SMSUCCESS; |
| for(i=0; i<SECTSIZE; i++) |
| WorkBuf[i]=DUMMY_DATA; |
| Clr_D_RedundantData(WorkRedund); |
| } |
| |
| Set_D_LogBlockAddr(WorkRedund); |
| if (err==ERROR) |
| { |
| Set_D_RightECC(WorkRedund); |
| Set_D_DataStaus(WorkRedund); |
| } |
| |
| Media.PhyBlock=WriteBlock; |
| |
| if (Ssfdc_D_WriteSectForCopy(us, WorkBuf, WorkRedund)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| if (Ssfdc_D_CheckStatus()) |
| { ErrCode = ERR_WriteFault; return(ERROR); } |
| |
| Media.PhyBlock=ReadBlock; |
| return(SMSUCCESS); |
| } |
| |
| //SmartMedia Physical Sector Read/Write/Erase Subroutine |
| //----- Read_D_PhyOneSect() -------------------------------------------- |
| int Read_D_PhyOneSect(struct us_data *us, WORD count, BYTE *buf) |
| { |
| int i; |
| DWORD retry; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| if (Media.PhyBlock==NO_ASSIGN) |
| { |
| for(i=0; i<SECTSIZE; i++) |
| *buf++=DUMMY_DATA; |
| return(SMSUCCESS); |
| } |
| |
| for(retry=0; retry<2; retry++) |
| { |
| if (retry!=0) |
| { |
| Ssfdc_D_Reset(us); |
| |
| if (Ssfdc_D_ReadCisSect(us,WorkBuf,WorkRedund)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| if (Check_D_CISdata(WorkBuf,WorkRedund)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| } |
| |
| //if (Ssfdc_D_ReadSect(fdoExt,buf,Redundant)) |
| if (Ssfdc_D_ReadBlock(us,count,buf,Redundant)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| if (Check_D_DataStatus(Redundant)) |
| { ErrCode = ERR_DataStatus; return(ERROR); } |
| |
| if (!Check_D_ReadError(Redundant)) |
| return(SMSUCCESS); |
| |
| if (!Check_D_Correct(buf,Redundant)) |
| { ErrCode = ERR_CorReadErr; return(ERROR); } |
| } |
| |
| ErrCode = ERR_EccReadErr; |
| return(ERROR); |
| } |
| /* |
| //----- Write_D_PhyOneSect() ------------------------------------------- |
| int Write_D_PhyOneSect(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf) |
| { |
| SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| //if (Ssfdc_D_WriteSect(fdoExt,buf,Redundant)) |
| if (Ssfdc_D_WriteBlock(fdoExt,count,buf,Redundant)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| if (Ssfdc_D_CheckStatus()) |
| { ErrCode = ERR_WriteFault; return(ERROR); } |
| |
| return(SMSUCCESS); |
| } |
| */ |
| //----- Erase_D_PhyOneBlock() ------------------------------------------ |
| int Erase_D_PhyOneBlock(struct us_data *us) |
| { |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| if (Ssfdc_D_EraseBlock(us)) |
| { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); } |
| if (Ssfdc_D_CheckStatus()) |
| { ErrCode = ERR_WriteFault; return(ERROR); } |
| |
| return(SMSUCCESS); |
| } |
| |
| //SmartMedia Physical Format Check Local Subroutine |
| //----- Set_D_PhyFmtValue() -------------------------------------------- |
| int Set_D_PhyFmtValue(struct us_data *us) |
| { |
| // PPDO_DEVICE_EXTENSION pdoExt; |
| // BYTE idcode[4]; |
| // DWORD UserDefData_1, UserDefData_2, Data, mask; |
| // |
| // //if (!fdoExt->ChildDeviceObject) return(ERROR); |
| // //pdoExt = fdoExt->ChildDeviceObject->DeviceExtension; |
| // |
| // Ssfdc_D_ReadID(idcode, READ_ID_1); |
| // |
| //if (Set_D_SsfdcModel(idcode[1])) |
| if (Set_D_SsfdcModel(us->SM_DeviceID)) |
| return(ERROR); |
| |
| // //Use Multi-function pin to differentiate SM and xD. |
| // UserDefData_1 = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, fdoExt->FuncID, PCI_REG_USER_DEF) & 0x80; |
| // if (UserDefData_1) |
| // { |
| // if ( READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x80 ) fdoExt->DiskType = DISKTYPE_XD; |
| // if ( READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x40 ) fdoExt->DiskType = DISKTYPE_SM; |
| // |
| // if ( IsXDCompliance && (fdoExt->DiskType == DISKTYPE_XD) ) |
| // { |
| // Ssfdc_D_ReadID(idcode, READ_ID_3); |
| // if (idcode[2] != 0xB5) |
| // return(ERROR); |
| // } |
| // } |
| // |
| // //Use GPIO to differentiate SM and xD. |
| // UserDefData_2 = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, fdoExt->FuncID, PCI_REG_USER_DEF) >> 8; |
| // if ( UserDefData_2 ) |
| // { |
| // Data = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, 0, 0xAC); |
| // |
| // mask = 1 << (UserDefData_2-1); |
| // // 1 : xD , 0 : SM |
| // if ( Data & mask) |
| // fdoExt->DiskType = DISKTYPE_XD; |
| // else |
| // fdoExt->DiskType = DISKTYPE_SM; |
| // |
| // if ( IsXDCompliance && (fdoExt->DiskType == DISKTYPE_XD) ) |
| // { |
| // Ssfdc_D_ReadID(idcode, READ_ID_3); |
| // if (idcode[2] != 0xB5) |
| // return(ERROR); |
| // } |
| // } |
| // |
| // if ( !(UserDefData_1 | UserDefData_2) ) |
| // { |
| // // Use UserDefine Register to differentiate SM and xD. |
| // Ssfdc_D_ReadID(idcode, READ_ID_3); |
| // |
| // if (idcode[2] == 0xB5) |
| // fdoExt->DiskType = DISKTYPE_XD; |
| // else |
| // { |
| // if (!IsXDCompliance) |
| // fdoExt->DiskType = DISKTYPE_SM; |
| // else |
| // return(ERROR); |
| // } |
| // |
| // if (fdoExt->UserDef_DiskType == 0x04) fdoExt->DiskType = DISKTYPE_XD; |
| // if (fdoExt->UserDef_DiskType == 0x08) fdoExt->DiskType = DISKTYPE_SM; |
| // } |
| // |
| // if (!fdoExt->UserDef_DisableWP) |
| // { |
| // if (fdoExt->DiskType == DISKTYPE_SM) |
| // { |
| // if (Check_D_SsfdcWP()) |
| // Ssfdc.Attribute|=WP; |
| // } |
| // } |
| |
| return(SMSUCCESS); |
| } |
| |
| //----- Search_D_CIS() ------------------------------------------------- |
| int Search_D_CIS(struct us_data *us) |
| { |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| Media.Zone=0; Media.Sector=0; |
| |
| for (Media.PhyBlock=0; Media.PhyBlock<(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1); Media.PhyBlock++) |
| { |
| if (Ssfdc_D_ReadRedtData(us, Redundant)) |
| { |
| Ssfdc_D_Reset(us); |
| return(ERROR); |
| } |
| |
| if (!Check_D_FailBlock(Redundant)) |
| break; |
| } |
| |
| if (Media.PhyBlock==(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1)) |
| { |
| Ssfdc_D_Reset(us); |
| return(ERROR); |
| } |
| |
| while (Media.Sector<CIS_SEARCH_SECT) |
| { |
| if (Media.Sector) |
| { |
| if (Ssfdc_D_ReadRedtData(us, Redundant)) |
| { |
| Ssfdc_D_Reset(us); |
| return(ERROR); |
| } |
| } |
| if (!Check_D_DataStatus(Redundant)) |
| { |
| if (Ssfdc_D_ReadSect(us,WorkBuf,Redundant)) |
| { |
| Ssfdc_D_Reset(us); |
| return(ERROR); |
| } |
| |
| if (Check_D_CISdata(WorkBuf,Redundant)) |
| { |
| Ssfdc_D_Reset(us); |
| return(ERROR); |
| } |
| |
| CisArea.PhyBlock=Media.PhyBlock; |
| CisArea.Sector=Media.Sector; |
| Ssfdc_D_Reset(us); |
| return(SMSUCCESS); |
| } |
| |
| Media.Sector++; |
| } |
| |
| Ssfdc_D_Reset(us); |
| return(ERROR); |
| } |
| |
| //----- Make_D_LogTable() ---------------------------------------------- |
| int Make_D_LogTable(struct us_data *us) |
| { |
| WORD phyblock,logblock; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| if (Log2Phy[Media.Zone]==NULL) |
| { |
| Log2Phy[Media.Zone] = kmalloc(MAX_LOGBLOCK*sizeof(WORD), GFP_KERNEL); |
| /* pr_info("ExAllocatePool Zone = %x, Addr = %x\n", |
| Media.Zone, Log2Phy[Media.Zone]); */ |
| if (Log2Phy[Media.Zone]==NULL) |
| return(ERROR); |
| } |
| |
| Media.Sector=0; |
| |
| //for(Media.Zone=0; Media.Zone<MAX_ZONENUM; Media.Zone++) |
| //for(Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++) |
| { |
| /* pr_info("Make_D_LogTable --- MediaZone = 0x%x\n", |
| Media.Zone); */ |
| for(Media.LogBlock=0; Media.LogBlock<Ssfdc.MaxLogBlocks; Media.LogBlock++) |
| Log2Phy[Media.Zone][Media.LogBlock]=NO_ASSIGN; |
| |
| for(Media.PhyBlock=0; Media.PhyBlock<(MAX_BLOCKNUM/8); Media.PhyBlock++) |
| Assign[Media.Zone][Media.PhyBlock]=0x00; |
| |
| for(Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++) |
| { |
| if ((!Media.Zone) && (Media.PhyBlock<=CisArea.PhyBlock)) |
| { |
| Set_D_Bit(Assign[Media.Zone],Media.PhyBlock); |
| continue; |
| } |
| |
| if (Ssfdc_D_ReadRedtData(us, Redundant)) |
| { Ssfdc_D_Reset(us); return(ERROR); } |
| |
| if (!Check_D_DataBlank(Redundant)) |
| continue; |
| |
| Set_D_Bit(Assign[Media.Zone],Media.PhyBlock); |
| |
| if (Check_D_FailBlock(Redundant)) |
| continue; |
| |
| //if (Check_D_DataStatus(Redundant)) |
| // continue; |
| |
| if (Load_D_LogBlockAddr(Redundant)) |
| continue; |
| |
| if (Media.LogBlock>=Ssfdc.MaxLogBlocks) |
| continue; |
| |
| if (Log2Phy[Media.Zone][Media.LogBlock]==NO_ASSIGN) |
| { |
| Log2Phy[Media.Zone][Media.LogBlock]=Media.PhyBlock; |
| continue; |
| } |
| |
| phyblock = Media.PhyBlock; |
| logblock = Media.LogBlock; |
| Media.Sector = (BYTE)(Ssfdc.MaxSectors-1); |
| |
| if (Ssfdc_D_ReadRedtData(us, Redundant)) |
| { Ssfdc_D_Reset(us); return(ERROR); } |
| |
| if (!Load_D_LogBlockAddr(Redundant)) |
| { |
| if (Media.LogBlock==logblock) |
| { |
| Media.PhyBlock=Log2Phy[Media.Zone][logblock]; |
| |
| if (Ssfdc_D_ReadRedtData(us, Redundant)) |
| { Ssfdc_D_Reset(us); return(ERROR); } |
| |
| Media.PhyBlock=phyblock; |
| |
| if (!Load_D_LogBlockAddr(Redundant)) |
| { |
| if (Media.LogBlock!=logblock) |
| { |
| Media.PhyBlock=Log2Phy[Media.Zone][logblock]; |
| Log2Phy[Media.Zone][logblock]=phyblock; |
| } |
| } |
| else |
| { |
| Media.PhyBlock=Log2Phy[Media.Zone][logblock]; |
| Log2Phy[Media.Zone][logblock]=phyblock; |
| } |
| } |
| } |
| |
| Media.Sector=0; |
| |
| // here Not yet |
| //#ifdef L2P_ERR_ERASE |
| // if (!(Ssfdc.Attribute &MWP)) |
| // { |
| // Ssfdc_D_Reset(fdoExt); |
| // if (Ssfdc_D_EraseBlock(fdoExt)) |
| // return(ERROR); |
| // |
| // if (Ssfdc_D_CheckStatus()) |
| // { |
| // if (MarkFail_D_PhyOneBlock()) |
| // return(ERROR); |
| // } |
| // else |
| // Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock); |
| // } |
| //#else |
| // Ssfdc.Attribute|=MWP; |
| //#endif |
| Media.PhyBlock=phyblock; |
| |
| } // End for (Media.PhyBlock<Ssfdc.MaxBlocks) |
| |
| AssignStart[Media.Zone]=0; |
| |
| } // End for (Media.Zone<MAX_ZONENUM) |
| |
| Ssfdc_D_Reset(us); |
| return(SMSUCCESS); |
| } |
| |
| //----- MarkFail_D_PhyOneBlock() --------------------------------------- |
| int MarkFail_D_PhyOneBlock(struct us_data *us) |
| { |
| BYTE sect; |
| //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc; |
| //ADDRESS_T bb = (ADDRESS_T) &Media; |
| |
| sect=Media.Sector; |
| Set_D_FailBlock(WorkRedund); |
| //Ssfdc_D_WriteRedtMode(); |
| |
| for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++) |
| { |
| if (Ssfdc_D_WriteRedtData(us, WorkRedund)) |
| { |
| Ssfdc_D_Reset(us); |
| Media.Sector = sect; |
| ErrCode = ERR_HwError; |
| MediaChange = ERROR; |
| return(ERROR); |
| } // NO Status Check |
| } |
| |
| Ssfdc_D_Reset(us); |
| Media.Sector=sect; |
| return(SMSUCCESS); |
| } |
| /* |
| // |
| ////----- SM_Init() ---------------------------------------------------- |
| //void SM_Init(void) |
| //{ |
| // _Hw_D_ClrIntCardChg(); |
| // _Hw_D_SetIntMask(); |
| // // For DMA Interrupt |
| // _Hw_D_ClrDMAIntCardChg(); |
| // _Hw_D_SetDMAIntMask(); |
| //} |
| // |
| ////----- Media_D_EraseAllRedtData() ----------------------------------- |
| //int Media_D_EraseAllRedtData(DWORD Index, BOOLEAN CheckBlock) |
| //{ |
| // BYTE i; |
| // |
| // if (Check_D_MediaPower()) |
| // return(ErrCode); |
| // |
| // if (Check_D_MediaWP()) |
| // return(ErrCode); |
| // |
| // for (i=0; i<REDTSIZE; i++) |
| // WorkRedund[i] = 0xFF; |
| // |
| // Media.Zone = (BYTE)Index; |
| // for (Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++) |
| // { |
| // if ((!Media.Zone) && (Media.PhyBlock<=CisArea.PhyBlock)) |
| // continue; |
| // |
| // if (Ssfdc_D_EraseBlock(fdoExt)) |
| // { |
| // ErrCode = ERR_HwError; |
| // return(ERROR); |
| // } |
| // |
| // for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++) |
| // { |
| // Ssfdc_D_WriteRedtMode(); |
| // |
| // if (Ssfdc_D_WriteRedtData(WorkRedund)) |
| // { |
| // Ssfdc_D_Reset(fdoExt); |
| // ErrCode = ERR_HwError; |
| // MediaChange = ERROR; |
| // return(ERROR); |
| // } // NO Status Check |
| // } |
| // |
| // Ssfdc_D_Reset(fdoExt); |
| // } |
| // |
| // Ssfdc_D_Reset(fdoExt); |
| // |
| // return(SMSUCCESS); |
| //} |
| // |
| ////----- Media_D_GetMediaInfo() --------------------------------------- |
| //DWORD Media_D_GetMediaInfo(PFDO_DEVICE_EXTENSION fdoExt, PIOCTL_MEDIA_INFO_IN pParamIn, PIOCTL_MEDIA_INFO_OUT pParamOut) |
| //{ |
| // pParamOut->ErrCode = STATUS_CMD_FAIL; |
| // |
| // Init_D_SmartMedia(); |
| // |
| // if (Check_D_MediaPower()) |
| // return (ErrCode==ERR_NoSmartMedia) ? STATUS_CMD_NO_MEDIA : STATUS_CMD_FAIL; |
| // |
| // if (Set_D_PhyFmtValue(fdoExt)) |
| // return STATUS_CMD_FAIL; |
| // |
| // //usleep(56*1024); |
| // if (Search_D_CIS(fdoExt)) |
| // return STATUS_CMD_FAIL; |
| // |
| // if (Check_D_MediaWP()) |
| // return STATUS_CMD_MEDIA_WP; |
| // |
| // pParamOut->PageSize = Ssfdc.MaxSectors; |
| // pParamOut->BlockSize = Ssfdc.MaxBlocks; |
| // pParamOut->ZoneSize = Ssfdc.MaxZones; |
| // |
| // return STATUS_CMD_SUCCESS; |
| //}*/ |
