Pileus Git - ~andy/linux/blob - drivers/staging/keucr/ms.c

   1 #include <linux/slab.h>
   2 #include <asm/byteorder.h>
   3
   4 #include "usb.h"
   5 #include "scsiglue.h"
   6 #include "transport.h"
   7 #include "ms.h"
   8
   9 //----- MS_ReaderCopyBlock() ------------------------------------------
  10 int MS_ReaderCopyBlock(struct us_data *us, WORD oldphy, WORD newphy, WORD PhyBlockAddr, BYTE PageNum, PBYTE buf, WORD len)
  11 {
  12         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
  13         int     result;
  14
  15         //printk("MS_ReaderCopyBlock --- PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum);
  16         result = ENE_LoadBinCode(us, MS_RW_PATTERN);
  17         if (result != USB_STOR_XFER_GOOD)
  18                 return USB_STOR_TRANSPORT_ERROR;
  19
  20         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
  21         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
  22         bcb->DataTransferLength = 0x200*len;
  23         bcb->Flags                      = 0x00;
  24         bcb->CDB[0]                     = 0xF0;
  25         bcb->CDB[1]                     = 0x08;
  26         bcb->CDB[4]                     = (BYTE)(oldphy);
  27         bcb->CDB[3]                     = (BYTE)(oldphy>>8);
  28         bcb->CDB[2]                     = (BYTE)(oldphy>>16);
  29         bcb->CDB[7]                     = (BYTE)(newphy);
  30         bcb->CDB[6]                     = (BYTE)(newphy>>8);
  31         bcb->CDB[5]                     = (BYTE)(newphy>>16);
  32         bcb->CDB[9]                     = (BYTE)(PhyBlockAddr);
  33         bcb->CDB[8]                     = (BYTE)(PhyBlockAddr>>8);
  34         bcb->CDB[10]            = PageNum;
  35
  36         result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
  37         if (result != USB_STOR_XFER_GOOD)
  38                 return USB_STOR_TRANSPORT_ERROR;
  39
  40         return USB_STOR_TRANSPORT_GOOD;
  41 }
  42
  43 //----- MS_ReaderReadPage() ------------------------------------------
  44 int MS_ReaderReadPage(struct us_data *us, DWORD PhyBlockAddr, BYTE PageNum, PDWORD PageBuf, MS_LibTypeExtdat *ExtraDat)
  45 {
  46         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
  47         int     result;
  48         BYTE    ExtBuf[4];
  49         DWORD   bn = PhyBlockAddr * 0x20 + PageNum;
  50
  51         //printk("MS --- MS_ReaderReadPage,  PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum);
  52
  53         result = ENE_LoadBinCode(us, MS_RW_PATTERN);
  54         if (result != USB_STOR_XFER_GOOD)
  55                 return USB_STOR_TRANSPORT_ERROR;
  56
  57         // Read Page Data
  58         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
  59         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
  60         bcb->DataTransferLength = 0x200;
  61         bcb->Flags                      = 0x80;
  62         bcb->CDB[0]                     = 0xF1;
  63         bcb->CDB[1]                     = 0x02;
  64         bcb->CDB[5]                     = (BYTE)(bn);
  65         bcb->CDB[4]                     = (BYTE)(bn>>8);
  66         bcb->CDB[3]                     = (BYTE)(bn>>16);
  67         bcb->CDB[2]                     = (BYTE)(bn>>24);
  68
  69         result = ENE_SendScsiCmd(us, FDIR_READ, PageBuf, 0);
  70         if (result != USB_STOR_XFER_GOOD)
  71                 return USB_STOR_TRANSPORT_ERROR;
  72
  73         // Read Extra Data
  74         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
  75         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
  76         bcb->DataTransferLength = 0x4;
  77         bcb->Flags                      = 0x80;
  78         bcb->CDB[0]                     = 0xF1;
  79         bcb->CDB[1]                     = 0x03;
  80         bcb->CDB[5]                     = (BYTE)(PageNum);
  81         bcb->CDB[4]                     = (BYTE)(PhyBlockAddr);
  82         bcb->CDB[3]                     = (BYTE)(PhyBlockAddr>>8);
  83         bcb->CDB[2]                     = (BYTE)(PhyBlockAddr>>16);
  84         bcb->CDB[6]                     = 0x01;
  85
  86         result = ENE_SendScsiCmd(us, FDIR_READ, &ExtBuf, 0);
  87         if (result != USB_STOR_XFER_GOOD)
  88                 return USB_STOR_TRANSPORT_ERROR;
  89
  90         ExtraDat->reserved = 0;
  91         ExtraDat->intr     = 0x80;  // Not yet, ¥ý°²³], µ¥ fireware support
  92         ExtraDat->status0  = 0x10;  // Not yet, ¥ý°²³], µ¥ fireware support
  93         ExtraDat->status1  = 0x00;  // Not yet, ¥ý°²³], µ¥ fireware support
  94         ExtraDat->ovrflg   = ExtBuf[0];
  95         ExtraDat->mngflg   = ExtBuf[1];
  96         ExtraDat->logadr   = MemStickLogAddr(ExtBuf[2], ExtBuf[3]);
  97
  98         return USB_STOR_TRANSPORT_GOOD;
  99 }
 100
 101 //----- MS_ReaderEraseBlock() ----------------------------------------
 102 int MS_ReaderEraseBlock(struct us_data *us, DWORD PhyBlockAddr)
 103 {
 104         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 105         int     result;
 106         DWORD   bn = PhyBlockAddr;
 107
 108         //printk("MS --- MS_ReaderEraseBlock,  PhyBlockAddr = %x\n", PhyBlockAddr);
 109         result = ENE_LoadBinCode(us, MS_RW_PATTERN);
 110         if (result != USB_STOR_XFER_GOOD)
 111                 return USB_STOR_TRANSPORT_ERROR;
 112
 113         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 114         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 115         bcb->DataTransferLength = 0x200;
 116         bcb->Flags                      = 0x80;
 117         bcb->CDB[0]                     = 0xF2;
 118         bcb->CDB[1]                     = 0x06;
 119         bcb->CDB[4]                     = (BYTE)(bn);
 120         bcb->CDB[3]                     = (BYTE)(bn>>8);
 121         bcb->CDB[2]                     = (BYTE)(bn>>16);
 122
 123         result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
 124         if (result != USB_STOR_XFER_GOOD)
 125                 return USB_STOR_TRANSPORT_ERROR;
 126
 127         return USB_STOR_TRANSPORT_GOOD;
 128 }
 129
 130 //----- MS_CardInit() ------------------------------------------------
 131 int MS_CardInit(struct us_data *us)
 132 {
 133         DWORD                   result=0;
 134         WORD                    TmpBlock;
 135         PBYTE                   PageBuffer0 = NULL, PageBuffer1 = NULL;
 136         MS_LibTypeExtdat        extdat;
 137         WORD                    btBlk1st, btBlk2nd;
 138         DWORD                   btBlk1stErred;
 139
 140         printk("MS_CardInit start\n");
 141
 142         MS_LibFreeAllocatedArea(us);
 143
 144         if (((PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL)) == NULL) ||
 145             ((PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL)) == NULL))
 146         {
 147                 result = MS_NO_MEMORY_ERROR;
 148                 goto exit;
 149         }
 150
 151         btBlk1st = btBlk2nd = MS_LB_NOT_USED;
 152         btBlk1stErred = 0;
 153
 154         for (TmpBlock=0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++)
 155         {
 156                 switch (MS_ReaderReadPage(us, TmpBlock, 0, (DWORD *)PageBuffer0, &extdat))
 157                 {
 158                         case MS_STATUS_SUCCESS:
 159                         break;
 160                         case MS_STATUS_INT_ERROR:
 161                         break;
 162                         case MS_STATUS_ERROR:
 163                         default:
 164                         continue;
 165                 }
 166
 167                 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
 168                         continue;
 169
 170                 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
 171                         (be16_to_cpu(((MemStickBootBlockPage0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
 172                         (be16_to_cpu(((MemStickBootBlockPage0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
 173                         (((MemStickBootBlockPage0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
 174                                 continue;
 175
 176                 if (btBlk1st != MS_LB_NOT_USED)
 177                 {
 178                         btBlk2nd = TmpBlock;
 179                         break;
 180                 }
 181
 182                 btBlk1st = TmpBlock;
 183                 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
 184                 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
 185                         btBlk1stErred = 1;
 186         }
 187
 188         if (btBlk1st == MS_LB_NOT_USED)
 189         {
 190                 result = MS_STATUS_ERROR;
 191                 goto exit;
 192         }
 193
 194         // write protect
 195         if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
 196                 MS_LibCtrlSet(us, MS_LIB_CTRL_WRPROTECT);
 197
 198         result = MS_STATUS_ERROR;
 199         // 1st Boot Block
 200         if (btBlk1stErred == 0)
 201                 result = MS_LibProcessBootBlock(us, btBlk1st, PageBuffer1);   // 1st
 202         // 2nd Boot Block
 203         if (result && (btBlk2nd != MS_LB_NOT_USED))
 204                 result = MS_LibProcessBootBlock(us, btBlk2nd, PageBuffer0);
 205
 206         if (result)
 207         {
 208                 result = MS_STATUS_ERROR;
 209                 goto exit;
 210         }
 211
 212         for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
 213                 us->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
 214
 215         us->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
 216
 217         if (btBlk2nd != MS_LB_NOT_USED)
 218         {
 219                 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
 220                         us->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
 221                 us->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
 222         }
 223
 224         result = MS_LibScanLogicalBlockNumber(us, btBlk1st);
 225         if (result)
 226                 goto exit;
 227
 228         for (TmpBlock=MS_PHYSICAL_BLOCKS_PER_SEGMENT; TmpBlock<us->MS_Lib.NumberOfPhyBlock; TmpBlock+=MS_PHYSICAL_BLOCKS_PER_SEGMENT)
 229         {
 230                 if (MS_CountFreeBlock(us, TmpBlock) == 0)
 231                 {
 232                         MS_LibCtrlSet(us, MS_LIB_CTRL_WRPROTECT);
 233                         break;
 234                 }
 235         }
 236
 237         // write
 238         if (MS_LibAllocWriteBuf(us))
 239         {
 240                 result = MS_NO_MEMORY_ERROR;
 241                 goto exit;
 242         }
 243
 244         result = MS_STATUS_SUCCESS;
 245
 246 exit:
 247         kfree(PageBuffer1);
 248         kfree(PageBuffer0);
 249
 250         printk("MS_CardInit end\n");
 251         return result;
 252 }
 253
 254 //----- MS_LibCheckDisableBlock() ------------------------------------
 255 int MS_LibCheckDisableBlock(struct us_data *us, WORD PhyBlock)
 256 {
 257         PWORD                   PageBuf=NULL;
 258         DWORD                   result=MS_STATUS_SUCCESS;
 259         DWORD                   blk, index=0;
 260         MS_LibTypeExtdat        extdat;
 261
 262         if (((PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL)) == NULL))
 263         {
 264                 result = MS_NO_MEMORY_ERROR;
 265                 goto exit;
 266         }
 267
 268         MS_ReaderReadPage(us, PhyBlock, 1, (DWORD *)PageBuf, &extdat);
 269         do
 270         {
 271                 blk = be16_to_cpu(PageBuf[index]);
 272                 if (blk == MS_LB_NOT_USED)
 273                         break;
 274                 if (blk == us->MS_Lib.Log2PhyMap[0])
 275                 {
 276                         result = MS_ERROR_FLASH_READ;
 277                         break;
 278                 }
 279                 index++;
 280         } while(1);
 281
 282 exit:
 283         kfree(PageBuf);
 284         return result;
 285 }
 286
 287 //----- MS_LibFreeAllocatedArea() ------------------------------------
 288 void MS_LibFreeAllocatedArea(struct us_data *us)
 289 {
 290         MS_LibFreeWriteBuf(us);
 291         MS_LibFreeLogicalMap(us);
 292
 293         us->MS_Lib.flags                        = 0;
 294         us->MS_Lib.BytesPerSector       = 0;
 295         us->MS_Lib.SectorsPerCylinder   = 0;
 296
 297         us->MS_Lib.cardType             = 0;
 298         us->MS_Lib.blockSize            = 0;
 299         us->MS_Lib.PagesPerBlock        = 0;
 300
 301         us->MS_Lib.NumberOfPhyBlock     = 0;
 302         us->MS_Lib.NumberOfLogBlock     = 0;
 303 }
 304
 305 //----- MS_LibFreeWriteBuf() -----------------------------------------
 306 void MS_LibFreeWriteBuf(struct us_data *us)
 307 {
 308         us->MS_Lib.wrtblk = (WORD)-1; //set to -1
 309         MS_LibClearPageMap(us); // memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap))
 310
 311         if (us->MS_Lib.blkpag)
 312         {
 313                 kfree((BYTE *)(us->MS_Lib.blkpag));  // Arnold test ...
 314                 us->MS_Lib.blkpag = NULL;
 315         }
 316
 317         if (us->MS_Lib.blkext)
 318         {
 319                 kfree((BYTE *)(us->MS_Lib.blkext));  // Arnold test ...
 320                 us->MS_Lib.blkext = NULL;
 321         }
 322 }
 323
 324 //----- MS_LibFreeLogicalMap() ---------------------------------------
 325 int MS_LibFreeLogicalMap(struct us_data *us)
 326 {
 327         kfree(us->MS_Lib.Phy2LogMap);
 328         us->MS_Lib.Phy2LogMap = NULL;
 329
 330         kfree(us->MS_Lib.Log2PhyMap);
 331         us->MS_Lib.Log2PhyMap = NULL;
 332
 333     return 0;
 334 }
 335
 336 //----- MS_LibProcessBootBlock() -------------------------------------
 337 int MS_LibProcessBootBlock(struct us_data *us, WORD PhyBlock, BYTE *PageData)
 338 {
 339         MemStickBootBlockSysEnt  *SysEntry;
 340         MemStickBootBlockSysInf  *SysInfo;
 341         DWORD                    i, result;
 342         BYTE                     PageNumber;
 343         BYTE                     *PageBuffer;
 344         MS_LibTypeExtdat         ExtraData;
 345
 346         if ((PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL))==NULL)
 347                 return (DWORD)-1;
 348
 349         result = (DWORD)-1;
 350
 351         SysInfo= &(((MemStickBootBlockPage0 *)PageData)->sysinf);
 352
 353         if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1)                                   ||
 354                 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE)                       ||
 355                 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
 356                 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1)                                     ||
 357                 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2)                                     ||
 358                 (SysInfo->bFormatType!= MS_SYSINF_FORMAT_FAT)                                    ||
 359                 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
 360                 goto exit;
 361
 362         switch (us->MS_Lib.cardType = SysInfo->bCardType)
 363         {
 364                 case MS_SYSINF_CARDTYPE_RDONLY:
 365                         MS_LibCtrlSet(us, MS_LIB_CTRL_RDONLY);
 366                         break;
 367                 case MS_SYSINF_CARDTYPE_RDWR:
 368                         MS_LibCtrlReset(us, MS_LIB_CTRL_RDONLY);
 369                         break;
 370                 case MS_SYSINF_CARDTYPE_HYBRID:
 371                 default:
 372                         goto exit;
 373         }
 374
 375         us->MS_Lib.blockSize        = be16_to_cpu(SysInfo->wBlockSize);
 376         us->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
 377         us->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber) - 2;
 378         us->MS_Lib.PagesPerBlock    = us->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
 379         us->MS_Lib.NumberOfSegment  = us->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 380         us->MS_Model                = be16_to_cpu(SysInfo->wMemorySize);
 381
 382         if (MS_LibAllocLogicalMap(us))                  //Allocate to all number of logicalblock and physicalblock
 383                 goto exit;
 384
 385         MS_LibSetBootBlockMark(us, PhyBlock);           //Mark the book block
 386
 387         SysEntry = &(((MemStickBootBlockPage0 *)PageData)->sysent);
 388
 389         for (i=0; i<MS_NUMBER_OF_SYSTEM_ENTRY; i++)
 390         {
 391                 DWORD  EntryOffset, EntrySize;
 392
 393                 if ((EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart)) == 0xffffff)
 394                         continue;
 395
 396                 if ((EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize)) == 0)
 397                         continue;
 398
 399                 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > us->MS_Lib.blockSize * (DWORD)SIZE_OF_KIRO)
 400                         continue;
 401
 402                 if (i == 0)
 403                 {
 404                         BYTE  PrevPageNumber = 0;
 405                         WORD  phyblk;
 406
 407                         if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
 408                                 goto exit;
 409
 410                         while (EntrySize > 0)
 411                         {
 412                                 if ((PageNumber = (BYTE)(EntryOffset / MS_BYTES_PER_PAGE + 1)) != PrevPageNumber)
 413                                 {
 414                                         switch (MS_ReaderReadPage(us, PhyBlock, PageNumber, (DWORD *)PageBuffer, &ExtraData))
 415                                         {
 416                                                 case MS_STATUS_SUCCESS:
 417                                                         break;
 418                                                 case MS_STATUS_WRITE_PROTECT:
 419                                                 case MS_ERROR_FLASH_READ:
 420                                                 case MS_STATUS_ERROR:
 421                                                 default:
 422                                                         goto exit;
 423                                         }
 424
 425                                         PrevPageNumber = PageNumber;
 426                                 }
 427
 428                                 if ((phyblk = be16_to_cpu(*(WORD *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))) < 0x0fff)
 429                                         MS_LibSetInitialErrorBlock(us, phyblk);
 430
 431                                 EntryOffset += 2;
 432                                 EntrySize -= 2;
 433                         }
 434                 }
 435                 else if (i == 1)
 436                 {  // CIS/IDI
 437                         MemStickBootBlockIDI  *idi;
 438
 439                         if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
 440                                 goto exit;
 441
 442                         switch (MS_ReaderReadPage(us, PhyBlock, (BYTE)(EntryOffset / MS_BYTES_PER_PAGE + 1), (DWORD *)PageBuffer, &ExtraData))
 443                         {
 444                                 case MS_STATUS_SUCCESS:
 445                                         break;
 446                                 case MS_STATUS_WRITE_PROTECT:
 447                                 case MS_ERROR_FLASH_READ:
 448                                 case MS_STATUS_ERROR:
 449                                 default:
 450                                         goto exit;
 451                         }
 452
 453                         idi = &((MemStickBootBlockCIS_IDI *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
 454                         if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
 455                                 goto exit;
 456
 457                         us->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
 458                         if (us->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
 459                                 goto exit;
 460                 }
 461         } // End for ..
 462
 463         result = 0;
 464
 465 exit:
 466         if (result)             MS_LibFreeLogicalMap(us);
 467         kfree(PageBuffer);
 468
 469         result = 0;
 470         return result;
 471 }
 472
 473 //----- MS_LibAllocLogicalMap() --------------------------------------
 474 int MS_LibAllocLogicalMap(struct us_data *us)
 475 {
 476         DWORD  i;
 477
 478
 479         us->MS_Lib.Phy2LogMap = kmalloc(us->MS_Lib.NumberOfPhyBlock * sizeof(WORD), GFP_KERNEL);
 480         us->MS_Lib.Log2PhyMap = kmalloc(us->MS_Lib.NumberOfLogBlock * sizeof(WORD), GFP_KERNEL);
 481
 482         if ((us->MS_Lib.Phy2LogMap == NULL) || (us->MS_Lib.Log2PhyMap == NULL))
 483         {
 484                 MS_LibFreeLogicalMap(us);
 485                 return (DWORD)-1;
 486         }
 487
 488         for (i = 0; i < us->MS_Lib.NumberOfPhyBlock; i++)
 489                 us->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
 490
 491         for (i = 0; i < us->MS_Lib.NumberOfLogBlock; i++)
 492         us->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
 493
 494         return 0;
 495 }
 496
 497 //----- MS_LibSetBootBlockMark() -------------------------------------
 498 int MS_LibSetBootBlockMark(struct us_data *us, WORD phyblk)
 499 {
 500     return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_BOOT_BLOCK);
 501 }
 502
 503 //----- MS_LibSetLogicalBlockMark() ----------------------------------
 504 int MS_LibSetLogicalBlockMark(struct us_data *us, WORD phyblk, WORD mark)
 505 {
 506     if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
 507         return (DWORD)-1;
 508
 509     us->MS_Lib.Phy2LogMap[phyblk] = mark;
 510
 511     return 0;
 512 }
 513
 514 //----- MS_LibSetInitialErrorBlock() ---------------------------------
 515 int MS_LibSetInitialErrorBlock(struct us_data *us, WORD phyblk)
 516 {
 517     return MS_LibSetLogicalBlockMark(us, phyblk, MS_LB_INITIAL_ERROR);
 518 }
 519
 520 //----- MS_LibScanLogicalBlockNumber() -------------------------------
 521 int MS_LibScanLogicalBlockNumber(struct us_data *us, WORD btBlk1st)
 522 {
 523         WORD                    PhyBlock, newblk, i;
 524         WORD                    LogStart, LogEnde;
 525         MS_LibTypeExtdat        extdat;
 526         BYTE                    buf[0x200];
 527         DWORD                   count=0, index=0;
 528
 529         for (PhyBlock = 0; PhyBlock < us->MS_Lib.NumberOfPhyBlock;)
 530         {
 531                 MS_LibPhy2LogRange(PhyBlock, &LogStart, &LogEnde);
 532
 533                 for (i=0; i<MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++)
 534                 {
 535                         switch (MS_LibConv2Logical(us, PhyBlock))
 536                         {
 537                                 case MS_STATUS_ERROR:
 538                                         continue;
 539                                 default:
 540                                         break;
 541                         }
 542
 543                         if (count == PhyBlock)
 544                         {
 545                                 MS_LibReadExtraBlock(us, PhyBlock, 0, 0x80, &buf);
 546                                 count += 0x80;
 547                         }
 548                         index = (PhyBlock % 0x80) * 4;
 549
 550                         extdat.ovrflg = buf[index];
 551                         extdat.mngflg = buf[index+1];
 552                         extdat.logadr = MemStickLogAddr(buf[index+2], buf[index+3]);
 553
 554                         if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK)
 555                         {
 556                                 MS_LibSetAcquiredErrorBlock(us, PhyBlock);
 557                                 continue;
 558                         }
 559
 560                         if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL)
 561                         {
 562                                 MS_LibErasePhyBlock(us, PhyBlock);
 563                                 continue;
 564                         }
 565
 566                         if (extdat.logadr != MS_LB_NOT_USED)
 567                         {
 568                                 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr))
 569                                 {
 570                                         MS_LibErasePhyBlock(us, PhyBlock);
 571                                         continue;
 572                                 }
 573
 574                                 if ((newblk = MS_LibConv2Physical(us, extdat.logadr)) != MS_LB_NOT_USED)
 575                                 {
 576                                         if (extdat.logadr==0)
 577                                         {
 578                                                 MS_LibSetLogicalPair(us, extdat.logadr, PhyBlock);
 579                                                 if ( MS_LibCheckDisableBlock(us, btBlk1st) )
 580                                                 {
 581                                                         MS_LibSetLogicalPair(us, extdat.logadr, newblk);
 582                                                         continue;
 583                                                 }
 584                                         }
 585
 586                                         MS_LibReadExtra(us, newblk, 0, &extdat);
 587                                         if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING)
 588                                         {
 589                                                 MS_LibErasePhyBlock(us, PhyBlock);
 590                                                 continue;
 591                                         }
 592                                         else
 593                                                 MS_LibErasePhyBlock(us, newblk);
 594                                 }
 595
 596                                 MS_LibSetLogicalPair(us, extdat.logadr, PhyBlock);
 597                         }
 598                 }
 599         } //End for ...
 600
 601         return MS_STATUS_SUCCESS;
 602 }
 603
 604 //----- MS_LibAllocWriteBuf() ----------------------------------------
 605 int MS_LibAllocWriteBuf(struct us_data *us)
 606 {
 607         us->MS_Lib.wrtblk = (WORD)-1;
 608
 609         us->MS_Lib.blkpag = kmalloc(us->MS_Lib.PagesPerBlock * us->MS_Lib.BytesPerSector, GFP_KERNEL);
 610         us->MS_Lib.blkext = kmalloc(us->MS_Lib.PagesPerBlock * sizeof(MS_LibTypeExtdat), GFP_KERNEL);
 611
 612         if ((us->MS_Lib.blkpag == NULL) || (us->MS_Lib.blkext == NULL))
 613         {
 614                 MS_LibFreeWriteBuf(us);
 615                 return (DWORD)-1;
 616         }
 617
 618         MS_LibClearWriteBuf(us);
 619
 620         return 0;
 621 }
 622
 623 //----- MS_LibClearWriteBuf() ----------------------------------------
 624 void MS_LibClearWriteBuf(struct us_data *us)
 625 {
 626         int i;
 627
 628         us->MS_Lib.wrtblk = (WORD)-1;
 629         MS_LibClearPageMap(us);
 630
 631         if (us->MS_Lib.blkpag)
 632                 memset(us->MS_Lib.blkpag, 0xff, us->MS_Lib.PagesPerBlock * us->MS_Lib.BytesPerSector);
 633
 634         if (us->MS_Lib.blkext)
 635         {
 636                 for (i = 0; i < us->MS_Lib.PagesPerBlock; i++)
 637                 {
 638                         us->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
 639                         us->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
 640                         us->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
 641                         us->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
 642                 }
 643         }
 644 }
 645
 646 //----- MS_LibPhy2LogRange() -----------------------------------------
 647 void MS_LibPhy2LogRange(WORD PhyBlock, WORD *LogStart, WORD *LogEnde)
 648 {
 649         PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 650
 651         if (PhyBlock)
 652         {
 653                 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;//496
 654                 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;//496
 655         }
 656         else
 657         {
 658                 *LogStart = 0;
 659                 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;//494
 660         }
 661 }
 662
 663 //----- MS_LibReadExtraBlock() --------------------------------------------
 664 int MS_LibReadExtraBlock(struct us_data *us, DWORD PhyBlock, BYTE PageNum, BYTE blen, void *buf)
 665 {
 666         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 667         int     result;
 668
 669         //printk("MS_LibReadExtraBlock --- PhyBlock = %x, PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen);
 670
 671         // Read Extra Data
 672         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 673         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 674         bcb->DataTransferLength = 0x4 * blen;
 675         bcb->Flags                      = 0x80;
 676         bcb->CDB[0]                     = 0xF1;
 677         bcb->CDB[1]                     = 0x03;
 678         bcb->CDB[5]                     = (BYTE)(PageNum);
 679         bcb->CDB[4]                     = (BYTE)(PhyBlock);
 680         bcb->CDB[3]                     = (BYTE)(PhyBlock>>8);
 681         bcb->CDB[2]                     = (BYTE)(PhyBlock>>16);
 682         bcb->CDB[6]                     = blen;
 683
 684         result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
 685         if (result != USB_STOR_XFER_GOOD)
 686                 return USB_STOR_TRANSPORT_ERROR;
 687
 688         return USB_STOR_TRANSPORT_GOOD;
 689 }
 690
 691 //----- MS_LibReadExtra() --------------------------------------------
 692 int MS_LibReadExtra(struct us_data *us, DWORD PhyBlock, BYTE PageNum, MS_LibTypeExtdat *ExtraDat)
 693 {
 694         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 695         int     result;
 696         BYTE    ExtBuf[4];
 697
 698         //printk("MS_LibReadExtra --- PhyBlock = %x, PageNum = %x\n", PhyBlock, PageNum);
 699         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 700         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 701         bcb->DataTransferLength = 0x4;
 702         bcb->Flags                      = 0x80;
 703         bcb->CDB[0]                     = 0xF1;
 704         bcb->CDB[1]                     = 0x03;
 705         bcb->CDB[5]                     = (BYTE)(PageNum);
 706         bcb->CDB[4]                     = (BYTE)(PhyBlock);
 707         bcb->CDB[3]                     = (BYTE)(PhyBlock>>8);
 708         bcb->CDB[2]                     = (BYTE)(PhyBlock>>16);
 709         bcb->CDB[6]                     = 0x01;
 710
 711         result = ENE_SendScsiCmd(us, FDIR_READ, &ExtBuf, 0);
 712         if (result != USB_STOR_XFER_GOOD)
 713                 return USB_STOR_TRANSPORT_ERROR;
 714
 715         ExtraDat->reserved = 0;
 716         ExtraDat->intr     = 0x80;  // Not yet, waiting for fireware support
 717         ExtraDat->status0  = 0x10;  // Not yet, waiting for fireware support
 718         ExtraDat->status1  = 0x00;  // Not yet, waiting for fireware support
 719         ExtraDat->ovrflg   = ExtBuf[0];
 720         ExtraDat->mngflg   = ExtBuf[1];
 721         ExtraDat->logadr   = MemStickLogAddr(ExtBuf[2], ExtBuf[3]);
 722
 723         return USB_STOR_TRANSPORT_GOOD;
 724 }
 725
 726 //----- MS_LibSetAcquiredErrorBlock() --------------------------------
 727 int MS_LibSetAcquiredErrorBlock(struct us_data *us, WORD phyblk)
 728 {
 729         WORD log;
 730
 731         if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
 732                 return (DWORD)-1;
 733
 734         if ((log = us->MS_Lib.Phy2LogMap[phyblk]) < us->MS_Lib.NumberOfLogBlock)
 735                 us->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
 736
 737         if (us->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
 738                 us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
 739
 740         return 0;
 741 }
 742
 743 //----- MS_LibErasePhyBlock() ----------------------------------------
 744 int MS_LibErasePhyBlock(struct us_data *us, WORD phyblk)
 745 {
 746         WORD  log;
 747
 748         if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
 749                 return MS_STATUS_ERROR;
 750
 751         if ((log = us->MS_Lib.Phy2LogMap[phyblk]) < us->MS_Lib.NumberOfLogBlock)
 752                 us->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
 753
 754         us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
 755
 756         if (MS_LibIsWritable(us))
 757         {
 758                 switch (MS_ReaderEraseBlock(us, phyblk))
 759                 {
 760                         case MS_STATUS_SUCCESS:
 761                                 us->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
 762                                 return MS_STATUS_SUCCESS;
 763                         case MS_ERROR_FLASH_ERASE:
 764                         case MS_STATUS_INT_ERROR :
 765                                 MS_LibErrorPhyBlock(us, phyblk);
 766                                 return MS_ERROR_FLASH_ERASE;
 767                         case MS_STATUS_ERROR:
 768                         default:
 769                                 MS_LibCtrlSet(us, MS_LIB_CTRL_RDONLY);
 770                                 MS_LibSetAcquiredErrorBlock(us, phyblk);
 771                                 return MS_STATUS_ERROR;
 772                 }
 773         }
 774
 775         MS_LibSetAcquiredErrorBlock(us, phyblk);
 776
 777         return MS_STATUS_SUCCESS;
 778 }
 779
 780 //----- MS_LibErrorPhyBlock() ----------------------------------------
 781 int MS_LibErrorPhyBlock(struct us_data *us, WORD phyblk)
 782 {
 783     if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
 784         return MS_STATUS_ERROR;
 785
 786     MS_LibSetAcquiredErrorBlock(us, phyblk);
 787
 788     if (MS_LibIsWritable(us))
 789         return MS_LibOverwriteExtra(us, phyblk, 0, (BYTE)(~MS_REG_OVR_BKST));
 790
 791
 792     return MS_STATUS_SUCCESS;
 793 }
 794
 795 //----- MS_LibOverwriteExtra() ---------------------------------------
 796 int MS_LibOverwriteExtra(struct us_data *us, DWORD PhyBlockAddr, BYTE PageNum, BYTE OverwriteFlag)
 797 {
 798         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 799         int     result;
 800
 801         //printk("MS --- MS_LibOverwriteExtra,  PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum);
 802         result = ENE_LoadBinCode(us, MS_RW_PATTERN);
 803         if (result != USB_STOR_XFER_GOOD)
 804                 return USB_STOR_TRANSPORT_ERROR;
 805
 806         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 807         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 808         bcb->DataTransferLength = 0x4;
 809         bcb->Flags                      = 0x80;
 810         bcb->CDB[0]                     = 0xF2;
 811         bcb->CDB[1]                     = 0x05;
 812         bcb->CDB[5]                     = (BYTE)(PageNum);
 813         bcb->CDB[4]                     = (BYTE)(PhyBlockAddr);
 814         bcb->CDB[3]                     = (BYTE)(PhyBlockAddr>>8);
 815         bcb->CDB[2]                     = (BYTE)(PhyBlockAddr>>16);
 816         bcb->CDB[6]                     = OverwriteFlag;
 817         bcb->CDB[7]                     = 0xFF;
 818         bcb->CDB[8]                     = 0xFF;
 819         bcb->CDB[9]                     = 0xFF;
 820
 821         result = ENE_SendScsiCmd(us, FDIR_READ, NULL, 0);
 822         if (result != USB_STOR_XFER_GOOD)
 823                 return USB_STOR_TRANSPORT_ERROR;
 824
 825         return USB_STOR_TRANSPORT_GOOD;
 826 }
 827
 828 //----- MS_LibForceSetLogicalPair() ----------------------------------
 829 int MS_LibForceSetLogicalPair(struct us_data *us, WORD logblk, WORD phyblk)
 830 {
 831         if (logblk == MS_LB_NOT_USED)
 832                 return 0;
 833
 834         if ((logblk >= us->MS_Lib.NumberOfLogBlock) || (phyblk >= us->MS_Lib.NumberOfPhyBlock))
 835                 return (DWORD)-1;
 836
 837         us->MS_Lib.Phy2LogMap[phyblk] = logblk;
 838         us->MS_Lib.Log2PhyMap[logblk] = phyblk;
 839
 840         return 0;
 841 }
 842
 843 //----- MS_LibSetLogicalPair() ---------------------------------------
 844 int MS_LibSetLogicalPair(struct us_data *us, WORD logblk, WORD phyblk)
 845 {
 846         if ((logblk >= us->MS_Lib.NumberOfLogBlock) || (phyblk >= us->MS_Lib.NumberOfPhyBlock))
 847                 return (DWORD)-1;
 848
 849         us->MS_Lib.Phy2LogMap[phyblk] = logblk;
 850         us->MS_Lib.Log2PhyMap[logblk] = phyblk;
 851
 852         return 0;
 853 }
 854
 855 //----- MS_CountFreeBlock() ------------------------------------------
 856 int MS_CountFreeBlock(struct us_data *us, WORD PhyBlock)
 857 {
 858         DWORD Ende, Count;
 859
 860         Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 861         for (Count = 0; PhyBlock < Ende; PhyBlock++)
 862         {
 863                 switch (us->MS_Lib.Phy2LogMap[PhyBlock])
 864                 {
 865                         case MS_LB_NOT_USED:
 866                         case MS_LB_NOT_USED_ERASED:
 867                                 Count++;
 868                         default:
 869                                 break;
 870                 }
 871         }
 872
 873         return Count;
 874 }
 875
 876 //----- MS_LibSearchBlockFromPhysical() ------------------------------
 877 int MS_LibSearchBlockFromPhysical(struct us_data *us, WORD phyblk)
 878 {
 879         WORD                    Newblk;
 880         WORD                    blk;
 881         MS_LibTypeExtdat        extdat;
 882
 883         if (phyblk >= us->MS_Lib.NumberOfPhyBlock)
 884                 return MS_LB_ERROR;
 885
 886         for (blk = phyblk + 1; blk != phyblk; blk++)
 887         {
 888                 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
 889                         blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 890
 891                 Newblk = us->MS_Lib.Phy2LogMap[blk];
 892                 if (us->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED)
 893                         return blk;
 894                 else if (us->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED)
 895                 {
 896                         switch (MS_LibReadExtra(us, blk, 0, &extdat))
 897                         {
 898                                 case MS_STATUS_SUCCESS :
 899                                 case MS_STATUS_SUCCESS_WITH_ECC:
 900                                         break;
 901                                 case MS_NOCARD_ERROR:
 902                                         return MS_NOCARD_ERROR;
 903                                 case MS_STATUS_INT_ERROR:
 904                                         return MS_LB_ERROR;
 905                                 case MS_ERROR_FLASH_READ:
 906                                 default:
 907                                         MS_LibSetAcquiredErrorBlock(us, blk);     // MS_LibErrorPhyBlock(fdoExt, blk);
 908                                         continue;
 909                         } // End switch
 910
 911                         if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK)
 912                         {
 913                                 MS_LibSetAcquiredErrorBlock(us, blk);
 914                                 continue;
 915                         }
 916
 917                         switch (MS_LibErasePhyBlock(us, blk))
 918                         {
 919                                 case MS_STATUS_SUCCESS:
 920                                         return blk;
 921                                 case MS_STATUS_ERROR:
 922                                         return MS_LB_ERROR;
 923                                 case MS_ERROR_FLASH_ERASE:
 924                                 default:
 925                                         MS_LibErrorPhyBlock(us, blk);
 926                                         break;
 927                         }
 928                 }
 929         } // End for
 930
 931         return MS_LB_ERROR;
 932 }
 933
 934 //----- MS_LibSearchBlockFromLogical() -------------------------------
 935 int MS_LibSearchBlockFromLogical(struct us_data *us, WORD logblk)
 936 {
 937         WORD phyblk;
 938
 939         if ((phyblk=MS_LibConv2Physical(us, logblk)) >= MS_LB_ERROR)
 940         {
 941                 if (logblk >= us->MS_Lib.NumberOfLogBlock)
 942                         return MS_LB_ERROR;
 943
 944                 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
 945                 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 946                 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
 947         }
 948
 949         return MS_LibSearchBlockFromPhysical(us, phyblk);
 950 }
 951
 952