kernel/drivers/usb/storage/ene_ub6250.c

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