drivers/usb/storage/ene_ub6250.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 #include <linux/jiffies.h>
   3 #include <linux/errno.h>
   4 #include <linux/module.h>
   5 #include <linux/slab.h>
   6
   7 #include <scsi/scsi.h>
   8 #include <scsi/scsi_cmnd.h>
   9
  10 #include <linux/firmware.h>
  11
  12 #include "usb.h"
  13 #include "transport.h"
  14 #include "protocol.h"
  15 #include "debug.h"
  16 #include "scsiglue.h"
  17
  18 #define SD_INIT1_FIRMWARE "/*(DEBLOBBED)*/"
  19 #define SD_INIT2_FIRMWARE "/*(DEBLOBBED)*/"
  20 #define SD_RW_FIRMWARE "/*(DEBLOBBED)*/"
  21 #define MS_INIT_FIRMWARE "/*(DEBLOBBED)*/"
  22 #define MSP_RW_FIRMWARE "/*(DEBLOBBED)*/"
  23 #define MS_RW_FIRMWARE "/*(DEBLOBBED)*/"
  24
  25 #define DRV_NAME "ums_eneub6250"
  26
  27 MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
  28 MODULE_LICENSE("GPL");
  29 /*(DEBLOBBED)*/
  30
  31 /*
  32  * The table of devices
  33  */
  34 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
  35                     vendorName, productName, useProtocol, useTransport, \
  36                     initFunction, flags) \
  37 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
  38         .driver_info = (flags)}
  39
  40 static struct usb_device_id ene_ub6250_usb_ids[] = {
  41 #       include "unusual_ene_ub6250.h"
  42         { }             /* Terminating entry */
  43 };
  44 MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
  45
  46 #undef UNUSUAL_DEV
  47
  48 /*
  49  * The flags table
  50  */
  51 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
  52                     vendor_name, product_name, use_protocol, use_transport, \
  53                     init_function, Flags) \
  54 { \
  55         .vendorName = vendor_name,      \
  56         .productName = product_name,    \
  57         .useProtocol = use_protocol,    \
  58         .useTransport = use_transport,  \
  59         .initFunction = init_function,  \
  60 }
  61
  62 static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
  63 #       include "unusual_ene_ub6250.h"
  64         { }             /* Terminating entry */
  65 };
  66
  67 #undef UNUSUAL_DEV
  68
  69
  70
  71 /* ENE bin code len */
  72 #define ENE_BIN_CODE_LEN    0x800
  73 /* EnE HW Register */
  74 #define REG_CARD_STATUS     0xFF83
  75 #define REG_HW_TRAP1        0xFF89
  76
  77 /* SRB Status */
  78 #define SS_SUCCESS              0x000000        /* No Sense */
  79 #define SS_NOT_READY            0x023A00        /* Medium not present */
  80 #define SS_MEDIUM_ERR           0x031100        /* Unrecovered read error */
  81 #define SS_HW_ERR               0x040800        /* Communication failure */
  82 #define SS_ILLEGAL_REQUEST      0x052000        /* Invalid command */
  83 #define SS_UNIT_ATTENTION       0x062900        /* Reset occurred */
  84
  85 /* ENE Load FW Pattern */
  86 #define SD_INIT1_PATTERN   1
  87 #define SD_INIT2_PATTERN   2
  88 #define SD_RW_PATTERN      3
  89 #define MS_INIT_PATTERN    4
  90 #define MSP_RW_PATTERN     5
  91 #define MS_RW_PATTERN      6
  92 #define SM_INIT_PATTERN    7
  93 #define SM_RW_PATTERN      8
  94
  95 #define FDIR_WRITE         0
  96 #define FDIR_READ          1
  97
  98 /* For MS Card */
  99
 100 /* Status Register 1 */
 101 #define MS_REG_ST1_MB           0x80    /* media busy */
 102 #define MS_REG_ST1_FB1          0x40    /* flush busy 1 */
 103 #define MS_REG_ST1_DTER         0x20    /* error on data(corrected) */
 104 #define MS_REG_ST1_UCDT         0x10    /* unable to correct data */
 105 #define MS_REG_ST1_EXER         0x08    /* error on extra(corrected) */
 106 #define MS_REG_ST1_UCEX         0x04    /* unable to correct extra */
 107 #define MS_REG_ST1_FGER         0x02    /* error on overwrite flag(corrected) */
 108 #define MS_REG_ST1_UCFG         0x01    /* unable to correct overwrite flag */
 109 #define MS_REG_ST1_DEFAULT      (MS_REG_ST1_MB | MS_REG_ST1_FB1 | MS_REG_ST1_DTER | MS_REG_ST1_UCDT | MS_REG_ST1_EXER | MS_REG_ST1_UCEX | MS_REG_ST1_FGER | MS_REG_ST1_UCFG)
 110
 111 /* Overwrite Area */
 112 #define MS_REG_OVR_BKST         0x80            /* block status */
 113 #define MS_REG_OVR_BKST_OK      MS_REG_OVR_BKST     /* OK */
 114 #define MS_REG_OVR_BKST_NG      0x00            /* NG */
 115 #define MS_REG_OVR_PGST0        0x40            /* page status */
 116 #define MS_REG_OVR_PGST1        0x20
 117 #define MS_REG_OVR_PGST_MASK    (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
 118 #define MS_REG_OVR_PGST_OK      (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
 119 #define MS_REG_OVR_PGST_NG      MS_REG_OVR_PGST1                      /* NG */
 120 #define MS_REG_OVR_PGST_DATA_ERROR      0x00        /* data error */
 121 #define MS_REG_OVR_UDST                 0x10        /* update status */
 122 #define MS_REG_OVR_UDST_UPDATING        0x00        /* updating */
 123 #define MS_REG_OVR_UDST_NO_UPDATE       MS_REG_OVR_UDST
 124 #define MS_REG_OVR_RESERVED     0x08
 125 #define MS_REG_OVR_DEFAULT      (MS_REG_OVR_BKST_OK | MS_REG_OVR_PGST_OK | MS_REG_OVR_UDST_NO_UPDATE | MS_REG_OVR_RESERVED)
 126
 127 /* Management Flag */
 128 #define MS_REG_MNG_SCMS0        0x20    /* serial copy management system */
 129 #define MS_REG_MNG_SCMS1        0x10
 130 #define MS_REG_MNG_SCMS_MASK            (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
 131 #define MS_REG_MNG_SCMS_COPY_OK         (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
 132 #define MS_REG_MNG_SCMS_ONE_COPY        MS_REG_MNG_SCMS1
 133 #define MS_REG_MNG_SCMS_NO_COPY 0x00
 134 #define MS_REG_MNG_ATFLG        0x08    /* address transfer table flag */
 135 #define MS_REG_MNG_ATFLG_OTHER  MS_REG_MNG_ATFLG    /* other */
 136 #define MS_REG_MNG_ATFLG_ATTBL  0x00    /* address transfer table */
 137 #define MS_REG_MNG_SYSFLG       0x04    /* system flag */
 138 #define MS_REG_MNG_SYSFLG_USER  MS_REG_MNG_SYSFLG   /* user block */
 139 #define MS_REG_MNG_SYSFLG_BOOT  0x00    /* system block */
 140 #define MS_REG_MNG_RESERVED     0xc3
 141 #define MS_REG_MNG_DEFAULT      (MS_REG_MNG_SCMS_COPY_OK | MS_REG_MNG_ATFLG_OTHER | MS_REG_MNG_SYSFLG_USER | MS_REG_MNG_RESERVED)
 142
 143
 144 #define MS_MAX_PAGES_PER_BLOCK          32
 145 #define MS_MAX_INITIAL_ERROR_BLOCKS     10
 146 #define MS_LIB_BITS_PER_BYTE            8
 147
 148 #define MS_SYSINF_FORMAT_FAT            1
 149 #define MS_SYSINF_USAGE_GENERAL         0
 150
 151 #define MS_SYSINF_MSCLASS_TYPE_1        1
 152 #define MS_SYSINF_PAGE_SIZE             MS_BYTES_PER_PAGE /* fixed */
 153
 154 #define MS_SYSINF_CARDTYPE_RDONLY       1
 155 #define MS_SYSINF_CARDTYPE_RDWR         2
 156 #define MS_SYSINF_CARDTYPE_HYBRID       3
 157 #define MS_SYSINF_SECURITY              0x01
 158 #define MS_SYSINF_SECURITY_NO_SUPPORT   MS_SYSINF_SECURITY
 159 #define MS_SYSINF_SECURITY_SUPPORT      0
 160
 161 #define MS_SYSINF_RESERVED1             1
 162 #define MS_SYSINF_RESERVED2             1
 163
 164 #define MS_SYSENT_TYPE_INVALID_BLOCK    0x01
 165 #define MS_SYSENT_TYPE_CIS_IDI          0x0a    /* CIS/IDI */
 166
 167 #define SIZE_OF_KIRO            1024
 168 #define BYTE_MASK               0xff
 169
 170 /* ms error code */
 171 #define MS_STATUS_WRITE_PROTECT 0x0106
 172 #define MS_STATUS_SUCCESS       0x0000
 173 #define MS_ERROR_FLASH_READ     0x8003
 174 #define MS_ERROR_FLASH_ERASE    0x8005
 175 #define MS_LB_ERROR             0xfff0
 176 #define MS_LB_BOOT_BLOCK        0xfff1
 177 #define MS_LB_INITIAL_ERROR     0xfff2
 178 #define MS_STATUS_SUCCESS_WITH_ECC 0xfff3
 179 #define MS_LB_ACQUIRED_ERROR    0xfff4
 180 #define MS_LB_NOT_USED_ERASED   0xfff5
 181 #define MS_NOCARD_ERROR         0xfff8
 182 #define MS_NO_MEMORY_ERROR      0xfff9
 183 #define MS_STATUS_INT_ERROR     0xfffa
 184 #define MS_STATUS_ERROR         0xfffe
 185 #define MS_LB_NOT_USED          0xffff
 186
 187 #define MS_REG_MNG_SYSFLG       0x04    /* system flag */
 188 #define MS_REG_MNG_SYSFLG_USER  MS_REG_MNG_SYSFLG   /* user block */
 189
 190 #define MS_BOOT_BLOCK_ID                        0x0001
 191 #define MS_BOOT_BLOCK_FORMAT_VERSION            0x0100
 192 #define MS_BOOT_BLOCK_DATA_ENTRIES              2
 193
 194 #define MS_NUMBER_OF_SYSTEM_ENTRY               4
 195 #define MS_NUMBER_OF_BOOT_BLOCK                 2
 196 #define MS_BYTES_PER_PAGE                       512
 197 #define MS_LOGICAL_BLOCKS_PER_SEGMENT           496
 198 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT        494
 199
 200 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT          0x200 /* 512 */
 201 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK     0x1ff
 202
 203 /* overwrite area */
 204 #define MS_REG_OVR_BKST         0x80            /* block status */
 205 #define MS_REG_OVR_BKST_OK      MS_REG_OVR_BKST /* OK */
 206 #define MS_REG_OVR_BKST_NG      0x00            /* NG */
 207
 208 /* Status Register 1 */
 209 #define MS_REG_ST1_DTER         0x20    /* error on data(corrected) */
 210 #define MS_REG_ST1_EXER         0x08    /* error on extra(corrected) */
 211 #define MS_REG_ST1_FGER         0x02    /* error on overwrite flag(corrected) */
 212
 213 /* MemoryStick Register */
 214 /* Status Register 0 */
 215 #define MS_REG_ST0_WP           0x01    /* write protected */
 216 #define MS_REG_ST0_WP_ON        MS_REG_ST0_WP
 217
 218 #define MS_LIB_CTRL_RDONLY      0
 219 #define MS_LIB_CTRL_WRPROTECT   1
 220
 221 /*dphy->log table */
 222 #define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
 223 #define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
 224
 225 #define ms_lib_ctrl_set(pdx, Flag)      ((pdx)->MS_Lib.flags |= (1 << (Flag)))
 226 #define ms_lib_ctrl_reset(pdx, Flag)    ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
 227 #define ms_lib_ctrl_check(pdx, Flag)    ((pdx)->MS_Lib.flags & (1 << (Flag)))
 228
 229 #define ms_lib_iswritable(pdx) ((ms_lib_ctrl_check((pdx), MS_LIB_CTRL_RDONLY) == 0) && (ms_lib_ctrl_check(pdx, MS_LIB_CTRL_WRPROTECT) == 0))
 230 #define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
 231 #define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0))
 232
 233
 234 /* SD_STATUS bits */
 235 #define SD_Insert       BIT(0)
 236 #define SD_Ready        BIT(1)
 237 #define SD_MediaChange  BIT(2)
 238 #define SD_IsMMC        BIT(3)
 239 #define SD_HiCapacity   BIT(4)
 240 #define SD_HiSpeed      BIT(5)
 241 #define SD_WtP          BIT(6)
 242                         /* Bit 7 reserved */
 243
 244 /* MS_STATUS bits */
 245 #define MS_Insert       BIT(0)
 246 #define MS_Ready        BIT(1)
 247 #define MS_MediaChange  BIT(2)
 248 #define MS_IsMSPro      BIT(3)
 249 #define MS_IsMSPHG      BIT(4)
 250                         /* Bit 5 reserved */
 251 #define MS_WtP          BIT(6)
 252                         /* Bit 7 reserved */
 253
 254 /* SM_STATUS bits */
 255 #define SM_Insert       BIT(0)
 256 #define SM_Ready        BIT(1)
 257 #define SM_MediaChange  BIT(2)
 258                         /* Bits 3-5 reserved */
 259 #define SM_WtP          BIT(6)
 260 #define SM_IsMS         BIT(7)
 261
 262 struct ms_bootblock_cis {
 263         u8 bCistplDEVICE[6];    /* 0 */
 264         u8 bCistplDEVICE0C[6];  /* 6 */
 265         u8 bCistplJEDECC[4];    /* 12 */
 266         u8 bCistplMANFID[6];    /* 16 */
 267         u8 bCistplVER1[32];     /* 22 */
 268         u8 bCistplFUNCID[4];    /* 54 */
 269         u8 bCistplFUNCE0[4];    /* 58 */
 270         u8 bCistplFUNCE1[5];    /* 62 */
 271         u8 bCistplCONF[7];      /* 67 */
 272         u8 bCistplCFTBLENT0[10];/* 74 */
 273         u8 bCistplCFTBLENT1[8]; /* 84 */
 274         u8 bCistplCFTBLENT2[12];/* 92 */
 275         u8 bCistplCFTBLENT3[8]; /* 104 */
 276         u8 bCistplCFTBLENT4[17];/* 112 */
 277         u8 bCistplCFTBLENT5[8]; /* 129 */
 278         u8 bCistplCFTBLENT6[17];/* 137 */
 279         u8 bCistplCFTBLENT7[8]; /* 154 */
 280         u8 bCistplNOLINK[3];    /* 162 */
 281 } ;
 282
 283 struct ms_bootblock_idi {
 284 #define MS_IDI_GENERAL_CONF 0x848A
 285         u16 wIDIgeneralConfiguration;   /* 0 */
 286         u16 wIDInumberOfCylinder;       /* 1 */
 287         u16 wIDIreserved0;              /* 2 */
 288         u16 wIDInumberOfHead;           /* 3 */
 289         u16 wIDIbytesPerTrack;          /* 4 */
 290         u16 wIDIbytesPerSector;         /* 5 */
 291         u16 wIDIsectorsPerTrack;        /* 6 */
 292         u16 wIDItotalSectors[2];        /* 7-8  high,low */
 293         u16 wIDIreserved1[11];          /* 9-19 */
 294         u16 wIDIbufferType;             /* 20 */
 295         u16 wIDIbufferSize;             /* 21 */
 296         u16 wIDIlongCmdECC;             /* 22 */
 297         u16 wIDIfirmVersion[4];         /* 23-26 */
 298         u16 wIDImodelName[20];          /* 27-46 */
 299         u16 wIDIreserved2;              /* 47 */
 300         u16 wIDIlongWordSupported;      /* 48 */
 301         u16 wIDIdmaSupported;           /* 49 */
 302         u16 wIDIreserved3;              /* 50 */
 303         u16 wIDIpioTiming;              /* 51 */
 304         u16 wIDIdmaTiming;              /* 52 */
 305         u16 wIDItransferParameter;      /* 53 */
 306         u16 wIDIformattedCylinder;      /* 54 */
 307         u16 wIDIformattedHead;          /* 55 */
 308         u16 wIDIformattedSectorsPerTrack;/* 56 */
 309         u16 wIDIformattedTotalSectors[2];/* 57-58 */
 310         u16 wIDImultiSector;            /* 59 */
 311         u16 wIDIlbaSectors[2];          /* 60-61 */
 312         u16 wIDIsingleWordDMA;          /* 62 */
 313         u16 wIDImultiWordDMA;           /* 63 */
 314         u16 wIDIreserved4[192];         /* 64-255 */
 315 };
 316
 317 struct ms_bootblock_sysent_rec {
 318         u32 dwStart;
 319         u32 dwSize;
 320         u8 bType;
 321         u8 bReserved[3];
 322 };
 323
 324 struct ms_bootblock_sysent {
 325         struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
 326 };
 327
 328 struct ms_bootblock_sysinf {
 329         u8 bMsClass;                    /* must be 1 */
 330         u8 bCardType;                   /* see below */
 331         u16 wBlockSize;                 /* n KB */
 332         u16 wBlockNumber;               /* number of physical block */
 333         u16 wTotalBlockNumber;          /* number of logical block */
 334         u16 wPageSize;                  /* must be 0x200 */
 335         u8 bExtraSize;                  /* 0x10 */
 336         u8 bSecuritySupport;
 337         u8 bAssemblyDate[8];
 338         u8 bFactoryArea[4];
 339         u8 bAssemblyMakerCode;
 340         u8 bAssemblyMachineCode[3];
 341         u16 wMemoryMakerCode;
 342         u16 wMemoryDeviceCode;
 343         u16 wMemorySize;
 344         u8 bReserved1;
 345         u8 bReserved2;
 346         u8 bVCC;
 347         u8 bVPP;
 348         u16 wControllerChipNumber;
 349         u16 wControllerFunction;        /* New MS */
 350         u8 bReserved3[9];               /* New MS */
 351         u8 bParallelSupport;            /* New MS */
 352         u16 wFormatValue;               /* New MS */
 353         u8 bFormatType;
 354         u8 bUsage;
 355         u8 bDeviceType;
 356         u8 bReserved4[22];
 357         u8 bFUValue3;
 358         u8 bFUValue4;
 359         u8 bReserved5[15];
 360 };
 361
 362 struct ms_bootblock_header {
 363         u16 wBlockID;
 364         u16 wFormatVersion;
 365         u8 bReserved1[184];
 366         u8 bNumberOfDataEntry;
 367         u8 bReserved2[179];
 368 };
 369
 370 struct ms_bootblock_page0 {
 371         struct ms_bootblock_header header;
 372         struct ms_bootblock_sysent sysent;
 373         struct ms_bootblock_sysinf sysinf;
 374 };
 375
 376 struct ms_bootblock_cis_idi {
 377         union {
 378                 struct ms_bootblock_cis cis;
 379                 u8 dmy[256];
 380         } cis;
 381
 382         union {
 383                 struct ms_bootblock_idi idi;
 384                 u8 dmy[256];
 385         } idi;
 386
 387 };
 388
 389 /* ENE MS Lib struct */
 390 struct ms_lib_type_extdat {
 391         u8 reserved;
 392         u8 intr;
 393         u8 status0;
 394         u8 status1;
 395         u8 ovrflg;
 396         u8 mngflg;
 397         u16 logadr;
 398 };
 399
 400 struct ms_lib_ctrl {
 401         u32 flags;
 402         u32 BytesPerSector;
 403         u32 NumberOfCylinder;
 404         u32 SectorsPerCylinder;
 405         u16 cardType;                   /* R/W, RO, Hybrid */
 406         u16 blockSize;
 407         u16 PagesPerBlock;
 408         u16 NumberOfPhyBlock;
 409         u16 NumberOfLogBlock;
 410         u16 NumberOfSegment;
 411         u16 *Phy2LogMap;                /* phy2log table */
 412         u16 *Log2PhyMap;                /* log2phy table */
 413         u16 wrtblk;
 414         unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
 415         unsigned char *blkpag;
 416         struct ms_lib_type_extdat *blkext;
 417         unsigned char copybuf[512];
 418 };
 419
 420
 421 /* SD Block Length */
 422 /* 2^9 = 512 Bytes, The HW maximum read/write data length */
 423 #define SD_BLOCK_LEN  9
 424
 425 struct ene_ub6250_info {
 426
 427         /* I/O bounce buffer */
 428         u8              *bbuf;
 429
 430         /* for 6250 code */
 431         u8              SD_Status;
 432         u8              MS_Status;
 433         u8              SM_Status;
 434
 435         /* ----- SD Control Data ---------------- */
 436         /*SD_REGISTER SD_Regs; */
 437         u16             SD_Block_Mult;
 438         u8              SD_READ_BL_LEN;
 439         u16             SD_C_SIZE;
 440         u8              SD_C_SIZE_MULT;
 441
 442         /* SD/MMC New spec. */
 443         u8              SD_SPEC_VER;
 444         u8              SD_CSD_VER;
 445         u8              SD20_HIGH_CAPACITY;
 446         u32             HC_C_SIZE;
 447         u8              MMC_SPEC_VER;
 448         u8              MMC_BusWidth;
 449         u8              MMC_HIGH_CAPACITY;
 450
 451         /*----- MS Control Data ---------------- */
 452         bool            MS_SWWP;
 453         u32             MSP_TotalBlock;
 454         struct ms_lib_ctrl MS_Lib;
 455         bool            MS_IsRWPage;
 456         u16             MS_Model;
 457
 458         /*----- SM Control Data ---------------- */
 459         u8              SM_DeviceID;
 460         u8              SM_CardID;
 461
 462         unsigned char   *testbuf;
 463         u8              BIN_FLAG;
 464         u32             bl_num;
 465         int             SrbStatus;
 466
 467         /*------Power Managerment ---------------*/
 468         bool            Power_IsResum;
 469 };
 470
 471 static int ene_sd_init(struct us_data *us);
 472 static int ene_ms_init(struct us_data *us);
 473 static int ene_load_bincode(struct us_data *us, unsigned char flag);
 474
 475 static void ene_ub6250_info_destructor(void *extra)
 476 {
 477         struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra;
 478
 479         if (!extra)
 480                 return;
 481         kfree(info->bbuf);
 482 }
 483
 484 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
 485 {
 486         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 487         struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
 488
 489         int result;
 490         unsigned int residue;
 491         unsigned int cswlen = 0, partial = 0;
 492         unsigned int transfer_length = bcb->DataTransferLength;
 493
 494         /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
 495         /* send cmd to out endpoint */
 496         result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
 497                                             bcb, US_BULK_CB_WRAP_LEN, NULL);
 498         if (result != USB_STOR_XFER_GOOD) {
 499                 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
 500                 return USB_STOR_TRANSPORT_ERROR;
 501         }
 502
 503         if (buf) {
 504                 unsigned int pipe = fDir;
 505
 506                 if (fDir  == FDIR_READ)
 507                         pipe = us->recv_bulk_pipe;
 508                 else
 509                         pipe = us->send_bulk_pipe;
 510
 511                 /* Bulk */
 512                 if (use_sg) {
 513                         result = usb_stor_bulk_srb(us, pipe, us->srb);
 514                 } else {
 515                         result = usb_stor_bulk_transfer_sg(us, pipe, buf,
 516                                                 transfer_length, 0, &partial);
 517                 }
 518                 if (result != USB_STOR_XFER_GOOD) {
 519                         usb_stor_dbg(us, "data transfer fail ---\n");
 520                         return USB_STOR_TRANSPORT_ERROR;
 521                 }
 522         }
 523
 524         /* Get CSW for device status */
 525         result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
 526                                             US_BULK_CS_WRAP_LEN, &cswlen);
 527
 528         if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
 529                 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
 530                 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 531                                             bcs, US_BULK_CS_WRAP_LEN, &cswlen);
 532         }
 533
 534         if (result == USB_STOR_XFER_STALLED) {
 535                 /* get the status again */
 536                 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
 537                 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
 538                                                 bcs, US_BULK_CS_WRAP_LEN, NULL);
 539         }
 540
 541         if (result != USB_STOR_XFER_GOOD)
 542                 return USB_STOR_TRANSPORT_ERROR;
 543
 544         /* check bulk status */
 545         residue = le32_to_cpu(bcs->Residue);
 546
 547         /*
 548          * try to compute the actual residue, based on how much data
 549          * was really transferred and what the device tells us
 550          */
 551         if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
 552                 residue = min(residue, transfer_length);
 553                 if (us->srb != NULL)
 554                         scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
 555                                                                 (int)residue));
 556         }
 557
 558         if (bcs->Status != US_BULK_STAT_OK)
 559                 return USB_STOR_TRANSPORT_ERROR;
 560
 561         return USB_STOR_TRANSPORT_GOOD;
 562 }
 563
 564 static int do_scsi_request_sense(struct us_data *us, struct scsi_cmnd *srb)
 565 {
 566         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 567         unsigned char buf[18];
 568
 569         memset(buf, 0, 18);
 570         buf[0] = 0x70;                          /* Current error */
 571         buf[2] = info->SrbStatus >> 16;         /* Sense key */
 572         buf[7] = 10;                            /* Additional length */
 573         buf[12] = info->SrbStatus >> 8;         /* ASC */
 574         buf[13] = info->SrbStatus;              /* ASCQ */
 575
 576         usb_stor_set_xfer_buf(buf, sizeof(buf), srb);
 577         return USB_STOR_TRANSPORT_GOOD;
 578 }
 579
 580 static int do_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
 581 {
 582         unsigned char data_ptr[36] = {
 583                 0x00, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
 584                 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
 585                 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
 586                 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
 587
 588         usb_stor_set_xfer_buf(data_ptr, 36, srb);
 589         return USB_STOR_TRANSPORT_GOOD;
 590 }
 591
 592 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
 593 {
 594         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 595
 596         if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready))
 597                 return USB_STOR_TRANSPORT_GOOD;
 598         else {
 599                 ene_sd_init(us);
 600                 return USB_STOR_TRANSPORT_GOOD;
 601         }
 602
 603         return USB_STOR_TRANSPORT_GOOD;
 604 }
 605
 606 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
 607 {
 608         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 609         unsigned char mediaNoWP[12] = {
 610                 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
 611                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
 612         unsigned char mediaWP[12]   = {
 613                 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
 614                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
 615
 616         if (info->SD_Status & SD_WtP)
 617                 usb_stor_set_xfer_buf(mediaWP, 12, srb);
 618         else
 619                 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
 620
 621
 622         return USB_STOR_TRANSPORT_GOOD;
 623 }
 624
 625 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
 626 {
 627         u32     bl_num;
 628         u32     bl_len;
 629         unsigned int offset = 0;
 630         unsigned char    buf[8];
 631         struct scatterlist *sg = NULL;
 632         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 633
 634         usb_stor_dbg(us, "sd_scsi_read_capacity\n");
 635         if (info->SD_Status & SD_HiCapacity) {
 636                 bl_len = 0x200;
 637                 if (info->SD_Status & SD_IsMMC)
 638                         bl_num = info->HC_C_SIZE-1;
 639                 else
 640                         bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
 641         } else {
 642                 bl_len = 1 << (info->SD_READ_BL_LEN);
 643                 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
 644                                 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
 645         }
 646         info->bl_num = bl_num;
 647         usb_stor_dbg(us, "bl_len = %x\n", bl_len);
 648         usb_stor_dbg(us, "bl_num = %x\n", bl_num);
 649
 650         /*srb->request_bufflen = 8; */
 651         buf[0] = (bl_num >> 24) & 0xff;
 652         buf[1] = (bl_num >> 16) & 0xff;
 653         buf[2] = (bl_num >> 8) & 0xff;
 654         buf[3] = (bl_num >> 0) & 0xff;
 655         buf[4] = (bl_len >> 24) & 0xff;
 656         buf[5] = (bl_len >> 16) & 0xff;
 657         buf[6] = (bl_len >> 8) & 0xff;
 658         buf[7] = (bl_len >> 0) & 0xff;
 659
 660         usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
 661
 662         return USB_STOR_TRANSPORT_GOOD;
 663 }
 664
 665 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
 666 {
 667         int result;
 668         unsigned char *cdb = srb->cmnd;
 669         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 670         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 671
 672         u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
 673                  ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
 674         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
 675         u32 bnByte = bn * 0x200;
 676         u32 blenByte = blen * 0x200;
 677
 678         if (bn > info->bl_num)
 679                 return USB_STOR_TRANSPORT_ERROR;
 680
 681         result = ene_load_bincode(us, SD_RW_PATTERN);
 682         if (result != USB_STOR_XFER_GOOD) {
 683                 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
 684                 return USB_STOR_TRANSPORT_ERROR;
 685         }
 686
 687         if (info->SD_Status & SD_HiCapacity)
 688                 bnByte = bn;
 689
 690         /* set up the command wrapper */
 691         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 692         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 693         bcb->DataTransferLength = blenByte;
 694         bcb->Flags  = US_BULK_FLAG_IN;
 695         bcb->CDB[0] = 0xF1;
 696         bcb->CDB[5] = (unsigned char)(bnByte);
 697         bcb->CDB[4] = (unsigned char)(bnByte>>8);
 698         bcb->CDB[3] = (unsigned char)(bnByte>>16);
 699         bcb->CDB[2] = (unsigned char)(bnByte>>24);
 700
 701         result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
 702         return result;
 703 }
 704
 705 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
 706 {
 707         int result;
 708         unsigned char *cdb = srb->cmnd;
 709         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 710         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 711
 712         u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
 713                  ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
 714         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
 715         u32 bnByte = bn * 0x200;
 716         u32 blenByte = blen * 0x200;
 717
 718         if (bn > info->bl_num)
 719                 return USB_STOR_TRANSPORT_ERROR;
 720
 721         result = ene_load_bincode(us, SD_RW_PATTERN);
 722         if (result != USB_STOR_XFER_GOOD) {
 723                 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
 724                 return USB_STOR_TRANSPORT_ERROR;
 725         }
 726
 727         if (info->SD_Status & SD_HiCapacity)
 728                 bnByte = bn;
 729
 730         /* set up the command wrapper */
 731         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 732         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 733         bcb->DataTransferLength = blenByte;
 734         bcb->Flags  = 0x00;
 735         bcb->CDB[0] = 0xF0;
 736         bcb->CDB[5] = (unsigned char)(bnByte);
 737         bcb->CDB[4] = (unsigned char)(bnByte>>8);
 738         bcb->CDB[3] = (unsigned char)(bnByte>>16);
 739         bcb->CDB[2] = (unsigned char)(bnByte>>24);
 740
 741         result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
 742         return result;
 743 }
 744
 745 /*
 746  * ENE MS Card
 747  */
 748
 749 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
 750 {
 751         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 752
 753         if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
 754                 return (u32)-1;
 755
 756         info->MS_Lib.Phy2LogMap[phyblk] = logblk;
 757         info->MS_Lib.Log2PhyMap[logblk] = phyblk;
 758
 759         return 0;
 760 }
 761
 762 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
 763 {
 764         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 765
 766         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
 767                 return (u32)-1;
 768
 769         info->MS_Lib.Phy2LogMap[phyblk] = mark;
 770
 771         return 0;
 772 }
 773
 774 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
 775 {
 776         return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
 777 }
 778
 779 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
 780 {
 781         return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
 782 }
 783
 784 static int ms_lib_free_logicalmap(struct us_data *us)
 785 {
 786         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 787
 788         kfree(info->MS_Lib.Phy2LogMap);
 789         info->MS_Lib.Phy2LogMap = NULL;
 790
 791         kfree(info->MS_Lib.Log2PhyMap);
 792         info->MS_Lib.Log2PhyMap = NULL;
 793
 794         return 0;
 795 }
 796
 797 static int ms_lib_alloc_logicalmap(struct us_data *us)
 798 {
 799         u32  i;
 800         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 801
 802         info->MS_Lib.Phy2LogMap = kmalloc_array(info->MS_Lib.NumberOfPhyBlock,
 803                                                 sizeof(u16),
 804                                                 GFP_KERNEL);
 805         info->MS_Lib.Log2PhyMap = kmalloc_array(info->MS_Lib.NumberOfLogBlock,
 806                                                 sizeof(u16),
 807                                                 GFP_KERNEL);
 808
 809         if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
 810                 ms_lib_free_logicalmap(us);
 811                 return (u32)-1;
 812         }
 813
 814         for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
 815                 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
 816
 817         for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
 818                 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
 819
 820         return 0;
 821 }
 822
 823 static void ms_lib_clear_writebuf(struct us_data *us)
 824 {
 825         int i;
 826         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 827
 828         info->MS_Lib.wrtblk = (u16)-1;
 829         ms_lib_clear_pagemap(info);
 830
 831         if (info->MS_Lib.blkpag)
 832                 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
 833
 834         if (info->MS_Lib.blkext) {
 835                 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
 836                         info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
 837                         info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
 838                         info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
 839                         info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
 840                 }
 841         }
 842 }
 843
 844 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
 845 {
 846         u32 Ende, Count;
 847         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 848
 849         Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 850         for (Count = 0; PhyBlock < Ende; PhyBlock++) {
 851                 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
 852                 case MS_LB_NOT_USED:
 853                 case MS_LB_NOT_USED_ERASED:
 854                         Count++;
 855                 default:
 856                         break;
 857                 }
 858         }
 859
 860         return Count;
 861 }
 862
 863 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
 864                 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
 865 {
 866         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 867         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 868         u8 *bbuf = info->bbuf;
 869         int result;
 870         u32 bn = PhyBlockAddr * 0x20 + PageNum;
 871
 872         result = ene_load_bincode(us, MS_RW_PATTERN);
 873         if (result != USB_STOR_XFER_GOOD)
 874                 return USB_STOR_TRANSPORT_ERROR;
 875
 876         /* Read Page Data */
 877         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 878         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 879         bcb->DataTransferLength = 0x200;
 880         bcb->Flags      = US_BULK_FLAG_IN;
 881         bcb->CDB[0]     = 0xF1;
 882
 883         bcb->CDB[1]     = 0x02; /* in init.c ENE_MSInit() is 0x01 */
 884
 885         bcb->CDB[5]     = (unsigned char)(bn);
 886         bcb->CDB[4]     = (unsigned char)(bn>>8);
 887         bcb->CDB[3]     = (unsigned char)(bn>>16);
 888         bcb->CDB[2]     = (unsigned char)(bn>>24);
 889
 890         result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
 891         if (result != USB_STOR_XFER_GOOD)
 892                 return USB_STOR_TRANSPORT_ERROR;
 893
 894
 895         /* Read Extra Data */
 896         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 897         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 898         bcb->DataTransferLength = 0x4;
 899         bcb->Flags      = US_BULK_FLAG_IN;
 900         bcb->CDB[0]     = 0xF1;
 901         bcb->CDB[1]     = 0x03;
 902
 903         bcb->CDB[5]     = (unsigned char)(PageNum);
 904         bcb->CDB[4]     = (unsigned char)(PhyBlockAddr);
 905         bcb->CDB[3]     = (unsigned char)(PhyBlockAddr>>8);
 906         bcb->CDB[2]     = (unsigned char)(PhyBlockAddr>>16);
 907         bcb->CDB[6]     = 0x01;
 908
 909         result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
 910         if (result != USB_STOR_XFER_GOOD)
 911                 return USB_STOR_TRANSPORT_ERROR;
 912
 913         ExtraDat->reserved = 0;
 914         ExtraDat->intr     = 0x80;  /* Not yet,fireware support */
 915         ExtraDat->status0  = 0x10;  /* Not yet,fireware support */
 916
 917         ExtraDat->status1  = 0x00;  /* Not yet,fireware support */
 918         ExtraDat->ovrflg   = bbuf[0];
 919         ExtraDat->mngflg   = bbuf[1];
 920         ExtraDat->logadr   = memstick_logaddr(bbuf[2], bbuf[3]);
 921
 922         return USB_STOR_TRANSPORT_GOOD;
 923 }
 924
 925 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
 926 {
 927         struct ms_bootblock_sysent *SysEntry;
 928         struct ms_bootblock_sysinf *SysInfo;
 929         u32 i, result;
 930         u8 PageNumber;
 931         u8 *PageBuffer;
 932         struct ms_lib_type_extdat ExtraData;
 933         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 934
 935         PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
 936         if (PageBuffer == NULL)
 937                 return (u32)-1;
 938
 939         result = (u32)-1;
 940
 941         SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
 942
 943         if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
 944                 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
 945                 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
 946                 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
 947                 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
 948                 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
 949                 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
 950                 goto exit;
 951                 /* */
 952         switch (info->MS_Lib.cardType = SysInfo->bCardType) {
 953         case MS_SYSINF_CARDTYPE_RDONLY:
 954                 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
 955                 break;
 956         case MS_SYSINF_CARDTYPE_RDWR:
 957                 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
 958                 break;
 959         case MS_SYSINF_CARDTYPE_HYBRID:
 960         default:
 961                 goto exit;
 962         }
 963
 964         info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
 965         info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
 966         info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
 967         info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
 968         info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 969         info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
 970
 971         /*Allocate to all number of logicalblock and physicalblock */
 972         if (ms_lib_alloc_logicalmap(us))
 973                 goto exit;
 974
 975         /* Mark the book block */
 976         ms_lib_set_bootblockmark(us, PhyBlock);
 977
 978         SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
 979
 980         for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
 981                 u32  EntryOffset, EntrySize;
 982
 983                 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
 984
 985                 if (EntryOffset == 0xffffff)
 986                         continue;
 987                 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
 988
 989                 if (EntrySize == 0)
 990                         continue;
 991
 992                 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
 993                         continue;
 994
 995                 if (i == 0) {
 996                         u8 PrevPageNumber = 0;
 997                         u16 phyblk;
 998
 999                         if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
1000                                 goto exit;
1001
1002                         while (EntrySize > 0) {
1003
1004                                 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1005                                 if (PageNumber != PrevPageNumber) {
1006                                         switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1007                                         case MS_STATUS_SUCCESS:
1008                                                 break;
1009                                         case MS_STATUS_WRITE_PROTECT:
1010                                         case MS_ERROR_FLASH_READ:
1011                                         case MS_STATUS_ERROR:
1012                                         default:
1013                                                 goto exit;
1014                                         }
1015
1016                                         PrevPageNumber = PageNumber;
1017                                 }
1018
1019                                 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1020                                 if (phyblk < 0x0fff)
1021                                         ms_lib_set_initialerrorblock(us, phyblk);
1022
1023                                 EntryOffset += 2;
1024                                 EntrySize -= 2;
1025                         }
1026                 } else if (i == 1) {  /* CIS/IDI */
1027                         struct ms_bootblock_idi *idi;
1028
1029                         if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1030                                 goto exit;
1031
1032                         switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1033                         case MS_STATUS_SUCCESS:
1034                                 break;
1035                         case MS_STATUS_WRITE_PROTECT:
1036                         case MS_ERROR_FLASH_READ:
1037                         case MS_STATUS_ERROR:
1038                         default:
1039                                 goto exit;
1040                         }
1041
1042                         idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1043                         if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1044                                 goto exit;
1045
1046                         info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1047                         if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1048                                 goto exit;
1049                 }
1050         } /* End for .. */
1051
1052         result = 0;
1053
1054 exit:
1055         if (result)
1056                 ms_lib_free_logicalmap(us);
1057
1058         kfree(PageBuffer);
1059
1060         result = 0;
1061         return result;
1062 }
1063
1064 static void ms_lib_free_writebuf(struct us_data *us)
1065 {
1066         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1067         info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1068
1069         /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1070
1071         ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1072
1073         if (info->MS_Lib.blkpag) {
1074                 kfree(info->MS_Lib.blkpag);  /* Arnold test ... */
1075                 info->MS_Lib.blkpag = NULL;
1076         }
1077
1078         if (info->MS_Lib.blkext) {
1079                 kfree(info->MS_Lib.blkext);  /* Arnold test ... */
1080                 info->MS_Lib.blkext = NULL;
1081         }
1082 }
1083
1084
1085 static void ms_lib_free_allocatedarea(struct us_data *us)
1086 {
1087         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1088
1089         ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1090         ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1091
1092         /* set struct us point flag to 0 */
1093         info->MS_Lib.flags = 0;
1094         info->MS_Lib.BytesPerSector = 0;
1095         info->MS_Lib.SectorsPerCylinder = 0;
1096
1097         info->MS_Lib.cardType = 0;
1098         info->MS_Lib.blockSize = 0;
1099         info->MS_Lib.PagesPerBlock = 0;
1100
1101         info->MS_Lib.NumberOfPhyBlock = 0;
1102         info->MS_Lib.NumberOfLogBlock = 0;
1103 }
1104
1105
1106 static int ms_lib_alloc_writebuf(struct us_data *us)
1107 {
1108         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1109
1110         info->MS_Lib.wrtblk = (u16)-1;
1111
1112         info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock,
1113                                             info->MS_Lib.BytesPerSector,
1114                                             GFP_KERNEL);
1115         info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock,
1116                                             sizeof(struct ms_lib_type_extdat),
1117                                             GFP_KERNEL);
1118
1119         if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1120                 ms_lib_free_writebuf(us);
1121                 return (u32)-1;
1122         }
1123
1124         ms_lib_clear_writebuf(us);
1125
1126 return 0;
1127 }
1128
1129 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1130 {
1131         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1132
1133         if (logblk == MS_LB_NOT_USED)
1134                 return 0;
1135
1136         if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1137                 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1138                 return (u32)-1;
1139
1140         info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1141         info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1142
1143         return 0;
1144 }
1145
1146 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1147                         u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1148 {
1149         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1150         int result;
1151
1152         result = ene_load_bincode(us, MS_RW_PATTERN);
1153         if (result != USB_STOR_XFER_GOOD)
1154                 return USB_STOR_TRANSPORT_ERROR;
1155
1156         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1157         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1158         bcb->DataTransferLength = 0x200*len;
1159         bcb->Flags = 0x00;
1160         bcb->CDB[0] = 0xF0;
1161         bcb->CDB[1] = 0x08;
1162         bcb->CDB[4] = (unsigned char)(oldphy);
1163         bcb->CDB[3] = (unsigned char)(oldphy>>8);
1164         bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1165         bcb->CDB[7] = (unsigned char)(newphy);
1166         bcb->CDB[6] = (unsigned char)(newphy>>8);
1167         bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1168         bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1169         bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1170         bcb->CDB[10] = PageNum;
1171
1172         result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1173         if (result != USB_STOR_XFER_GOOD)
1174                 return USB_STOR_TRANSPORT_ERROR;
1175
1176         return USB_STOR_TRANSPORT_GOOD;
1177 }
1178
1179 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1180 {
1181         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1182         int result;
1183         u32 bn = PhyBlockAddr;
1184
1185         result = ene_load_bincode(us, MS_RW_PATTERN);
1186         if (result != USB_STOR_XFER_GOOD)
1187                 return USB_STOR_TRANSPORT_ERROR;
1188
1189         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1190         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1191         bcb->DataTransferLength = 0x200;
1192         bcb->Flags = US_BULK_FLAG_IN;
1193         bcb->CDB[0] = 0xF2;
1194         bcb->CDB[1] = 0x06;
1195         bcb->CDB[4] = (unsigned char)(bn);
1196         bcb->CDB[3] = (unsigned char)(bn>>8);
1197         bcb->CDB[2] = (unsigned char)(bn>>16);
1198
1199         result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1200         if (result != USB_STOR_XFER_GOOD)
1201                 return USB_STOR_TRANSPORT_ERROR;
1202
1203         return USB_STOR_TRANSPORT_GOOD;
1204 }
1205
1206 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1207 {
1208         unsigned char *PageBuf = NULL;
1209         u16 result = MS_STATUS_SUCCESS;
1210         u16 blk, index = 0;
1211         struct ms_lib_type_extdat extdat;
1212         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1213
1214         PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1215         if (PageBuf == NULL) {
1216                 result = MS_NO_MEMORY_ERROR;
1217                 goto exit;
1218         }
1219
1220         ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1221         do {
1222                 blk = be16_to_cpu(PageBuf[index]);
1223                 if (blk == MS_LB_NOT_USED)
1224                         break;
1225                 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1226                         result = MS_ERROR_FLASH_READ;
1227                         break;
1228                 }
1229                 index++;
1230         } while (1);
1231
1232 exit:
1233         kfree(PageBuf);
1234         return result;
1235 }
1236
1237 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1238 {
1239         u16 log;
1240         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1241
1242         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1243                 return (u32)-1;
1244
1245         log = info->MS_Lib.Phy2LogMap[phyblk];
1246
1247         if (log < info->MS_Lib.NumberOfLogBlock)
1248                 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1249
1250         if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1251                 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1252
1253         return 0;
1254 }
1255
1256 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1257                                 u8 PageNum, u8 OverwriteFlag)
1258 {
1259         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1260         int result;
1261
1262         result = ene_load_bincode(us, MS_RW_PATTERN);
1263         if (result != USB_STOR_XFER_GOOD)
1264                 return USB_STOR_TRANSPORT_ERROR;
1265
1266         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1267         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1268         bcb->DataTransferLength = 0x4;
1269         bcb->Flags = US_BULK_FLAG_IN;
1270         bcb->CDB[0] = 0xF2;
1271         bcb->CDB[1] = 0x05;
1272         bcb->CDB[5] = (unsigned char)(PageNum);
1273         bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1274         bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1275         bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1276         bcb->CDB[6] = OverwriteFlag;
1277         bcb->CDB[7] = 0xFF;
1278         bcb->CDB[8] = 0xFF;
1279         bcb->CDB[9] = 0xFF;
1280
1281         result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1282         if (result != USB_STOR_XFER_GOOD)
1283                 return USB_STOR_TRANSPORT_ERROR;
1284
1285         return USB_STOR_TRANSPORT_GOOD;
1286 }
1287
1288 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1289 {
1290         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1291
1292         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1293                 return MS_STATUS_ERROR;
1294
1295         ms_lib_setacquired_errorblock(us, phyblk);
1296
1297         if (ms_lib_iswritable(info))
1298                 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1299
1300         return MS_STATUS_SUCCESS;
1301 }
1302
1303 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1304 {
1305         u16 log;
1306         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1307
1308         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1309                 return MS_STATUS_ERROR;
1310
1311         log = info->MS_Lib.Phy2LogMap[phyblk];
1312
1313         if (log < info->MS_Lib.NumberOfLogBlock)
1314                 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1315
1316         info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1317
1318         if (ms_lib_iswritable(info)) {
1319                 switch (ms_read_eraseblock(us, phyblk)) {
1320                 case MS_STATUS_SUCCESS:
1321                         info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1322                         return MS_STATUS_SUCCESS;
1323                 case MS_ERROR_FLASH_ERASE:
1324                 case MS_STATUS_INT_ERROR:
1325                         ms_lib_error_phyblock(us, phyblk);
1326                         return MS_ERROR_FLASH_ERASE;
1327                 case MS_STATUS_ERROR:
1328                 default:
1329                         ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1330                         ms_lib_setacquired_errorblock(us, phyblk);
1331                         return MS_STATUS_ERROR;
1332                 }
1333         }
1334
1335         ms_lib_setacquired_errorblock(us, phyblk);
1336
1337         return MS_STATUS_SUCCESS;
1338 }
1339
1340 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1341                                 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1342 {
1343         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1344         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1345         u8 *bbuf = info->bbuf;
1346         int result;
1347
1348         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1349         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1350         bcb->DataTransferLength = 0x4;
1351         bcb->Flags      = US_BULK_FLAG_IN;
1352         bcb->CDB[0]     = 0xF1;
1353         bcb->CDB[1]     = 0x03;
1354         bcb->CDB[5]     = (unsigned char)(PageNum);
1355         bcb->CDB[4]     = (unsigned char)(PhyBlock);
1356         bcb->CDB[3]     = (unsigned char)(PhyBlock>>8);
1357         bcb->CDB[2]     = (unsigned char)(PhyBlock>>16);
1358         bcb->CDB[6]     = 0x01;
1359
1360         result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1361         if (result != USB_STOR_XFER_GOOD)
1362                 return USB_STOR_TRANSPORT_ERROR;
1363
1364         ExtraDat->reserved = 0;
1365         ExtraDat->intr     = 0x80;  /* Not yet, waiting for fireware support */
1366         ExtraDat->status0  = 0x10;  /* Not yet, waiting for fireware support */
1367         ExtraDat->status1  = 0x00;  /* Not yet, waiting for fireware support */
1368         ExtraDat->ovrflg   = bbuf[0];
1369         ExtraDat->mngflg   = bbuf[1];
1370         ExtraDat->logadr   = memstick_logaddr(bbuf[2], bbuf[3]);
1371
1372         return USB_STOR_TRANSPORT_GOOD;
1373 }
1374
1375 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1376 {
1377         u16 blk;
1378         struct ms_lib_type_extdat extdat; /* need check */
1379         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1380
1381
1382         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1383                 return MS_LB_ERROR;
1384
1385         for (blk = phyblk + 1; blk != phyblk; blk++) {
1386                 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1387                         blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1388
1389                 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1390                         return blk;
1391                 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1392                         switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1393                         case MS_STATUS_SUCCESS:
1394                         case MS_STATUS_SUCCESS_WITH_ECC:
1395                                 break;
1396                         case MS_NOCARD_ERROR:
1397                                 return MS_NOCARD_ERROR;
1398                         case MS_STATUS_INT_ERROR:
1399                                 return MS_LB_ERROR;
1400                         case MS_ERROR_FLASH_READ:
1401                         default:
1402                                 ms_lib_setacquired_errorblock(us, blk);
1403                                 continue;
1404                         } /* End switch */
1405
1406                         if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1407                                 ms_lib_setacquired_errorblock(us, blk);
1408                                 continue;
1409                         }
1410
1411                         switch (ms_lib_erase_phyblock(us, blk)) {
1412                         case MS_STATUS_SUCCESS:
1413                                 return blk;
1414                         case MS_STATUS_ERROR:
1415                                 return MS_LB_ERROR;
1416                         case MS_ERROR_FLASH_ERASE:
1417                         default:
1418                                 ms_lib_error_phyblock(us, blk);
1419                                 break;
1420                         }
1421                 }
1422         } /* End for */
1423
1424         return MS_LB_ERROR;
1425 }
1426 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1427 {
1428         u16 phyblk;
1429         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1430
1431         phyblk = ms_libconv_to_physical(info, logblk);
1432         if (phyblk >= MS_LB_ERROR) {
1433                 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1434                         return MS_LB_ERROR;
1435
1436                 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1437                 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1438                 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1439         }
1440
1441         return ms_libsearch_block_from_physical(us, phyblk);
1442 }
1443
1444 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1445 {
1446         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1447
1448         /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1449         if ((info->MS_Status & MS_Insert) && (info->MS_Status & MS_Ready)) {
1450                 return USB_STOR_TRANSPORT_GOOD;
1451         } else {
1452                 ene_ms_init(us);
1453                 return USB_STOR_TRANSPORT_GOOD;
1454         }
1455
1456         return USB_STOR_TRANSPORT_GOOD;
1457 }
1458
1459 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1460 {
1461         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1462         unsigned char mediaNoWP[12] = {
1463                 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1464                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1465         unsigned char mediaWP[12]   = {
1466                 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1467                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1468
1469         if (info->MS_Status & MS_WtP)
1470                 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1471         else
1472                 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1473
1474         return USB_STOR_TRANSPORT_GOOD;
1475 }
1476
1477 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1478 {
1479         u32   bl_num;
1480         u16    bl_len;
1481         unsigned int offset = 0;
1482         unsigned char    buf[8];
1483         struct scatterlist *sg = NULL;
1484         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1485
1486         usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1487         bl_len = 0x200;
1488         if (info->MS_Status & MS_IsMSPro)
1489                 bl_num = info->MSP_TotalBlock - 1;
1490         else
1491                 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1492
1493         info->bl_num = bl_num;
1494         usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1495         usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1496
1497         /*srb->request_bufflen = 8; */
1498         buf[0] = (bl_num >> 24) & 0xff;
1499         buf[1] = (bl_num >> 16) & 0xff;
1500         buf[2] = (bl_num >> 8) & 0xff;
1501         buf[3] = (bl_num >> 0) & 0xff;
1502         buf[4] = (bl_len >> 24) & 0xff;
1503         buf[5] = (bl_len >> 16) & 0xff;
1504         buf[6] = (bl_len >> 8) & 0xff;
1505         buf[7] = (bl_len >> 0) & 0xff;
1506
1507         usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1508
1509         return USB_STOR_TRANSPORT_GOOD;
1510 }
1511
1512 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1513 {
1514         PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1515
1516         if (PhyBlock) {
1517                 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1518                 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1519         } else {
1520                 *LogStart = 0;
1521                 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1522         }
1523 }
1524
1525 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1526         u8 PageNum, u8 blen, void *buf)
1527 {
1528         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1529         int     result;
1530
1531         /* Read Extra Data */
1532         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1533         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1534         bcb->DataTransferLength = 0x4 * blen;
1535         bcb->Flags      = US_BULK_FLAG_IN;
1536         bcb->CDB[0]     = 0xF1;
1537         bcb->CDB[1]     = 0x03;
1538         bcb->CDB[5]     = (unsigned char)(PageNum);
1539         bcb->CDB[4]     = (unsigned char)(PhyBlock);
1540         bcb->CDB[3]     = (unsigned char)(PhyBlock>>8);
1541         bcb->CDB[2]     = (unsigned char)(PhyBlock>>16);
1542         bcb->CDB[6]     = blen;
1543
1544         result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1545         if (result != USB_STOR_XFER_GOOD)
1546                 return USB_STOR_TRANSPORT_ERROR;
1547
1548         return USB_STOR_TRANSPORT_GOOD;
1549 }
1550
1551 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1552 {
1553         u16 PhyBlock, newblk, i;
1554         u16 LogStart, LogEnde;
1555         struct ms_lib_type_extdat extdat;
1556         u32 count = 0, index = 0;
1557         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1558         u8 *bbuf = info->bbuf;
1559
1560         for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1561                 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1562
1563                 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1564                         switch (ms_libconv_to_logical(info, PhyBlock)) {
1565                         case MS_STATUS_ERROR:
1566                                 continue;
1567                         default:
1568                                 break;
1569                         }
1570
1571                         if (count == PhyBlock) {
1572                                 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1573                                                 bbuf);
1574                                 count += 0x80;
1575                         }
1576                         index = (PhyBlock % 0x80) * 4;
1577
1578                         extdat.ovrflg = bbuf[index];
1579                         extdat.mngflg = bbuf[index+1];
1580                         extdat.logadr = memstick_logaddr(bbuf[index+2],
1581                                         bbuf[index+3]);
1582
1583                         if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1584                                 ms_lib_setacquired_errorblock(us, PhyBlock);
1585                                 continue;
1586                         }
1587
1588                         if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1589                                 ms_lib_erase_phyblock(us, PhyBlock);
1590                                 continue;
1591                         }
1592
1593                         if (extdat.logadr != MS_LB_NOT_USED) {
1594                                 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1595                                         ms_lib_erase_phyblock(us, PhyBlock);
1596                                         continue;
1597                                 }
1598
1599                                 newblk = ms_libconv_to_physical(info, extdat.logadr);
1600
1601                                 if (newblk != MS_LB_NOT_USED) {
1602                                         if (extdat.logadr == 0) {
1603                                                 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1604                                                 if (ms_lib_check_disableblock(us, btBlk1st)) {
1605                                                         ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1606                                                         continue;
1607                                                 }
1608                                         }
1609
1610                                         ms_lib_read_extra(us, newblk, 0, &extdat);
1611                                         if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1612                                                 ms_lib_erase_phyblock(us, PhyBlock);
1613                                                 continue;
1614                                         } else {
1615                                                 ms_lib_erase_phyblock(us, newblk);
1616                                         }
1617                                 }
1618
1619                                 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1620                         }
1621                 }
1622         } /* End for ... */
1623
1624         return MS_STATUS_SUCCESS;
1625 }
1626
1627
1628 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1629 {
1630         int result;
1631         unsigned char *cdb = srb->cmnd;
1632         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1633         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1634
1635         u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1636                 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1637         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1638         u32 blenByte = blen * 0x200;
1639
1640         if (bn > info->bl_num)
1641                 return USB_STOR_TRANSPORT_ERROR;
1642
1643         if (info->MS_Status & MS_IsMSPro) {
1644                 result = ene_load_bincode(us, MSP_RW_PATTERN);
1645                 if (result != USB_STOR_XFER_GOOD) {
1646                         usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1647                         return USB_STOR_TRANSPORT_ERROR;
1648                 }
1649
1650                 /* set up the command wrapper */
1651                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1652                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1653                 bcb->DataTransferLength = blenByte;
1654                 bcb->Flags  = US_BULK_FLAG_IN;
1655                 bcb->CDB[0] = 0xF1;
1656                 bcb->CDB[1] = 0x02;
1657                 bcb->CDB[5] = (unsigned char)(bn);
1658                 bcb->CDB[4] = (unsigned char)(bn>>8);
1659                 bcb->CDB[3] = (unsigned char)(bn>>16);
1660                 bcb->CDB[2] = (unsigned char)(bn>>24);
1661
1662                 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1663         } else {
1664                 void *buf;
1665                 int offset = 0;
1666                 u16 phyblk, logblk;
1667                 u8 PageNum;
1668                 u16 len;
1669                 u32 blkno;
1670
1671                 buf = kmalloc(blenByte, GFP_KERNEL);
1672                 if (buf == NULL)
1673                         return USB_STOR_TRANSPORT_ERROR;
1674
1675                 result = ene_load_bincode(us, MS_RW_PATTERN);
1676                 if (result != USB_STOR_XFER_GOOD) {
1677                         pr_info("Load MS RW pattern Fail !!\n");
1678                         result = USB_STOR_TRANSPORT_ERROR;
1679                         goto exit;
1680                 }
1681
1682                 logblk  = (u16)(bn / info->MS_Lib.PagesPerBlock);
1683                 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1684
1685                 while (1) {
1686                         if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1687                                 len = info->MS_Lib.PagesPerBlock-PageNum;
1688                         else
1689                                 len = blen;
1690
1691                         phyblk = ms_libconv_to_physical(info, logblk);
1692                         blkno  = phyblk * 0x20 + PageNum;
1693
1694                         /* set up the command wrapper */
1695                         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1696                         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1697                         bcb->DataTransferLength = 0x200 * len;
1698                         bcb->Flags  = US_BULK_FLAG_IN;
1699                         bcb->CDB[0] = 0xF1;
1700                         bcb->CDB[1] = 0x02;
1701                         bcb->CDB[5] = (unsigned char)(blkno);
1702                         bcb->CDB[4] = (unsigned char)(blkno>>8);
1703                         bcb->CDB[3] = (unsigned char)(blkno>>16);
1704                         bcb->CDB[2] = (unsigned char)(blkno>>24);
1705
1706                         result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1707                         if (result != USB_STOR_XFER_GOOD) {
1708                                 pr_info("MS_SCSI_Read --- result = %x\n", result);
1709                                 result = USB_STOR_TRANSPORT_ERROR;
1710                                 goto exit;
1711                         }
1712
1713                         blen -= len;
1714                         if (blen <= 0)
1715                                 break;
1716                         logblk++;
1717                         PageNum = 0;
1718                         offset += MS_BYTES_PER_PAGE*len;
1719                 }
1720                 usb_stor_set_xfer_buf(buf, blenByte, srb);
1721 exit:
1722                 kfree(buf);
1723         }
1724         return result;
1725 }
1726
1727 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1728 {
1729         int result;
1730         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1731         unsigned char *cdb = srb->cmnd;
1732         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1733
1734         u32 bn = ((cdb[2] << 24) & 0xff000000) |
1735                         ((cdb[3] << 16) & 0x00ff0000) |
1736                         ((cdb[4] << 8) & 0x0000ff00) |
1737                         ((cdb[5] << 0) & 0x000000ff);
1738         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1739         u32 blenByte = blen * 0x200;
1740
1741         if (bn > info->bl_num)
1742                 return USB_STOR_TRANSPORT_ERROR;
1743
1744         if (info->MS_Status & MS_IsMSPro) {
1745                 result = ene_load_bincode(us, MSP_RW_PATTERN);
1746                 if (result != USB_STOR_XFER_GOOD) {
1747                         pr_info("Load MSP RW pattern Fail !!\n");
1748                         return USB_STOR_TRANSPORT_ERROR;
1749                 }
1750
1751                 /* set up the command wrapper */
1752                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1753                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1754                 bcb->DataTransferLength = blenByte;
1755                 bcb->Flags  = 0x00;
1756                 bcb->CDB[0] = 0xF0;
1757                 bcb->CDB[1] = 0x04;
1758                 bcb->CDB[5] = (unsigned char)(bn);
1759                 bcb->CDB[4] = (unsigned char)(bn>>8);
1760                 bcb->CDB[3] = (unsigned char)(bn>>16);
1761                 bcb->CDB[2] = (unsigned char)(bn>>24);
1762
1763                 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1764         } else {
1765                 void *buf;
1766                 int offset = 0;
1767                 u16 PhyBlockAddr;
1768                 u8 PageNum;
1769                 u16 len, oldphy, newphy;
1770
1771                 buf = kmalloc(blenByte, GFP_KERNEL);
1772                 if (buf == NULL)
1773                         return USB_STOR_TRANSPORT_ERROR;
1774                 usb_stor_set_xfer_buf(buf, blenByte, srb);
1775
1776                 result = ene_load_bincode(us, MS_RW_PATTERN);
1777                 if (result != USB_STOR_XFER_GOOD) {
1778                         pr_info("Load MS RW pattern Fail !!\n");
1779                         result = USB_STOR_TRANSPORT_ERROR;
1780                         goto exit;
1781                 }
1782
1783                 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1784                 PageNum      = (u8)(bn % info->MS_Lib.PagesPerBlock);
1785
1786                 while (1) {
1787                         if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1788                                 len = info->MS_Lib.PagesPerBlock-PageNum;
1789                         else
1790                                 len = blen;
1791
1792                         oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1793                         newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1794
1795                         result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1796
1797                         if (result != USB_STOR_XFER_GOOD) {
1798                                 pr_info("MS_SCSI_Write --- result = %x\n", result);
1799                                 result =  USB_STOR_TRANSPORT_ERROR;
1800                                 goto exit;
1801                         }
1802
1803                         info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1804                         ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1805
1806                         blen -= len;
1807                         if (blen <= 0)
1808                                 break;
1809                         PhyBlockAddr++;
1810                         PageNum = 0;
1811                         offset += MS_BYTES_PER_PAGE*len;
1812                 }
1813 exit:
1814                 kfree(buf);
1815         }
1816         return result;
1817 }
1818
1819 /*
1820  * ENE MS Card
1821  */
1822
1823 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1824 {
1825         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1826         int result;
1827
1828         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1829         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1830         bcb->DataTransferLength = 0x01;
1831         bcb->Flags                      = US_BULK_FLAG_IN;
1832         bcb->CDB[0]                     = 0xED;
1833         bcb->CDB[2]                     = (unsigned char)(index>>8);
1834         bcb->CDB[3]                     = (unsigned char)index;
1835
1836         result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1837         return result;
1838 }
1839
1840 static int ene_get_card_status(struct us_data *us, u8 *buf)
1841 {
1842         u16 tmpreg;
1843         u32 reg4b;
1844         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1845
1846         /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1847         reg4b = *(u32 *)&buf[0x18];
1848         info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1849
1850         tmpreg = (u16) reg4b;
1851         reg4b = *(u32 *)(&buf[0x14]);
1852         if ((info->SD_Status & SD_HiCapacity) && !(info->SD_Status & SD_IsMMC))
1853                 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1854
1855         info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1856         info->SD_C_SIZE_MULT = (u8)(reg4b >> 7)  & 0x07;
1857         if ((info->SD_Status & SD_HiCapacity) && (info->SD_Status & SD_IsMMC))
1858                 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1859
1860         if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1861                 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1862                 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1863         } else {
1864                 info->SD_Block_Mult = 1;
1865         }
1866
1867         return USB_STOR_TRANSPORT_GOOD;
1868 }
1869
1870 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1871 {
1872         int err;
1873         char *fw_name = NULL;
1874         unsigned char *buf = NULL;
1875         const struct firmware *sd_fw = NULL;
1876         int result = USB_STOR_TRANSPORT_ERROR;
1877         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1878         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1879
1880         if (info->BIN_FLAG == flag)
1881                 return USB_STOR_TRANSPORT_GOOD;
1882
1883         switch (flag) {
1884         /* For SD */
1885         case SD_INIT1_PATTERN:
1886                 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1887                 fw_name = SD_INIT1_FIRMWARE;
1888                 break;
1889         case SD_INIT2_PATTERN:
1890                 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1891                 fw_name = SD_INIT2_FIRMWARE;
1892                 break;
1893         case SD_RW_PATTERN:
1894                 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1895                 fw_name = SD_RW_FIRMWARE;
1896                 break;
1897         /* For MS */
1898         case MS_INIT_PATTERN:
1899                 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1900                 fw_name = MS_INIT_FIRMWARE;
1901                 break;
1902         case MSP_RW_PATTERN:
1903                 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1904                 fw_name = MSP_RW_FIRMWARE;
1905                 break;
1906         case MS_RW_PATTERN:
1907                 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1908                 fw_name = MS_RW_FIRMWARE;
1909                 break;
1910         default:
1911                 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1912                 goto nofw;
1913         }
1914
1915         err = reject_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1916         if (err) {
1917                 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1918                 goto nofw;
1919         }
1920         buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1921         if (buf == NULL)
1922                 goto nofw;
1923
1924         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1925         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1926         bcb->DataTransferLength = sd_fw->size;
1927         bcb->Flags = 0x00;
1928         bcb->CDB[0] = 0xEF;
1929
1930         result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1931         if (us->srb != NULL)
1932                 scsi_set_resid(us->srb, 0);
1933         info->BIN_FLAG = flag;
1934         kfree(buf);
1935
1936 nofw:
1937         release_firmware(sd_fw);
1938         return result;
1939 }
1940
1941 static int ms_card_init(struct us_data *us)
1942 {
1943         u32 result;
1944         u16 TmpBlock;
1945         unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1946         struct ms_lib_type_extdat extdat;
1947         u16 btBlk1st, btBlk2nd;
1948         u32 btBlk1stErred;
1949         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1950
1951         printk(KERN_INFO "MS_CardInit start\n");
1952
1953         ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1954
1955         /* get two PageBuffer */
1956         PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1957         PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1958         if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1959                 result = MS_NO_MEMORY_ERROR;
1960                 goto exit;
1961         }
1962
1963         btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1964         btBlk1stErred = 0;
1965
1966         for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1967
1968                 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1969                 case MS_STATUS_SUCCESS:
1970                         break;
1971                 case MS_STATUS_INT_ERROR:
1972                         break;
1973                 case MS_STATUS_ERROR:
1974                 default:
1975                         continue;
1976                 }
1977
1978                 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1979                         continue;
1980
1981                 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1982                         (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1983                         (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1984                         (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1985                                 continue;
1986
1987                 if (btBlk1st != MS_LB_NOT_USED) {
1988                         btBlk2nd = TmpBlock;
1989                         break;
1990                 }
1991
1992                 btBlk1st = TmpBlock;
1993                 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
1994                 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
1995                         btBlk1stErred = 1;
1996         }
1997
1998         if (btBlk1st == MS_LB_NOT_USED) {
1999                 result = MS_STATUS_ERROR;
2000                 goto exit;
2001         }
2002
2003         /* write protect */
2004         if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2005                 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2006
2007         result = MS_STATUS_ERROR;
2008         /* 1st Boot Block */
2009         if (btBlk1stErred == 0)
2010                 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2011                 /* 1st */
2012         /* 2nd Boot Block */
2013         if (result && (btBlk2nd != MS_LB_NOT_USED))
2014                 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2015
2016         if (result) {
2017                 result = MS_STATUS_ERROR;
2018                 goto exit;
2019         }
2020
2021         for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2022                 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2023
2024         info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2025
2026         if (btBlk2nd != MS_LB_NOT_USED) {
2027                 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2028                         info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2029
2030                 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2031         }
2032
2033         result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2034         if (result)
2035                 goto exit;
2036
2037         for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2038                 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2039                 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2040                 if (ms_count_freeblock(us, TmpBlock) == 0) {
2041                         ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2042                         break;
2043                 }
2044         }
2045
2046         /* write */
2047         if (ms_lib_alloc_writebuf(us)) {
2048                 result = MS_NO_MEMORY_ERROR;
2049                 goto exit;
2050         }
2051
2052         result = MS_STATUS_SUCCESS;
2053
2054 exit:
2055         kfree(PageBuffer1);
2056         kfree(PageBuffer0);
2057
2058         printk(KERN_INFO "MS_CardInit end\n");
2059         return result;
2060 }
2061
2062 static int ene_ms_init(struct us_data *us)
2063 {
2064         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2065         int result;
2066         u16 MSP_BlockSize, MSP_UserAreaBlocks;
2067         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2068         u8 *bbuf = info->bbuf;
2069         unsigned int s;
2070
2071         printk(KERN_INFO "transport --- ENE_MSInit\n");
2072
2073         /* the same part to test ENE */
2074
2075         result = ene_load_bincode(us, MS_INIT_PATTERN);
2076         if (result != USB_STOR_XFER_GOOD) {
2077                 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2078                 return USB_STOR_TRANSPORT_ERROR;
2079         }
2080
2081         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2082         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2083         bcb->DataTransferLength = 0x200;
2084         bcb->Flags      = US_BULK_FLAG_IN;
2085         bcb->CDB[0]     = 0xF1;
2086         bcb->CDB[1]     = 0x01;
2087
2088         result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2089         if (result != USB_STOR_XFER_GOOD) {
2090                 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2091                 return USB_STOR_TRANSPORT_ERROR;
2092         }
2093         /* the same part to test ENE */
2094         info->MS_Status = bbuf[0];
2095
2096         s = info->MS_Status;
2097         if ((s & MS_Insert) && (s & MS_Ready)) {
2098                 printk(KERN_INFO "Insert     = %x\n", !!(s & MS_Insert));
2099                 printk(KERN_INFO "Ready      = %x\n", !!(s & MS_Ready));
2100                 printk(KERN_INFO "IsMSPro    = %x\n", !!(s & MS_IsMSPro));
2101                 printk(KERN_INFO "IsMSPHG    = %x\n", !!(s & MS_IsMSPHG));
2102                 printk(KERN_INFO "WtP= %x\n", !!(s & MS_WtP));
2103                 if (s & MS_IsMSPro) {
2104                         MSP_BlockSize      = (bbuf[6] << 8) | bbuf[7];
2105                         MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
2106                         info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2107                 } else {
2108                         ms_card_init(us); /* Card is MS (to ms.c)*/
2109                 }
2110                 usb_stor_dbg(us, "MS Init Code OK !!\n");
2111         } else {
2112                 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
2113                 return USB_STOR_TRANSPORT_ERROR;
2114         }
2115
2116         return USB_STOR_TRANSPORT_GOOD;
2117 }
2118
2119 static int ene_sd_init(struct us_data *us)
2120 {
2121         int result;
2122         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2123         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2124         u8 *bbuf = info->bbuf;
2125
2126         usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2127         /* SD Init Part-1 */
2128         result = ene_load_bincode(us, SD_INIT1_PATTERN);
2129         if (result != USB_STOR_XFER_GOOD) {
2130                 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2131                 return USB_STOR_TRANSPORT_ERROR;
2132         }
2133
2134         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2135         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2136         bcb->Flags = US_BULK_FLAG_IN;
2137         bcb->CDB[0] = 0xF2;
2138
2139         result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2140         if (result != USB_STOR_XFER_GOOD) {
2141                 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2142                 return USB_STOR_TRANSPORT_ERROR;
2143         }
2144
2145         /* SD Init Part-2 */
2146         result = ene_load_bincode(us, SD_INIT2_PATTERN);
2147         if (result != USB_STOR_XFER_GOOD) {
2148                 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2149                 return USB_STOR_TRANSPORT_ERROR;
2150         }
2151
2152         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2153         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2154         bcb->DataTransferLength = 0x200;
2155         bcb->Flags              = US_BULK_FLAG_IN;
2156         bcb->CDB[0]             = 0xF1;
2157
2158         result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2159         if (result != USB_STOR_XFER_GOOD) {
2160                 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2161                 return USB_STOR_TRANSPORT_ERROR;
2162         }
2163
2164         info->SD_Status = bbuf[0];
2165         if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready)) {
2166                 unsigned int s = info->SD_Status;
2167
2168                 ene_get_card_status(us, bbuf);
2169                 usb_stor_dbg(us, "Insert     = %x\n", !!(s & SD_Insert));
2170                 usb_stor_dbg(us, "Ready      = %x\n", !!(s & SD_Ready));
2171                 usb_stor_dbg(us, "IsMMC      = %x\n", !!(s & SD_IsMMC));
2172                 usb_stor_dbg(us, "HiCapacity = %x\n", !!(s & SD_HiCapacity));
2173                 usb_stor_dbg(us, "HiSpeed    = %x\n", !!(s & SD_HiSpeed));
2174                 usb_stor_dbg(us, "WtP        = %x\n", !!(s & SD_WtP));
2175         } else {
2176                 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
2177                 return USB_STOR_TRANSPORT_ERROR;
2178         }
2179         return USB_STOR_TRANSPORT_GOOD;
2180 }
2181
2182
2183 static int ene_init(struct us_data *us)
2184 {
2185         int result;
2186         u8  misc_reg03;
2187         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2188         u8 *bbuf = info->bbuf;
2189
2190         result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
2191         if (result != USB_STOR_XFER_GOOD)
2192                 return USB_STOR_TRANSPORT_ERROR;
2193
2194         misc_reg03 = bbuf[0];
2195         if (misc_reg03 & 0x01) {
2196                 if (!(info->SD_Status & SD_Ready)) {
2197                         result = ene_sd_init(us);
2198                         if (result != USB_STOR_XFER_GOOD)
2199                                 return USB_STOR_TRANSPORT_ERROR;
2200                 }
2201         }
2202         if (misc_reg03 & 0x02) {
2203                 if (!(info->MS_Status & MS_Ready)) {
2204                         result = ene_ms_init(us);
2205                         if (result != USB_STOR_XFER_GOOD)
2206                                 return USB_STOR_TRANSPORT_ERROR;
2207                 }
2208         }
2209         return result;
2210 }
2211
2212 /*----- sd_scsi_irp() ---------*/
2213 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2214 {
2215         int    result;
2216         struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2217
2218         switch (srb->cmnd[0]) {
2219         case TEST_UNIT_READY:
2220                 result = sd_scsi_test_unit_ready(us, srb);
2221                 break; /* 0x00 */
2222         case REQUEST_SENSE:
2223                 result = do_scsi_request_sense(us, srb);
2224                 break; /* 0x03 */
2225         case INQUIRY:
2226                 result = do_scsi_inquiry(us, srb);
2227                 break; /* 0x12 */
2228         case MODE_SENSE:
2229                 result = sd_scsi_mode_sense(us, srb);
2230                 break; /* 0x1A */
2231         /*
2232         case START_STOP:
2233                 result = SD_SCSI_Start_Stop(us, srb);
2234                 break; //0x1B
2235         */
2236         case READ_CAPACITY:
2237                 result = sd_scsi_read_capacity(us, srb);
2238                 break; /* 0x25 */
2239         case READ_10:
2240                 result = sd_scsi_read(us, srb);
2241                 break; /* 0x28 */
2242         case WRITE_10:
2243                 result = sd_scsi_write(us, srb);
2244                 break; /* 0x2A */
2245         default:
2246                 info->SrbStatus = SS_ILLEGAL_REQUEST;
2247                 result = USB_STOR_TRANSPORT_FAILED;
2248                 break;
2249         }
2250         if (result == USB_STOR_TRANSPORT_GOOD)
2251                 info->SrbStatus = SS_SUCCESS;
2252         return result;
2253 }
2254
2255 /*
2256  * ms_scsi_irp()
2257  */
2258 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2259 {
2260         int result;
2261         struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2262
2263         switch (srb->cmnd[0]) {
2264         case TEST_UNIT_READY:
2265                 result = ms_scsi_test_unit_ready(us, srb);
2266                 break; /* 0x00 */
2267         case REQUEST_SENSE:
2268                 result = do_scsi_request_sense(us, srb);
2269                 break; /* 0x03 */
2270         case INQUIRY:
2271                 result = do_scsi_inquiry(us, srb);
2272                 break; /* 0x12 */
2273         case MODE_SENSE:
2274                 result = ms_scsi_mode_sense(us, srb);
2275                 break; /* 0x1A */
2276         case READ_CAPACITY:
2277                 result = ms_scsi_read_capacity(us, srb);
2278                 break; /* 0x25 */
2279         case READ_10:
2280                 result = ms_scsi_read(us, srb);
2281                 break; /* 0x28 */
2282         case WRITE_10:
2283                 result = ms_scsi_write(us, srb);
2284                 break;  /* 0x2A */
2285         default:
2286                 info->SrbStatus = SS_ILLEGAL_REQUEST;
2287                 result = USB_STOR_TRANSPORT_FAILED;
2288                 break;
2289         }
2290         if (result == USB_STOR_TRANSPORT_GOOD)
2291                 info->SrbStatus = SS_SUCCESS;
2292         return result;
2293 }
2294
2295 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2296 {
2297         int result = USB_STOR_XFER_GOOD;
2298         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2299
2300         /*US_DEBUG(usb_stor_show_command(us, srb)); */
2301         scsi_set_resid(srb, 0);
2302         if (unlikely(!(info->SD_Status & SD_Ready) || (info->MS_Status & MS_Ready)))
2303                 result = ene_init(us);
2304         if (result == USB_STOR_XFER_GOOD) {
2305                 result = USB_STOR_TRANSPORT_ERROR;
2306                 if (info->SD_Status & SD_Ready)
2307                         result = sd_scsi_irp(us, srb);
2308
2309                 if (info->MS_Status & MS_Ready)
2310                         result = ms_scsi_irp(us, srb);
2311         }
2312         return result;
2313 }
2314
2315 static struct scsi_host_template ene_ub6250_host_template;
2316
2317 static int ene_ub6250_probe(struct usb_interface *intf,
2318                          const struct usb_device_id *id)
2319 {
2320         int result;
2321         u8  misc_reg03;
2322         struct us_data *us;
2323         struct ene_ub6250_info *info;
2324
2325         result = usb_stor_probe1(&us, intf, id,
2326                    (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2327                    &ene_ub6250_host_template);
2328         if (result)
2329                 return result;
2330
2331         /* FIXME: where should the code alloc extra buf ? */
2332         us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2333         if (!us->extra)
2334                 return -ENOMEM;
2335         us->extra_destructor = ene_ub6250_info_destructor;
2336
2337         info = (struct ene_ub6250_info *)(us->extra);
2338         info->bbuf = kmalloc(512, GFP_KERNEL);
2339         if (!info->bbuf) {
2340                 kfree(us->extra);
2341                 return -ENOMEM;
2342         }
2343
2344         us->transport_name = "ene_ub6250";
2345         us->transport = ene_transport;
2346         us->max_lun = 0;
2347
2348         result = usb_stor_probe2(us);
2349         if (result)
2350                 return result;
2351
2352         /* probe card type */
2353         result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2354         if (result != USB_STOR_XFER_GOOD) {
2355                 usb_stor_disconnect(intf);
2356                 return USB_STOR_TRANSPORT_ERROR;
2357         }
2358
2359         misc_reg03 = info->bbuf[0];
2360         if (!(misc_reg03 & 0x01)) {
2361                 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2362                         "It does not support SM cards.\n");
2363         }
2364
2365         return result;
2366 }
2367
2368
2369 #ifdef CONFIG_PM
2370
2371 static int ene_ub6250_resume(struct usb_interface *iface)
2372 {
2373         struct us_data *us = usb_get_intfdata(iface);
2374         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2375
2376         mutex_lock(&us->dev_mutex);
2377
2378         if (us->suspend_resume_hook)
2379                 (us->suspend_resume_hook)(us, US_RESUME);
2380
2381         mutex_unlock(&us->dev_mutex);
2382
2383         info->Power_IsResum = true;
2384         /* info->SD_Status &= ~SD_Ready; */
2385         info->SD_Status = 0;
2386         info->MS_Status = 0;
2387         info->SM_Status = 0;
2388
2389         return 0;
2390 }
2391
2392 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2393 {
2394         struct us_data *us = usb_get_intfdata(iface);
2395         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2396
2397         /* Report the reset to the SCSI core */
2398         usb_stor_reset_resume(iface);
2399
2400         /*
2401          * FIXME: Notify the subdrivers that they need to reinitialize
2402          * the device
2403          */
2404         info->Power_IsResum = true;
2405         /* info->SD_Status &= ~SD_Ready; */
2406         info->SD_Status = 0;
2407         info->MS_Status = 0;
2408         info->SM_Status = 0;
2409
2410         return 0;
2411 }
2412
2413 #else
2414
2415 #define ene_ub6250_resume               NULL
2416 #define ene_ub6250_reset_resume         NULL
2417
2418 #endif
2419
2420 static struct usb_driver ene_ub6250_driver = {
2421         .name =         DRV_NAME,
2422         .probe =        ene_ub6250_probe,
2423         .disconnect =   usb_stor_disconnect,
2424         .suspend =      usb_stor_suspend,
2425         .resume =       ene_ub6250_resume,
2426         .reset_resume = ene_ub6250_reset_resume,
2427         .pre_reset =    usb_stor_pre_reset,
2428         .post_reset =   usb_stor_post_reset,
2429         .id_table =     ene_ub6250_usb_ids,
2430         .soft_unbind =  1,
2431         .no_dynamic_id = 1,
2432 };
2433
2434 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);