drivers/staging/keucr/smilmain.c

   1 #include <linux/slab.h>
   2 #include "usb.h"
   3 #include "scsiglue.h"
   4 #include "smcommon.h"
   5 #include "smil.h"
   6
   7 int         Check_D_LogCHS              (WORD *,BYTE *,BYTE *);
   8 void        Initialize_D_Media          (void);
   9 void        PowerOff_D_Media            (void);
  10 int         Check_D_MediaPower          (void);
  11 int         Check_D_MediaExist          (void);
  12 int         Check_D_MediaWP             (void);
  13 int         Check_D_MediaFmt            (struct us_data *);
  14 int         Check_D_MediaFmtForEraseAll (struct us_data *);
  15 int         Conv_D_MediaAddr            (struct us_data *, DWORD);
  16 int         Inc_D_MediaAddr             (struct us_data *);
  17 int         Check_D_FirstSect           (void);
  18 int         Check_D_LastSect            (void);
  19 int         Media_D_ReadOneSect         (struct us_data *, WORD, BYTE *);
  20 int         Media_D_WriteOneSect        (struct us_data *, WORD, BYTE *);
  21 int         Media_D_CopyBlockHead       (struct us_data *);
  22 int         Media_D_CopyBlockTail       (struct us_data *);
  23 int         Media_D_EraseOneBlock       (void);
  24 int         Media_D_EraseAllBlock       (void);
  25
  26 int  Copy_D_BlockAll             (struct us_data *, DWORD);
  27 int  Copy_D_BlockHead            (struct us_data *);
  28 int  Copy_D_BlockTail            (struct us_data *);
  29 int  Reassign_D_BlockHead        (struct us_data *);
  30
  31 int  Assign_D_WriteBlock         (void);
  32 int  Release_D_ReadBlock         (struct us_data *);
  33 int  Release_D_WriteBlock        (struct us_data *);
  34 int  Release_D_CopySector        (struct us_data *);
  35
  36 int  Copy_D_PhyOneSect           (struct us_data *);
  37 int  Read_D_PhyOneSect           (struct us_data *, WORD, BYTE *);
  38 int  Write_D_PhyOneSect          (struct us_data *, WORD, BYTE *);
  39 int  Erase_D_PhyOneBlock         (struct us_data *);
  40
  41 int  Set_D_PhyFmtValue           (struct us_data *);
  42 int  Search_D_CIS                (struct us_data *);
  43 int  Make_D_LogTable             (struct us_data *);
  44 void Check_D_BlockIsFull         (void);
  45
  46 int  MarkFail_D_PhyOneBlock      (struct us_data *);
  47
  48 DWORD ErrXDCode;
  49 DWORD ErrCode;
  50 //BYTE  SectBuf[SECTSIZE];
  51 BYTE  WorkBuf[SECTSIZE];
  52 BYTE  Redundant[REDTSIZE];
  53 BYTE  WorkRedund[REDTSIZE];
  54 //WORD  Log2Phy[MAX_ZONENUM][MAX_LOGBLOCK];
  55 WORD  *Log2Phy[MAX_ZONENUM];                 // 128 x 1000,   Log2Phy[MAX_ZONENUM][MAX_LOGBLOCK];
  56 BYTE  Assign[MAX_ZONENUM][MAX_BLOCKNUM/8];
  57 WORD  AssignStart[MAX_ZONENUM];
  58 WORD  ReadBlock;
  59 WORD  WriteBlock;
  60 DWORD MediaChange;
  61 DWORD SectCopyMode;
  62
  63 extern struct SSFDCTYPE  Ssfdc;
  64 extern struct ADDRESS    Media;
  65 extern struct CIS_AREA   CisArea;
  66
  67 //BIT Controll Macro
  68 BYTE BitData[] = { 0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 } ;
  69 #define Set_D_Bit(a,b)    (a[(BYTE)((b)/8)]|= BitData[(b)%8])
  70 #define Clr_D_Bit(a,b)    (a[(BYTE)((b)/8)]&=~BitData[(b)%8])
  71 #define Chk_D_Bit(a,b)    (a[(BYTE)((b)/8)] & BitData[(b)%8])
  72
  73 //extern PBYTE    SMHostAddr;
  74 extern BYTE     IsSSFDCCompliance;
  75 extern BYTE     IsXDCompliance;
  76
  77
  78 //
  79 ////Power Controll & Media Exist Check Function
  80 ////----- Init_D_SmartMedia() --------------------------------------------
  81 //int Init_D_SmartMedia(void)
  82 //{
  83 //    int     i;
  84 //
  85 //    EMCR_Print("Init_D_SmartMedia start\n");
  86 //    for (i=0; i<MAX_ZONENUM; i++)
  87 //    {
  88 //        if (Log2Phy[i]!=NULL)
  89 //        {
  90 //            EMCR_Print("ExFreePool Zone = %x, Addr = %x\n", i, Log2Phy[i]);
  91 //            ExFreePool(Log2Phy[i]);
  92 //            Log2Phy[i] = NULL;
  93 //        }
  94 //    }
  95 //
  96 //    Initialize_D_Media();
  97 //    return(NO_ERROR);
  98 //}
  99
 100 //----- SM_FreeMem() -------------------------------------------------
 101 int SM_FreeMem(void)
 102 {
 103         int     i;
 104
 105         printk("SM_FreeMem start\n");
 106         for (i=0; i<MAX_ZONENUM; i++)
 107         {
 108                 if (Log2Phy[i]!=NULL)
 109                 {
 110                         printk("Free Zone = %x, Addr = %p\n", i, Log2Phy[i]);
 111                         kfree(Log2Phy[i]);
 112                         Log2Phy[i] = NULL;
 113                 }
 114         }
 115         return(NO_ERROR);
 116 }
 117
 118 ////----- Pwoff_D_SmartMedia() -------------------------------------------
 119 //int Pwoff_D_SmartMedia(void)
 120 //{
 121 //    PowerOff_D_Media();
 122 //    return(NO_ERROR);
 123 //}
 124 //
 125 ////----- Check_D_SmartMedia() -------------------------------------------
 126 //int Check_D_SmartMedia(void)
 127 //{
 128 //    if (Check_D_MediaExist())
 129 //        return(ErrCode);
 130 //
 131 //    return(NO_ERROR);
 132 //}
 133 //
 134 ////----- Check_D_Parameter() --------------------------------------------
 135 //int Check_D_Parameter(PFDO_DEVICE_EXTENSION fdoExt,WORD *pcyl,BYTE *phead,BYTE *psect)
 136 //{
 137 //    if (Check_D_MediaPower())
 138 //        return(ErrCode);
 139 //
 140 //    if (Check_D_MediaFmt(fdoExt))
 141 //        return(ErrCode);
 142 //
 143 //    if (Check_D_LogCHS(pcyl,phead,psect))
 144 //        return(ErrCode);
 145 //
 146 //    return(NO_ERROR);
 147 //}
 148
 149 //SmartMedia Read/Write/Erase Function
 150 //----- Media_D_ReadSector() -------------------------------------------
 151 int Media_D_ReadSector(struct us_data *us, DWORD start,WORD count,BYTE *buf)
 152 {
 153         WORD len, bn;
 154
 155         //if (Check_D_MediaPower())        ; ¦b 6250 don't care
 156         //    return(ErrCode);             ;
 157         //if (Check_D_MediaFmt(fdoExt))    ;
 158         //    return(ErrCode);             ;
 159         if (Conv_D_MediaAddr(us, start))
 160                 return(ErrCode);
 161
 162         while(1)
 163         {
 164                 len = Ssfdc.MaxSectors - Media.Sector;
 165                 if (count > len)
 166                         bn = len;
 167                 else
 168                         bn = count;
 169                 //if (Media_D_ReadOneSect(fdoExt, SectBuf))
 170                 //if (Media_D_ReadOneSect(fdoExt, count, buf))
 171                 if (Media_D_ReadOneSect(us, bn, buf))
 172                 {
 173                         ErrCode = ERR_EccReadErr;
 174                         return(ErrCode);
 175                 }
 176
 177                 Media.Sector += bn;
 178                 count -= bn;
 179
 180                 if (count<=0)
 181                         break;
 182
 183                 buf += bn * SECTSIZE;
 184
 185                 if (Inc_D_MediaAddr(us))
 186                         return(ErrCode);
 187         }
 188
 189         return(NO_ERROR);
 190 }
 191 // here
 192 //----- Media_D_CopySector() ------------------------------------------
 193 int Media_D_CopySector(struct us_data *us, DWORD start,WORD count,BYTE *buf)
 194 {
 195         //DWORD mode;
 196         //int i;
 197         WORD len, bn;
 198         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 199         //ADDRESS_T   bb = (ADDRESS_T) &Media;
 200
 201         //printk("Media_D_CopySector !!!\n");
 202         if (Conv_D_MediaAddr(us, start))
 203                 return(ErrCode);
 204
 205         while(1)
 206         {
 207                 if (Assign_D_WriteBlock())
 208                         return(ERROR);
 209
 210                 len = Ssfdc.MaxSectors - Media.Sector;
 211                 if (count > len)
 212                         bn = len;
 213                 else
 214                 bn = count;
 215
 216                 //if (Ssfdc_D_CopyBlock(fdoExt,count,buf,Redundant))
 217                 if (Ssfdc_D_CopyBlock(us,bn,buf,Redundant))
 218                 {
 219                         ErrCode = ERR_WriteFault;
 220                         return(ErrCode);
 221                 }
 222
 223                 Media.Sector = 0x1F;
 224                 //if (Release_D_ReadBlock(fdoExt))
 225                 if (Release_D_CopySector(us))
 226                 {
 227                         if (ErrCode==ERR_HwError)
 228                         {
 229                                 ErrCode = ERR_WriteFault;
 230                                 return(ErrCode);
 231                         }
 232                 }
 233                 count -= bn;
 234
 235                 if (count<=0)
 236                         break;
 237
 238                 buf += bn * SECTSIZE;
 239
 240                 if (Inc_D_MediaAddr(us))
 241                         return(ErrCode);
 242
 243         }
 244         return(NO_ERROR);
 245 }
 246
 247 //----- Release_D_CopySector() ------------------------------------------
 248 int Release_D_CopySector(struct us_data *us)
 249 {
 250         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 251         //ADDRESS_T   bb = (ADDRESS_T) &Media;
 252
 253         Log2Phy[Media.Zone][Media.LogBlock]=WriteBlock;
 254         Media.PhyBlock=ReadBlock;
 255
 256         if (Media.PhyBlock==NO_ASSIGN)
 257         {
 258                 Media.PhyBlock=WriteBlock;
 259                 return(SUCCESS);
 260         }
 261
 262         Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
 263         Media.PhyBlock=WriteBlock;
 264
 265         return(SUCCESS);
 266 }
 267 /*
 268 //----- Media_D_WriteSector() ------------------------------------------
 269 int Media_D_WriteSector(PFDO_DEVICE_EXTENSION fdoExt, DWORD start,WORD count,BYTE *buf)
 270 {
 271     int i;
 272     WORD len, bn;
 273     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 274     ADDRESS_T   bb = (ADDRESS_T) &Media;
 275
 276     //if (Check_D_MediaPower())
 277     //    return(ErrCode);
 278     //
 279     //if (Check_D_MediaFmt(fdoExt))
 280     //    return(ErrCode);
 281     //
 282     //if (Check_D_MediaWP())
 283     //    return(ErrCode);
 284
 285     if (Conv_D_MediaAddr(fdoExt, start))
 286         return(ErrCode);
 287
 288     //ENE_Print("Media_D_WriteSector --- Sector = %x\n", Media.Sector);
 289     if (Check_D_FirstSect())
 290     {
 291         if (Media_D_CopyBlockHead(fdoExt))
 292         {
 293             ErrCode = ERR_WriteFault;
 294             return(ErrCode);
 295         }
 296     }
 297
 298     while(1)
 299     {
 300         if (!Check_D_FirstSect())
 301         {
 302             if (Assign_D_WriteBlock())
 303                 return(ErrCode);
 304         }
 305
 306         len = Ssfdc.MaxSectors - Media.Sector;
 307         if (count > len)
 308            bn = len;
 309         else
 310            bn = count;
 311         //for(i=0;i<SECTSIZE;i++)
 312         //    SectBuf[i]=*buf++;
 313
 314         //if (Media_D_WriteOneSect(fdoExt, SectBuf))
 315         if (Media_D_WriteOneSect(fdoExt, bn, buf))
 316         {
 317             ErrCode = ERR_WriteFault;
 318             return(ErrCode);
 319         }
 320
 321         Media.Sector += bn - 1;
 322
 323         if (!Check_D_LastSect())
 324         {
 325             if (Release_D_ReadBlock(fdoExt))
 326
 327             {    if (ErrCode==ERR_HwError)
 328                 {
 329                     ErrCode = ERR_WriteFault;
 330                     return(ErrCode);
 331                 }
 332             }
 333         }
 334
 335         count -= bn;
 336
 337         if (count<=0)
 338             break;
 339
 340         buf += bn * SECTSIZE;
 341
 342         //if (--count<=0)
 343         //    break;
 344
 345         if (Inc_D_MediaAddr(fdoExt))
 346             return(ErrCode);
 347     }
 348
 349     if (!Check_D_LastSect())
 350         return(NO_ERROR);
 351
 352     if (Inc_D_MediaAddr(fdoExt))
 353         return(ErrCode);
 354
 355     if (Media_D_CopyBlockTail(fdoExt))
 356     {
 357         ErrCode = ERR_WriteFault;
 358         return(ErrCode);
 359     }
 360
 361     return(NO_ERROR);
 362 }
 363 //
 364 ////----- Media_D_EraseBlock() -------------------------------------------
 365 //int Media_D_EraseBlock(PFDO_DEVICE_EXTENSION fdoExt, DWORD start,WORD count)
 366 //{
 367 //    if (Check_D_MediaPower())
 368 //        return(ErrCode);
 369 //
 370 //    if (Check_D_MediaFmt(fdoExt))
 371 //        return(ErrCode);
 372 //
 373 //    if (Check_D_MediaWP())
 374 //        return(ErrCode);
 375 //
 376 //    if (Conv_D_MediaAddr(start))
 377 //        return(ErrCode);
 378 //
 379 //    while(Check_D_FirstSect()) {
 380 //        if (Inc_D_MediaAddr(fdoExt))
 381 //            return(ErrCode);
 382 //
 383 //        if (--count<=0)
 384 //            return(NO_ERROR);
 385 //    }
 386 //
 387 //    while(1) {
 388 //        if (!Check_D_LastSect())
 389 //            if (Media_D_EraseOneBlock())
 390 //                if (ErrCode==ERR_HwError)
 391 //                {
 392 //                    ErrCode = ERR_WriteFault;
 393 //                    return(ErrCode);
 394 //                }
 395 //
 396 //        if (Inc_D_MediaAddr(fdoExt))
 397 //            return(ErrCode);
 398 //
 399 //        if (--count<=0)
 400 //            return(NO_ERROR);
 401 //    }
 402 //}
 403 //
 404 ////----- Media_D_EraseAll() ---------------------------------------------
 405 //int Media_D_EraseAll(PFDO_DEVICE_EXTENSION fdoExt)
 406 //{
 407 //    if (Check_D_MediaPower())
 408 //        return(ErrCode);
 409 //
 410 //    if (Check_D_MediaFmtForEraseAll(fdoExt))
 411 //        return(ErrCode);
 412 //
 413 //    if (Check_D_MediaWP())
 414 //        return(ErrCode);
 415 //
 416 //    if (Media_D_EraseAllBlock())
 417 //        return(ErrCode);
 418 //
 419 //    return(NO_ERROR);
 420 //}
 421
 422 //SmartMedia Write Function for One Sector Write Mode
 423 //----- Media_D_OneSectWriteStart() ------------------------------------
 424 int Media_D_OneSectWriteStart(PFDO_DEVICE_EXTENSION fdoExt,DWORD start,BYTE *buf)
 425 {
 426 //  int i;
 427 //  SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 428 //  ADDRESS_T   bb = (ADDRESS_T) &Media;
 429 //
 430 //  //if (Check_D_MediaPower())
 431 //  //    return(ErrCode);
 432 //  //if (Check_D_MediaFmt(fdoExt))
 433 //  //    return(ErrCode);
 434 //  //if (Check_D_MediaWP())
 435 //  //    return(ErrCode);
 436 //  if (Conv_D_MediaAddr(fdoExt, start))
 437 //      return(ErrCode);
 438 //
 439 //  if (Check_D_FirstSect())
 440 //      if (Media_D_CopyBlockHead(fdoExt))
 441 //      {
 442 //          ErrCode = ERR_WriteFault;
 443 //          return(ErrCode);
 444 //      }
 445 //
 446 //  if (!Check_D_FirstSect())
 447 //      if (Assign_D_WriteBlock())
 448 //          return(ErrCode);
 449 //
 450 //  //for(i=0;i<SECTSIZE;i++)
 451 //  //    SectBuf[i]=*buf++;
 452 //
 453 //  //if (Media_D_WriteOneSect(fdoExt, SectBuf))
 454 //  if (Media_D_WriteOneSect(fdoExt, buf))
 455 //  {
 456 //      ErrCode = ERR_WriteFault;
 457 //      return(ErrCode);
 458 //  }
 459 //
 460 //  if (!Check_D_LastSect())
 461 //  {
 462 //      if (Release_D_ReadBlock(fdoExt))
 463 //          if (ErrCode==ERR_HwError)
 464 //          {
 465 //              ErrCode = ERR_WriteFault;
 466 //              return(ErrCode);
 467 //          }
 468 //  }
 469
 470     return(NO_ERROR);
 471 }
 472
 473 //----- Media_D_OneSectWriteNext() -------------------------------------
 474 int Media_D_OneSectWriteNext(PFDO_DEVICE_EXTENSION fdoExt, BYTE *buf)
 475 {
 476 //  int i;
 477 //  SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 478 //  ADDRESS_T   bb = (ADDRESS_T) &Media;
 479 //
 480 //  if (Inc_D_MediaAddr(fdoExt))
 481 //      return(ErrCode);
 482 //
 483 //  if (!Check_D_FirstSect())
 484 //    if (Assign_D_WriteBlock())
 485 //      return(ErrCode);
 486 //
 487 //  //for(i=0;i<SECTSIZE;i++)
 488 //  //    SectBuf[i]=*buf++;
 489 //
 490 //  //if (Media_D_WriteOneSect(fdoExt, SectBuf))
 491 //  if (Media_D_WriteOneSect(fdoExt, buf))
 492 //  {
 493 //      ErrCode = ERR_WriteFault;
 494 //      return(ErrCode);
 495 //  }
 496 //
 497 //  if (!Check_D_LastSect())
 498 //  {
 499 //      if (Release_D_ReadBlock(fdoExt))
 500 //          if (ErrCode==ERR_HwError)
 501 //          {
 502 //              ErrCode = ERR_WriteFault;
 503 //              return(ErrCode);
 504 //          }
 505 //  }
 506
 507     return(NO_ERROR);
 508 }
 509
 510 //----- Media_D_OneSectWriteFlush() ------------------------------------
 511 int Media_D_OneSectWriteFlush(PFDO_DEVICE_EXTENSION fdoExt)
 512 {
 513     if (!Check_D_LastSect())
 514         return(NO_ERROR);
 515
 516     if (Inc_D_MediaAddr(fdoExt))
 517         return(ErrCode);
 518
 519     if (Media_D_CopyBlockTail(fdoExt))
 520     {
 521         ErrCode = ERR_WriteFault;
 522         return(ErrCode);
 523     }
 524
 525     return(NO_ERROR);
 526 }
 527 //
 528 ////LED Tern On/Off Subroutine
 529 ////----- SM_EnableLED() -----------------------------------------------
 530 //void SM_EnableLED(PFDO_DEVICE_EXTENSION fdoExt, BOOLEAN enable)
 531 //{
 532 //    if (fdoExt->Drive_IsSWLED)
 533 //    {
 534 //        if (enable)
 535 //           Led_D_TernOn();
 536 //        else
 537 //           Led_D_TernOff();
 538 //    }
 539 //}
 540 //
 541 ////----- Led_D_TernOn() -------------------------------------------------
 542 //void Led_D_TernOn(void)
 543 //{
 544 //    if (Check_D_CardStsChg())
 545 //        MediaChange=ERROR;
 546 //
 547 //    Cnt_D_LedOn();
 548 //}
 549 //
 550 ////----- Led_D_TernOff() ------------------------------------------------
 551 //void Led_D_TernOff(void)
 552 //{
 553 //    if (Check_D_CardStsChg())
 554 //        MediaChange=ERROR;
 555 //
 556 //    Cnt_D_LedOff();
 557 //}
 558 //
 559 ////SmartMedia Logical Format Subroutine
 560 ////----- Check_D_LogCHS() -----------------------------------------------
 561 //int Check_D_LogCHS(WORD *c,BYTE *h,BYTE *s)
 562 //{
 563 //    switch(Ssfdc.Model) {
 564 //        case SSFDC1MB:   *c=125; *h= 4; *s= 4; break;
 565 //        case SSFDC2MB:   *c=125; *h= 4; *s= 8; break;
 566 //        case SSFDC4MB:   *c=250; *h= 4; *s= 8; break;
 567 //        case SSFDC8MB:   *c=250; *h= 4; *s=16; break;
 568 //        case SSFDC16MB:  *c=500; *h= 4; *s=16; break;
 569 //        case SSFDC32MB:  *c=500; *h= 8; *s=16; break;
 570 //        case SSFDC64MB:  *c=500; *h= 8; *s=32; break;
 571 //        case SSFDC128MB: *c=500; *h=16; *s=32; break;
 572 //        default:         *c= 0;  *h= 0; *s= 0; ErrCode = ERR_NoSmartMedia;    return(ERROR);
 573 //    }
 574 //
 575 //    return(SUCCESS);
 576 //}
 577 //
 578 ////Power Controll & Media Exist Check Subroutine
 579 ////----- Initialize_D_Media() -------------------------------------------
 580 //void Initialize_D_Media(void)
 581 //{
 582 //    ErrCode      = NO_ERROR;
 583 //    MediaChange  = ERROR;
 584 //    SectCopyMode = COMPLETED;
 585 //    Cnt_D_Reset();
 586 //}
 587 //
 588 ////----- PowerOff_D_Media() ---------------------------------------------
 589 //void PowerOff_D_Media(void)
 590 //{
 591 //    Cnt_D_PowerOff();
 592 //}
 593 //
 594 ////----- Check_D_MediaPower() -------------------------------------------
 595 //int Check_D_MediaPower(void)
 596 //{
 597 //    //usleep(56*1024);
 598 //    if (Check_D_CardStsChg())
 599 //        MediaChange = ERROR;
 600 //    //usleep(56*1024);
 601 //    if ((!Check_D_CntPower())&&(!MediaChange))  // ¦³ power & Media ¨S³Q change, «h return success
 602 //        return(SUCCESS);
 603 //    //usleep(56*1024);
 604 //
 605 //    if (Check_D_CardExist())                    // Check if card is not exist, return err
 606 //    {
 607 //        ErrCode        = ERR_NoSmartMedia;
 608 //        MediaChange = ERROR;
 609 //        return(ERROR);
 610 //    }
 611 //    //usleep(56*1024);
 612 //    if (Cnt_D_PowerOn())
 613 //    {
 614 //        ErrCode        = ERR_NoSmartMedia;
 615 //        MediaChange = ERROR;
 616 //        return(ERROR);
 617 //    }
 618 //    //usleep(56*1024);
 619 //    Ssfdc_D_Reset(fdoExt);
 620 //    //usleep(56*1024);
 621 //    return(SUCCESS);
 622 //}
 623 //
 624 ////-----Check_D_MediaExist() --------------------------------------------
 625 //int Check_D_MediaExist(void)
 626 //{
 627 //    if (Check_D_CardStsChg())
 628 //        MediaChange = ERROR;
 629 //
 630 //    if (!Check_D_CardExist())
 631 //    {
 632 //        if (!MediaChange)
 633 //            return(SUCCESS);
 634 //
 635 //        ErrCode = ERR_ChangedMedia;
 636 //        return(ERROR);
 637 //    }
 638 //
 639 //    ErrCode = ERR_NoSmartMedia;
 640 //
 641 //    return(ERROR);
 642 //}
 643 //
 644 ////----- Check_D_MediaWP() ----------------------------------------------
 645 //int Check_D_MediaWP(void)
 646 //{
 647 //    if (Ssfdc.Attribute &MWP)
 648 //    {
 649 //        ErrCode = ERR_WrtProtect;
 650 //        return(ERROR);
 651 //    }
 652 //
 653 //    return(SUCCESS);
 654 //}
 655 */
 656 //SmartMedia Physical Format Test Subroutine
 657 //----- Check_D_MediaFmt() ---------------------------------------------
 658 int Check_D_MediaFmt(struct us_data *us)
 659 {
 660         printk("Check_D_MediaFmt\n");
 661         //ULONG i,j, result=FALSE, zone,block;
 662
 663         //usleep(56*1024);
 664         if (!MediaChange)
 665                 return(SUCCESS);
 666
 667         MediaChange  = ERROR;
 668         SectCopyMode = COMPLETED;
 669
 670         //usleep(56*1024);
 671         if (Set_D_PhyFmtValue(us))
 672         {
 673                 ErrCode = ERR_UnknownMedia;
 674                 return(ERROR);
 675         }
 676
 677         //usleep(56*1024);
 678         if (Search_D_CIS(us))
 679         {
 680                 ErrCode = ERR_IllegalFmt;
 681                 return(ERROR);
 682         }
 683
 684
 685     MediaChange = SUCCESS;
 686     return(SUCCESS);
 687 }
 688 /*
 689 ////----- Check_D_BlockIsFull() ----------------------------------
 690 //void Check_D_BlockIsFull()
 691 //{
 692 //    ULONG i, block;
 693 //
 694 //    if (IsXDCompliance || IsSSFDCCompliance)
 695 //    {
 696 //       // If the blocks are full then return write-protect.
 697 //       block = Ssfdc.MaxBlocks/8;
 698 //       for (Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++)
 699 //       {
 700 //           if (Log2Phy[Media.Zone]==NULL)
 701 //           {
 702 //               if (Make_D_LogTable())
 703 //               {
 704 //                   ErrCode = ERR_IllegalFmt;
 705 //                   return;
 706 //               }
 707 //           }
 708 //
 709 //           for (i=0; i<block; i++)
 710 //           {
 711 //               if (Assign[Media.Zone][i] != 0xFF)
 712 //                  return;
 713 //           }
 714 //       }
 715 //       Ssfdc.Attribute |= WP;
 716 //    }
 717 //}
 718 //
 719 //
 720 ////----- Check_D_MediaFmtForEraseAll() ----------------------------------
 721 //int Check_D_MediaFmtForEraseAll(PFDO_DEVICE_EXTENSION fdoExt)
 722 //{
 723 //    MediaChange  = ERROR;
 724 //    SectCopyMode = COMPLETED;
 725 //
 726 //    if (Set_D_PhyFmtValue(fdoExt))
 727 //    {
 728 //        ErrCode = ERR_UnknownMedia;
 729 //        return(ERROR);
 730 //    }
 731 //
 732 //    if (Search_D_CIS(fdoExt))
 733 //    {
 734 //        ErrCode = ERR_IllegalFmt;
 735 //        return(ERROR);
 736 //    }
 737 //
 738 //    return(SUCCESS);
 739 //}
 740 */
 741 //SmartMedia Physical Address Controll Subroutine
 742 //----- Conv_D_MediaAddr() ---------------------------------------------
 743 int Conv_D_MediaAddr(struct us_data *us, DWORD addr)
 744 {
 745         DWORD temp;
 746         //ULONG  zz;
 747         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 748         //ADDRESS_T   bb = (ADDRESS_T) &Media;
 749
 750         temp           = addr/Ssfdc.MaxSectors;
 751         Media.Zone     = (BYTE) (temp/Ssfdc.MaxLogBlocks);
 752
 753         if (Log2Phy[Media.Zone]==NULL)
 754         {
 755                 if (Make_D_LogTable(us))
 756                 {
 757                         ErrCode = ERR_IllegalFmt;
 758                         return(ERROR);
 759                 }
 760         }
 761
 762         Media.Sector   = (BYTE) (addr%Ssfdc.MaxSectors);
 763         Media.LogBlock = (WORD) (temp%Ssfdc.MaxLogBlocks);
 764
 765         if (Media.Zone<Ssfdc.MaxZones)
 766         {
 767                 Clr_D_RedundantData(Redundant);
 768                 Set_D_LogBlockAddr(Redundant);
 769                 Media.PhyBlock = Log2Phy[Media.Zone][Media.LogBlock];
 770                 return(SUCCESS);
 771         }
 772
 773         ErrCode = ERR_OutOfLBA;
 774         return(ERROR);
 775 }
 776
 777 //----- Inc_D_MediaAddr() ----------------------------------------------
 778 int Inc_D_MediaAddr(struct us_data *us)
 779 {
 780         WORD        LogBlock = Media.LogBlock;
 781         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 782         //ADDRESS_T   bb = (ADDRESS_T) &Media;
 783
 784         if (++Media.Sector<Ssfdc.MaxSectors)
 785                 return(SUCCESS);
 786
 787         if (Log2Phy[Media.Zone]==NULL)
 788         {
 789                 if (Make_D_LogTable(us))
 790                 {
 791                         ErrCode = ERR_IllegalFmt;
 792                         return(ERROR);
 793                 }
 794         }
 795
 796         Media.Sector=0;
 797         Media.LogBlock = LogBlock;
 798
 799         if (++Media.LogBlock<Ssfdc.MaxLogBlocks)
 800         {
 801                 Clr_D_RedundantData(Redundant);
 802                 Set_D_LogBlockAddr(Redundant);
 803                 Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock];
 804                 return(SUCCESS);
 805         }
 806
 807         Media.LogBlock=0;
 808
 809         if (++Media.Zone<Ssfdc.MaxZones)
 810         {
 811                 if (Log2Phy[Media.Zone]==NULL)
 812                 {
 813                         if (Make_D_LogTable(us))
 814                         {
 815                                 ErrCode = ERR_IllegalFmt;
 816                                 return(ERROR);
 817                         }
 818                 }
 819
 820                 Media.LogBlock = 0;
 821
 822                 Clr_D_RedundantData(Redundant);
 823                 Set_D_LogBlockAddr(Redundant);
 824                 Media.PhyBlock=Log2Phy[Media.Zone][Media.LogBlock];
 825                 return(SUCCESS);
 826         }
 827
 828         Media.Zone=0;
 829         ErrCode = ERR_OutOfLBA;
 830
 831         return(ERROR);
 832 }
 833 /*
 834 //----- Check_D_FirstSect() --------------------------------------------
 835 int Check_D_FirstSect(void)
 836 {
 837     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 838     ADDRESS_T   bb = (ADDRESS_T) &Media;
 839
 840     if (!Media.Sector)
 841         return(SUCCESS);
 842
 843     return(ERROR);
 844 }
 845
 846 //----- Check_D_LastSect() ---------------------------------------------
 847 int Check_D_LastSect(void)
 848 {
 849     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 850     ADDRESS_T   bb = (ADDRESS_T) &Media;
 851
 852     if (Media.Sector<(Ssfdc.MaxSectors-1))
 853         return(ERROR);
 854
 855     return(SUCCESS);
 856 }
 857 */
 858 //SmartMedia Read/Write Subroutine with Retry
 859 //----- Media_D_ReadOneSect() ------------------------------------------
 860 int Media_D_ReadOneSect(struct us_data *us, WORD count, BYTE *buf)
 861 {
 862         DWORD err, retry;
 863
 864         if (!Read_D_PhyOneSect(us, count, buf))
 865                 return(SUCCESS);
 866         if (ErrCode==ERR_HwError)
 867                 return(ERROR);
 868         if (ErrCode==ERR_DataStatus)
 869                 return(ERROR);
 870
 871 #ifdef RDERR_REASSIGN
 872         if (Ssfdc.Attribute &MWP)
 873         {
 874                 if (ErrCode==ERR_CorReadErr)
 875                         return(SUCCESS);
 876                 return(ERROR);
 877         }
 878
 879         err=ErrCode;
 880         for(retry=0; retry<2; retry++)
 881         {
 882                 if (Copy_D_BlockAll(us, (err==ERR_EccReadErr)?REQ_FAIL:REQ_ERASE))
 883                 {
 884                         if (ErrCode==ERR_HwError)
 885                                 return(ERROR);
 886                         continue;
 887                 }
 888
 889                 ErrCode = err;
 890                 if (ErrCode==ERR_CorReadErr)
 891                         return(SUCCESS);
 892                 return(ERROR);
 893         }
 894
 895         MediaChange = ERROR;
 896 #else
 897         if (ErrCode==ERR_CorReadErr) return(SUCCESS);
 898 #endif
 899
 900         return(ERROR);
 901 }
 902 /*
 903 //----- Media_D_WriteOneSect() -----------------------------------------
 904 int Media_D_WriteOneSect(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf)
 905 {
 906     DWORD retry;
 907     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 908     ADDRESS_T   bb = (ADDRESS_T) &Media;
 909
 910     if (!Write_D_PhyOneSect(fdoExt, count, buf))
 911         return(SUCCESS);
 912     if (ErrCode==ERR_HwError)
 913         return(ERROR);
 914
 915     for(retry=1; retry<2; retry++)
 916     {
 917         if (Reassign_D_BlockHead(fdoExt))
 918         {
 919             if (ErrCode==ERR_HwError)
 920                 return(ERROR);
 921             continue;
 922         }
 923
 924         if (!Write_D_PhyOneSect(fdoExt, count, buf))
 925             return(SUCCESS);
 926         if (ErrCode==ERR_HwError)
 927             return(ERROR);
 928     }
 929
 930     if (Release_D_WriteBlock(fdoExt))
 931         return(ERROR);
 932
 933     ErrCode        = ERR_WriteFault;
 934     MediaChange = ERROR;
 935     return(ERROR);
 936 }
 937
 938 //SmartMedia Data Copy Subroutine with Retry
 939 //----- Media_D_CopyBlockHead() ----------------------------------------
 940 int Media_D_CopyBlockHead(PFDO_DEVICE_EXTENSION fdoExt)
 941 {
 942     DWORD retry;
 943
 944     for(retry=0; retry<2; retry++)
 945     {
 946         if (!Copy_D_BlockHead(fdoExt))
 947             return(SUCCESS);
 948         if (ErrCode==ERR_HwError)
 949             return(ERROR);
 950     }
 951
 952     MediaChange = ERROR;
 953     return(ERROR);
 954 }
 955
 956 //----- Media_D_CopyBlockTail() ----------------------------------------
 957 int Media_D_CopyBlockTail(PFDO_DEVICE_EXTENSION fdoExt)
 958 {
 959     DWORD retry;
 960
 961     if (!Copy_D_BlockTail(fdoExt))
 962         return(SUCCESS);
 963     if (ErrCode==ERR_HwError)
 964         return(ERROR);
 965
 966     for(retry=1; retry<2; retry++)
 967     {
 968         if (Reassign_D_BlockHead(fdoExt))
 969         {
 970             if (ErrCode==ERR_HwError)
 971                 return(ERROR);
 972             continue;
 973         }
 974
 975         if (!Copy_D_BlockTail(fdoExt))
 976             return(SUCCESS);
 977         if (ErrCode==ERR_HwError)
 978             return(ERROR);
 979     }
 980
 981     if (Release_D_WriteBlock(fdoExt))
 982         return(ERROR);
 983
 984     ErrCode        = ERR_WriteFault;
 985     MediaChange = ERROR;
 986     return(ERROR);
 987 }
 988 //
 989 ////----- Media_D_EraseOneBlock() ----------------------------------------
 990 //int Media_D_EraseOneBlock(void)
 991 //{
 992 //    WORD        LogBlock = Media.LogBlock;
 993 //    WORD        PhyBlock = Media.PhyBlock;
 994 //    SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
 995 //    ADDRESS_T   bb = (ADDRESS_T) &Media;
 996 //
 997 //    if (Media.PhyBlock==NO_ASSIGN)
 998 //        return(SUCCESS);
 999 //
1000 //    if (Log2Phy[Media.Zone]==NULL)
1001 //    {
1002 //        if (Make_D_LogTable())
1003 //        {
1004 //            ErrCode = ERR_IllegalFmt;
1005 //            return(ERROR);
1006 //        }
1007 //    }
1008 //    Media.LogBlock = LogBlock;
1009 //    Media.PhyBlock = PhyBlock;
1010 //
1011 //    Log2Phy[Media.Zone][Media.LogBlock]=NO_ASSIGN;
1012 //
1013 //    if (Erase_D_PhyOneBlock(fdoExt))
1014 //    {
1015 //        if (ErrCode==ERR_HwError)
1016 //            return(ERROR);
1017 //        if (MarkFail_D_PhyOneBlock())
1018 //            return(ERROR);
1019 //
1020 //        ErrCode = ERR_WriteFault;
1021 //        return(ERROR);
1022 //    }
1023 //
1024 //    Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1025 //    Media.PhyBlock=NO_ASSIGN;
1026 //    return(SUCCESS);
1027 //}
1028 //
1029 ////SmartMedia Erase Subroutine
1030 ////----- Media_D_EraseAllBlock() ----------------------------------------
1031 //int Media_D_EraseAllBlock(void)
1032 //{
1033 //    WORD cis=0;
1034 //
1035 //    SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1036 //    ADDRESS_T   bb = (ADDRESS_T) &Media;
1037 //
1038 //    MediaChange = ERROR;
1039 //    Media.Sector   = 0;
1040 //
1041 //    for(Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++)
1042 //        for(Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++) {
1043 //            if (Ssfdc_D_ReadRedtData(Redundant))
1044 //            {
1045 //                Ssfdc_D_Reset(fdoExt);
1046 //                return(ERROR);
1047 //            }
1048 //
1049 //            Ssfdc_D_Reset(fdoExt);
1050 //            if (!Check_D_FailBlock(Redundant))
1051 //            {
1052 //                if (cis)
1053 //                {
1054 //                    if (Ssfdc_D_EraseBlock(fdoExt))
1055 //                    {
1056 //                        ErrCode = ERR_HwError;
1057 //                        return(ERROR);
1058 //                    }
1059 //
1060 //                    if (Ssfdc_D_CheckStatus())
1061 //                    {
1062 //                        if (MarkFail_D_PhyOneBlock())
1063 //                            return(ERROR);
1064 //                    }
1065 //
1066 //                    continue;
1067 //                }
1068 //
1069 //                if (Media.PhyBlock!=CisArea.PhyBlock)
1070 //                {
1071 //                    ErrCode = ERR_IllegalFmt;
1072 //                    return(ERROR);
1073 //                }
1074 //
1075 //                cis++;
1076 //            }
1077 //
1078 //        }
1079 //    return(SUCCESS);
1080 //}
1081 */
1082 //SmartMedia Physical Sector Data Copy Subroutine
1083 //----- Copy_D_BlockAll() ----------------------------------------------
1084 int Copy_D_BlockAll(struct us_data *us, DWORD mode)
1085 {
1086         BYTE sect;
1087         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1088         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1089
1090         sect=Media.Sector;
1091
1092         if (Assign_D_WriteBlock())
1093                 return(ERROR);
1094         if (mode==REQ_FAIL)
1095                 SectCopyMode=REQ_FAIL;
1096
1097         for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1098         {
1099                 if (Copy_D_PhyOneSect(us))
1100                 {
1101                         if (ErrCode==ERR_HwError)
1102                                 return(ERROR);
1103                         if (Release_D_WriteBlock(us))
1104                                 return(ERROR);
1105
1106                         ErrCode = ERR_WriteFault;
1107                         Media.PhyBlock=ReadBlock;
1108                         Media.Sector=sect;
1109
1110                         return(ERROR);
1111                 }
1112         }
1113
1114         if (Release_D_ReadBlock(us))
1115                 return(ERROR);
1116
1117         Media.PhyBlock=WriteBlock;
1118         Media.Sector=sect;
1119         return(SUCCESS);
1120 }
1121 /*
1122 //----- Copy_D_BlockHead() ---------------------------------------------
1123 int Copy_D_BlockHead(PFDO_DEVICE_EXTENSION fdoExt)
1124 {
1125     BYTE sect;
1126     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1127     ADDRESS_T   bb = (ADDRESS_T) &Media;
1128
1129     sect=Media.Sector;
1130     if (Assign_D_WriteBlock())
1131         return(ERROR);
1132
1133     for(Media.Sector=0; Media.Sector<sect; Media.Sector++)
1134     {
1135         if (Copy_D_PhyOneSect(fdoExt))
1136         {
1137             if (ErrCode==ERR_HwError)
1138                 return(ERROR);
1139             if (Release_D_WriteBlock(fdoExt))
1140                 return(ERROR);
1141
1142             ErrCode = ERR_WriteFault;
1143             Media.PhyBlock=ReadBlock;
1144             Media.Sector=sect;
1145
1146             return(ERROR);
1147         }
1148     }
1149
1150     Media.PhyBlock=WriteBlock;
1151     Media.Sector=sect;
1152     return(SUCCESS);
1153 }
1154
1155 //----- Copy_D_BlockTail() ---------------------------------------------
1156 int Copy_D_BlockTail(PFDO_DEVICE_EXTENSION fdoExt)
1157 {
1158     BYTE sect;
1159     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1160     ADDRESS_T   bb = (ADDRESS_T) &Media;
1161
1162     for(sect=Media.Sector; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1163     {
1164         if (Copy_D_PhyOneSect(fdoExt))
1165         {
1166             if (ErrCode==ERR_HwError)
1167                 return(ERROR);
1168
1169             Media.PhyBlock=WriteBlock;
1170             Media.Sector=sect;
1171
1172             return(ERROR);
1173         }
1174     }
1175
1176     if (Release_D_ReadBlock(fdoExt))
1177         return(ERROR);
1178
1179     Media.PhyBlock=WriteBlock;
1180     Media.Sector=sect;
1181     return(SUCCESS);
1182 }
1183
1184 //----- Reassign_D_BlockHead() -----------------------------------------
1185 int Reassign_D_BlockHead(PFDO_DEVICE_EXTENSION fdoExt)
1186 {
1187     DWORD  mode;
1188     WORD   block;
1189     BYTE   sect;
1190     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1191     ADDRESS_T   bb = (ADDRESS_T) &Media;
1192
1193     mode=SectCopyMode;
1194     block=ReadBlock;
1195     sect=Media.Sector;
1196
1197     if (Assign_D_WriteBlock())
1198         return(ERROR);
1199
1200     SectCopyMode=REQ_FAIL;
1201
1202     for(Media.Sector=0; Media.Sector<sect; Media.Sector++)
1203     {
1204         if (Copy_D_PhyOneSect(fdoExt))
1205         {
1206             if (ErrCode==ERR_HwError)
1207                 return(ERROR);
1208             if (Release_D_WriteBlock(fdoExt))
1209                 return(ERROR);
1210
1211             ErrCode = ERR_WriteFault;
1212             SectCopyMode=mode;
1213             WriteBlock=ReadBlock;
1214             ReadBlock=block;
1215             Media.Sector=sect;
1216             Media.PhyBlock=WriteBlock;
1217
1218             return(ERROR);
1219         }
1220     }
1221
1222     if (Release_D_ReadBlock(fdoExt))
1223         return(ERROR);
1224
1225     SectCopyMode=mode;
1226     ReadBlock=block;
1227     Media.Sector=sect;
1228     Media.PhyBlock=WriteBlock;
1229     return(SUCCESS);
1230 }
1231 */
1232 //SmartMedia Physical Block Assign/Release Subroutine
1233 //----- Assign_D_WriteBlock() ------------------------------------------
1234 int Assign_D_WriteBlock(void)
1235 {
1236         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1237         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1238         ReadBlock=Media.PhyBlock;
1239
1240         for(WriteBlock=AssignStart[Media.Zone]; WriteBlock<Ssfdc.MaxBlocks; WriteBlock++)
1241         {
1242                 if (!Chk_D_Bit(Assign[Media.Zone],WriteBlock))
1243                 {
1244                         Set_D_Bit(Assign[Media.Zone],WriteBlock);
1245                         AssignStart[Media.Zone]=WriteBlock+1;
1246                         Media.PhyBlock=WriteBlock;
1247                         SectCopyMode=REQ_ERASE;
1248                         //ErrXDCode = NO_ERROR;
1249                         return(SUCCESS);
1250                 }
1251         }
1252
1253         for(WriteBlock=0; WriteBlock<AssignStart[Media.Zone]; WriteBlock++)
1254         {
1255                 if (!Chk_D_Bit(Assign[Media.Zone],WriteBlock))
1256                 {
1257                         Set_D_Bit(Assign[Media.Zone],WriteBlock);
1258                         AssignStart[Media.Zone]=WriteBlock+1;
1259                         Media.PhyBlock=WriteBlock;
1260                         SectCopyMode=REQ_ERASE;
1261                         //ErrXDCode = NO_ERROR;
1262                         return(SUCCESS);
1263                 }
1264         }
1265
1266         WriteBlock=NO_ASSIGN;
1267         ErrCode = ERR_WriteFault;
1268         // For xD test
1269         //Ssfdc.Attribute |= WP;
1270         //ErrXDCode = ERR_WrtProtect;
1271         return(ERROR);
1272 }
1273
1274 //----- Release_D_ReadBlock() ------------------------------------------
1275 int Release_D_ReadBlock(struct us_data *us)
1276 {
1277         DWORD mode;
1278         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1279         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1280
1281         mode=SectCopyMode;
1282         SectCopyMode=COMPLETED;
1283
1284         if (mode==COMPLETED)
1285                 return(SUCCESS);
1286
1287         Log2Phy[Media.Zone][Media.LogBlock]=WriteBlock;
1288         Media.PhyBlock=ReadBlock;
1289
1290         if (Media.PhyBlock==NO_ASSIGN)
1291         {
1292                 Media.PhyBlock=WriteBlock;
1293                 return(SUCCESS);
1294         }
1295
1296         if (mode==REQ_ERASE)
1297         {
1298                 if (Erase_D_PhyOneBlock(us))
1299                 {
1300                         if (ErrCode==ERR_HwError) return(ERROR);
1301                         if (MarkFail_D_PhyOneBlock(us)) return(ERROR);
1302                 }
1303                 else
1304                         Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1305         }
1306         else if (MarkFail_D_PhyOneBlock(us))
1307                 return(ERROR);
1308
1309         Media.PhyBlock=WriteBlock;
1310         return(SUCCESS);
1311 }
1312
1313 //----- Release_D_WriteBlock() -----------------------------------------
1314 int Release_D_WriteBlock(struct us_data *us)
1315 {
1316         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1317         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1318         SectCopyMode=COMPLETED;
1319         Media.PhyBlock=WriteBlock;
1320
1321         if (MarkFail_D_PhyOneBlock(us))
1322                 return(ERROR);
1323
1324         Media.PhyBlock=ReadBlock;
1325         return(SUCCESS);
1326 }
1327
1328 //SmartMedia Physical Sector Data Copy Subroutine
1329 //----- Copy_D_PhyOneSect() --------------------------------------------
1330 int Copy_D_PhyOneSect(struct us_data *us)
1331 {
1332         int           i;
1333         DWORD  err, retry;
1334         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1335         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1336
1337         //printk("Copy_D_PhyOneSect --- Secotr = %x\n", Media.Sector);
1338         if (ReadBlock!=NO_ASSIGN)
1339         {
1340                 Media.PhyBlock=ReadBlock;
1341                 for(retry=0; retry<2; retry++)
1342                 {
1343                         if (retry!=0)
1344                         {
1345                                 Ssfdc_D_Reset(us);
1346                                 if (Ssfdc_D_ReadCisSect(us,WorkBuf,WorkRedund))
1347                                 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1348
1349                                 if (Check_D_CISdata(WorkBuf,WorkRedund))
1350                                 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1351                         }
1352
1353                         if (Ssfdc_D_ReadSect(us,WorkBuf,WorkRedund))
1354                         { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1355                         if (Check_D_DataStatus(WorkRedund))
1356                         { err=ERROR; break; }
1357                         if (!Check_D_ReadError(WorkRedund))
1358                         { err=SUCCESS; break; }
1359                         if (!Check_D_Correct(WorkBuf,WorkRedund))
1360                         { err=SUCCESS; break; }
1361
1362                         err=ERROR;
1363                         SectCopyMode=REQ_FAIL;
1364                 }
1365         }
1366         else
1367         {
1368                 err=SUCCESS;
1369                 for(i=0; i<SECTSIZE; i++)
1370                         WorkBuf[i]=DUMMY_DATA;
1371                 Clr_D_RedundantData(WorkRedund);
1372         }
1373
1374         Set_D_LogBlockAddr(WorkRedund);
1375         if (err==ERROR)
1376         {
1377                 Set_D_RightECC(WorkRedund);
1378                 Set_D_DataStaus(WorkRedund);
1379         }
1380
1381         Media.PhyBlock=WriteBlock;
1382
1383         if (Ssfdc_D_WriteSectForCopy(us, WorkBuf, WorkRedund))
1384         { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1385         if (Ssfdc_D_CheckStatus())
1386         { ErrCode = ERR_WriteFault; return(ERROR); }
1387
1388         Media.PhyBlock=ReadBlock;
1389         return(SUCCESS);
1390 }
1391
1392 //SmartMedia Physical Sector Read/Write/Erase Subroutine
1393 //----- Read_D_PhyOneSect() --------------------------------------------
1394 int Read_D_PhyOneSect(struct us_data *us, WORD count, BYTE *buf)
1395 {
1396         int           i;
1397         DWORD  retry;
1398         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1399         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1400
1401         if (Media.PhyBlock==NO_ASSIGN)
1402         {
1403                 for(i=0; i<SECTSIZE; i++)
1404                         *buf++=DUMMY_DATA;
1405                 return(SUCCESS);
1406         }
1407
1408         for(retry=0; retry<2; retry++)
1409         {
1410                 if (retry!=0)
1411                 {
1412                         Ssfdc_D_Reset(us);
1413
1414                         if (Ssfdc_D_ReadCisSect(us,WorkBuf,WorkRedund))
1415                         { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1416                         if (Check_D_CISdata(WorkBuf,WorkRedund))
1417                         { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1418                 }
1419
1420                 //if (Ssfdc_D_ReadSect(fdoExt,buf,Redundant))
1421                 if (Ssfdc_D_ReadBlock(us,count,buf,Redundant))
1422                 { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1423                 if (Check_D_DataStatus(Redundant))
1424                 { ErrCode = ERR_DataStatus; return(ERROR); }
1425
1426                 if (!Check_D_ReadError(Redundant))
1427                         return(SUCCESS);
1428
1429                 if (!Check_D_Correct(buf,Redundant))
1430                 { ErrCode = ERR_CorReadErr; return(ERROR); }
1431         }
1432
1433         ErrCode = ERR_EccReadErr;
1434         return(ERROR);
1435 }
1436 /*
1437 //----- Write_D_PhyOneSect() -------------------------------------------
1438 int Write_D_PhyOneSect(PFDO_DEVICE_EXTENSION fdoExt, WORD count, BYTE *buf)
1439 {
1440     SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1441     ADDRESS_T   bb = (ADDRESS_T) &Media;
1442
1443     //if (Ssfdc_D_WriteSect(fdoExt,buf,Redundant))
1444     if (Ssfdc_D_WriteBlock(fdoExt,count,buf,Redundant))
1445     { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1446     if (Ssfdc_D_CheckStatus())
1447     { ErrCode = ERR_WriteFault; return(ERROR); }
1448
1449     return(SUCCESS);
1450 }
1451 */
1452 //----- Erase_D_PhyOneBlock() ------------------------------------------
1453 int Erase_D_PhyOneBlock(struct us_data *us)
1454 {
1455         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1456         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1457
1458         if (Ssfdc_D_EraseBlock(us))
1459         { ErrCode = ERR_HwError; MediaChange=ERROR; return(ERROR); }
1460         if (Ssfdc_D_CheckStatus())
1461         { ErrCode = ERR_WriteFault; return(ERROR); }
1462
1463         return(SUCCESS);
1464 }
1465
1466 //SmartMedia Physical Format Check Local Subroutine
1467 //----- Set_D_PhyFmtValue() --------------------------------------------
1468 int Set_D_PhyFmtValue(struct us_data *us)
1469 {
1470 //    PPDO_DEVICE_EXTENSION   pdoExt;
1471 //    BYTE      idcode[4];
1472 //    DWORD     UserDefData_1, UserDefData_2, Data, mask;
1473 //
1474 //    //if (!fdoExt->ChildDeviceObject)       return(ERROR);
1475 //    //pdoExt = fdoExt->ChildDeviceObject->DeviceExtension;
1476 //
1477 //    Ssfdc_D_ReadID(idcode, READ_ID_1);
1478 //
1479     //if (Set_D_SsfdcModel(idcode[1]))
1480     if (Set_D_SsfdcModel(us->SM_DeviceID))
1481         return(ERROR);
1482
1483 //    //Use Multi-function pin to differentiate SM and xD.
1484 //    UserDefData_1 = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, fdoExt->FuncID, PCI_REG_USER_DEF) & 0x80;
1485 //    if (UserDefData_1)
1486 //    {
1487 //       if ( READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x80 )      fdoExt->DiskType = DISKTYPE_XD;
1488 //       if ( READ_PORT_BYTE(SM_REG_INT_STATUS) & 0x40 )      fdoExt->DiskType = DISKTYPE_SM;
1489 //
1490 //       if ( IsXDCompliance && (fdoExt->DiskType == DISKTYPE_XD) )
1491 //       {
1492 //          Ssfdc_D_ReadID(idcode, READ_ID_3);
1493 //          if (idcode[2] != 0xB5)
1494 //             return(ERROR);
1495 //       }
1496 //    }
1497 //
1498 //    //Use GPIO to differentiate SM and xD.
1499 //    UserDefData_2 = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, fdoExt->FuncID, PCI_REG_USER_DEF) >> 8;
1500 //    if ( UserDefData_2 )
1501 //    {
1502 //       Data = ReadPCIReg(fdoExt->BusID, fdoExt->DevID, 0, 0xAC);
1503 //
1504 //       mask = 1 << (UserDefData_2-1);
1505 //       // 1 : xD , 0 : SM
1506 //       if ( Data & mask)
1507 //          fdoExt->DiskType = DISKTYPE_XD;
1508 //       else
1509 //          fdoExt->DiskType = DISKTYPE_SM;
1510 //
1511 //       if ( IsXDCompliance && (fdoExt->DiskType == DISKTYPE_XD) )
1512 //       {
1513 //          Ssfdc_D_ReadID(idcode, READ_ID_3);
1514 //          if (idcode[2] != 0xB5)
1515 //             return(ERROR);
1516 //       }
1517 //    }
1518 //
1519 //    if ( !(UserDefData_1 | UserDefData_2) )
1520 //    {
1521 //      // Use UserDefine Register to differentiate SM and xD.
1522 //      Ssfdc_D_ReadID(idcode, READ_ID_3);
1523 //
1524 //      if (idcode[2] == 0xB5)
1525 //         fdoExt->DiskType = DISKTYPE_XD;
1526 //      else
1527 //      {
1528 //          if (!IsXDCompliance)
1529 //             fdoExt->DiskType = DISKTYPE_SM;
1530 //          else
1531 //             return(ERROR);
1532 //      }
1533 //
1534 //      if (fdoExt->UserDef_DiskType == 0x04)  fdoExt->DiskType = DISKTYPE_XD;
1535 //      if (fdoExt->UserDef_DiskType == 0x08)  fdoExt->DiskType = DISKTYPE_SM;
1536 //    }
1537 //
1538 //    if (!fdoExt->UserDef_DisableWP)
1539 //    {
1540 //       if (fdoExt->DiskType == DISKTYPE_SM)
1541 //       {
1542 //           if (Check_D_SsfdcWP())
1543 //              Ssfdc.Attribute|=WP;
1544 //       }
1545 //    }
1546
1547     return(SUCCESS);
1548 }
1549
1550 //----- Search_D_CIS() -------------------------------------------------
1551 int Search_D_CIS(struct us_data *us)
1552 {
1553         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1554         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1555
1556         Media.Zone=0; Media.Sector=0;
1557
1558         for (Media.PhyBlock=0; Media.PhyBlock<(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1); Media.PhyBlock++)
1559         {
1560                 if (Ssfdc_D_ReadRedtData(us, Redundant))
1561                 {
1562                         Ssfdc_D_Reset(us);
1563                         return(ERROR);
1564                 }
1565
1566                 if (!Check_D_FailBlock(Redundant))
1567                         break;
1568         }
1569
1570         if (Media.PhyBlock==(Ssfdc.MaxBlocks-Ssfdc.MaxLogBlocks-1))
1571         {
1572                 Ssfdc_D_Reset(us);
1573                 return(ERROR);
1574         }
1575
1576         while (Media.Sector<CIS_SEARCH_SECT)
1577         {
1578                 if (Media.Sector)
1579                 {
1580                         if (Ssfdc_D_ReadRedtData(us, Redundant))
1581                         {
1582                                 Ssfdc_D_Reset(us);
1583                                 return(ERROR);
1584                         }
1585                 }
1586                 if (!Check_D_DataStatus(Redundant))
1587                 {
1588                         if (Ssfdc_D_ReadSect(us,WorkBuf,Redundant))
1589                         {
1590                                 Ssfdc_D_Reset(us);
1591                                 return(ERROR);
1592                         }
1593
1594                         if (Check_D_CISdata(WorkBuf,Redundant))
1595                         {
1596                                 Ssfdc_D_Reset(us);
1597                                 return(ERROR);
1598                         }
1599
1600                         CisArea.PhyBlock=Media.PhyBlock;
1601                         CisArea.Sector=Media.Sector;
1602                         Ssfdc_D_Reset(us);
1603                         return(SUCCESS);
1604                 }
1605
1606                 Media.Sector++;
1607         }
1608
1609         Ssfdc_D_Reset(us);
1610         return(ERROR);
1611 }
1612
1613 //----- Make_D_LogTable() ----------------------------------------------
1614 int Make_D_LogTable(struct us_data *us)
1615 {
1616         WORD  phyblock,logblock;
1617         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1618         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1619
1620         if (Log2Phy[Media.Zone]==NULL)
1621         {
1622                 Log2Phy[Media.Zone] = kmalloc(MAX_LOGBLOCK*sizeof(WORD), GFP_KERNEL);
1623                 //printk("ExAllocatePool Zone = %x, Addr = %x\n", Media.Zone, Log2Phy[Media.Zone]);
1624                 if (Log2Phy[Media.Zone]==NULL)
1625                         return(ERROR);
1626         }
1627
1628         Media.Sector=0;
1629
1630         //for(Media.Zone=0; Media.Zone<MAX_ZONENUM; Media.Zone++)
1631         //for(Media.Zone=0; Media.Zone<Ssfdc.MaxZones; Media.Zone++)
1632         {
1633                 //printk("Make_D_LogTable --- MediaZone = 0x%x\n", Media.Zone);
1634                 for(Media.LogBlock=0; Media.LogBlock<Ssfdc.MaxLogBlocks; Media.LogBlock++)
1635                         Log2Phy[Media.Zone][Media.LogBlock]=NO_ASSIGN;
1636
1637                 for(Media.PhyBlock=0; Media.PhyBlock<(MAX_BLOCKNUM/8); Media.PhyBlock++)
1638                         Assign[Media.Zone][Media.PhyBlock]=0x00;
1639
1640                 for(Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++)
1641                 {
1642                         if ((!Media.Zone) && (Media.PhyBlock<=CisArea.PhyBlock))
1643                         {
1644                                 Set_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1645                                 continue;
1646                         }
1647
1648                         if (Ssfdc_D_ReadRedtData(us, Redundant))
1649                         { Ssfdc_D_Reset(us); return(ERROR); }
1650
1651                         if (!Check_D_DataBlank(Redundant))
1652                                 continue;
1653
1654                         Set_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1655
1656                         if (Check_D_FailBlock(Redundant))
1657                                 continue;
1658
1659                         //if (Check_D_DataStatus(Redundant))
1660                         //    continue;
1661
1662                         if (Load_D_LogBlockAddr(Redundant))
1663                                 continue;
1664
1665                         if (Media.LogBlock>=Ssfdc.MaxLogBlocks)
1666                                 continue;
1667
1668                         if (Log2Phy[Media.Zone][Media.LogBlock]==NO_ASSIGN)
1669                         {
1670                                 Log2Phy[Media.Zone][Media.LogBlock]=Media.PhyBlock;
1671                                 continue;
1672                         }
1673
1674                         phyblock     = Media.PhyBlock;
1675                         logblock     = Media.LogBlock;
1676                         Media.Sector = (BYTE)(Ssfdc.MaxSectors-1);
1677
1678                         if (Ssfdc_D_ReadRedtData(us, Redundant))
1679                         { Ssfdc_D_Reset(us); return(ERROR); }
1680
1681                         if (!Load_D_LogBlockAddr(Redundant))
1682                         {
1683                                 if (Media.LogBlock==logblock)
1684                                 {
1685                                         Media.PhyBlock=Log2Phy[Media.Zone][logblock];
1686
1687                                         if (Ssfdc_D_ReadRedtData(us, Redundant))
1688                                         { Ssfdc_D_Reset(us); return(ERROR); }
1689
1690                                         Media.PhyBlock=phyblock;
1691
1692                                         if (!Load_D_LogBlockAddr(Redundant))
1693                                         {
1694                                                 if (Media.LogBlock!=logblock)
1695                                                 {
1696                                                         Media.PhyBlock=Log2Phy[Media.Zone][logblock];
1697                                                         Log2Phy[Media.Zone][logblock]=phyblock;
1698                                                 }
1699                                         }
1700                                         else
1701                                         {
1702                                                 Media.PhyBlock=Log2Phy[Media.Zone][logblock];
1703                                                 Log2Phy[Media.Zone][logblock]=phyblock;
1704                                         }
1705                                 }
1706                         }
1707
1708                         Media.Sector=0;
1709
1710 // here Not yet
1711 //#ifdef L2P_ERR_ERASE
1712 //                      if (!(Ssfdc.Attribute &MWP))
1713 //                      {
1714 //                              Ssfdc_D_Reset(fdoExt);
1715 //                              if (Ssfdc_D_EraseBlock(fdoExt))
1716 //                                      return(ERROR);
1717 //
1718 //                              if (Ssfdc_D_CheckStatus())
1719 //                              {
1720 //                                      if (MarkFail_D_PhyOneBlock())
1721 //                                              return(ERROR);
1722 //                              }
1723 //                              else
1724 //                                      Clr_D_Bit(Assign[Media.Zone],Media.PhyBlock);
1725 //                      }
1726 //#else
1727 //                      Ssfdc.Attribute|=MWP;
1728 //#endif
1729                         Media.PhyBlock=phyblock;
1730
1731                 } // End for (Media.PhyBlock<Ssfdc.MaxBlocks)
1732
1733                 AssignStart[Media.Zone]=0;
1734
1735         } // End for (Media.Zone<MAX_ZONENUM)
1736
1737         Ssfdc_D_Reset(us);
1738         return(SUCCESS);
1739 }
1740
1741 //----- MarkFail_D_PhyOneBlock() ---------------------------------------
1742 int MarkFail_D_PhyOneBlock(struct us_data *us)
1743 {
1744         BYTE sect;
1745         //SSFDCTYPE_T aa = (SSFDCTYPE_T ) &Ssfdc;
1746         //ADDRESS_T   bb = (ADDRESS_T) &Media;
1747
1748         sect=Media.Sector;
1749         Set_D_FailBlock(WorkRedund);
1750         //Ssfdc_D_WriteRedtMode();
1751
1752         for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1753         {
1754                 if (Ssfdc_D_WriteRedtData(us, WorkRedund))
1755                 {
1756                         Ssfdc_D_Reset(us);
1757                         Media.Sector   = sect;
1758                         ErrCode        = ERR_HwError;
1759                         MediaChange = ERROR;
1760                         return(ERROR);
1761                 } // NO Status Check
1762         }
1763
1764         Ssfdc_D_Reset(us);
1765         Media.Sector=sect;
1766         return(SUCCESS);
1767 }
1768 /*
1769 //
1770 ////----- SM_Init() ----------------------------------------------------
1771 //void SM_Init(void)
1772 //{
1773 //    _Hw_D_ClrIntCardChg();
1774 //    _Hw_D_SetIntMask();
1775 //    // For DMA Interrupt
1776 //    _Hw_D_ClrDMAIntCardChg();
1777 //    _Hw_D_SetDMAIntMask();
1778 //}
1779 //
1780 ////----- Media_D_EraseAllRedtData() -----------------------------------
1781 //int Media_D_EraseAllRedtData(DWORD Index, BOOLEAN CheckBlock)
1782 //{
1783 //    BYTE    i;
1784 //
1785 //    if (Check_D_MediaPower())
1786 //        return(ErrCode);
1787 //
1788 //    if (Check_D_MediaWP())
1789 //        return(ErrCode);
1790 //
1791 //    for (i=0; i<REDTSIZE; i++)
1792 //        WorkRedund[i] = 0xFF;
1793 //
1794 //    Media.Zone = (BYTE)Index;
1795 //    for (Media.PhyBlock=0; Media.PhyBlock<Ssfdc.MaxBlocks; Media.PhyBlock++)
1796 //    {
1797 //        if ((!Media.Zone) && (Media.PhyBlock<=CisArea.PhyBlock))
1798 //            continue;
1799 //
1800 //        if (Ssfdc_D_EraseBlock(fdoExt))
1801 //        {
1802 //            ErrCode = ERR_HwError;
1803 //            return(ERROR);
1804 //        }
1805 //
1806 //        for(Media.Sector=0; Media.Sector<Ssfdc.MaxSectors; Media.Sector++)
1807 //        {
1808 //            Ssfdc_D_WriteRedtMode();
1809 //
1810 //            if (Ssfdc_D_WriteRedtData(WorkRedund))
1811 //            {
1812 //                Ssfdc_D_Reset(fdoExt);
1813 //                ErrCode        = ERR_HwError;
1814 //                MediaChange    = ERROR;
1815 //                return(ERROR);
1816 //            } // NO Status Check
1817 //        }
1818 //
1819 //        Ssfdc_D_Reset(fdoExt);
1820 //    }
1821 //
1822 //    Ssfdc_D_Reset(fdoExt);
1823 //
1824 //    return(SUCCESS);
1825 //}
1826 //
1827 ////----- Media_D_GetMediaInfo() ---------------------------------------
1828 //DWORD Media_D_GetMediaInfo(PFDO_DEVICE_EXTENSION fdoExt, PIOCTL_MEDIA_INFO_IN pParamIn, PIOCTL_MEDIA_INFO_OUT pParamOut)
1829 //{
1830 //    pParamOut->ErrCode = STATUS_CMD_FAIL;
1831 //
1832 //    Init_D_SmartMedia();
1833 //
1834 //    if (Check_D_MediaPower())
1835 //        return (ErrCode==ERR_NoSmartMedia) ? STATUS_CMD_NO_MEDIA : STATUS_CMD_FAIL;
1836 //
1837 //    if (Set_D_PhyFmtValue(fdoExt))
1838 //        return STATUS_CMD_FAIL;
1839 //
1840 //    //usleep(56*1024);
1841 //    if (Search_D_CIS(fdoExt))
1842 //        return STATUS_CMD_FAIL;
1843 //
1844 //    if (Check_D_MediaWP())
1845 //        return STATUS_CMD_MEDIA_WP;
1846 //
1847 //    pParamOut->PageSize  = Ssfdc.MaxSectors;
1848 //    pParamOut->BlockSize = Ssfdc.MaxBlocks;
1849 //    pParamOut->ZoneSize  = Ssfdc.MaxZones;
1850 //
1851 //    return STATUS_CMD_SUCCESS;
1852 //}*/