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         /*
 564          * try to compute the actual residue, based on how much data
 565          * was really transferred and what the device tells us
 566          */
 567         if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
 568                 residue = min(residue, transfer_length);
 569                 if (us->srb != NULL)
 570                         scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
 571                                                                 (int)residue));
 572         }
 573
 574         if (bcs->Status != US_BULK_STAT_OK)
 575                 return USB_STOR_TRANSPORT_ERROR;
 576
 577         return USB_STOR_TRANSPORT_GOOD;
 578 }
 579
 580 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
 581 {
 582         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 583
 584         if (info->SD_Status.Insert && info->SD_Status.Ready)
 585                 return USB_STOR_TRANSPORT_GOOD;
 586         else {
 587                 ene_sd_init(us);
 588                 return USB_STOR_TRANSPORT_GOOD;
 589         }
 590
 591         return USB_STOR_TRANSPORT_GOOD;
 592 }
 593
 594 static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
 595 {
 596         unsigned char data_ptr[36] = {
 597                 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
 598                 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
 599                 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
 600                 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
 601
 602         usb_stor_set_xfer_buf(data_ptr, 36, srb);
 603         return USB_STOR_TRANSPORT_GOOD;
 604 }
 605
 606 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
 607 {
 608         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 609         unsigned char mediaNoWP[12] = {
 610                 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
 611                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
 612         unsigned char mediaWP[12]   = {
 613                 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
 614                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
 615
 616         if (info->SD_Status.WtP)
 617                 usb_stor_set_xfer_buf(mediaWP, 12, srb);
 618         else
 619                 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
 620
 621
 622         return USB_STOR_TRANSPORT_GOOD;
 623 }
 624
 625 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
 626 {
 627         u32     bl_num;
 628         u32     bl_len;
 629         unsigned int offset = 0;
 630         unsigned char    buf[8];
 631         struct scatterlist *sg = NULL;
 632         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 633
 634         usb_stor_dbg(us, "sd_scsi_read_capacity\n");
 635         if (info->SD_Status.HiCapacity) {
 636                 bl_len = 0x200;
 637                 if (info->SD_Status.IsMMC)
 638                         bl_num = info->HC_C_SIZE-1;
 639                 else
 640                         bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
 641         } else {
 642                 bl_len = 1 << (info->SD_READ_BL_LEN);
 643                 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
 644                                 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
 645         }
 646         info->bl_num = bl_num;
 647         usb_stor_dbg(us, "bl_len = %x\n", bl_len);
 648         usb_stor_dbg(us, "bl_num = %x\n", bl_num);
 649
 650         /*srb->request_bufflen = 8; */
 651         buf[0] = (bl_num >> 24) & 0xff;
 652         buf[1] = (bl_num >> 16) & 0xff;
 653         buf[2] = (bl_num >> 8) & 0xff;
 654         buf[3] = (bl_num >> 0) & 0xff;
 655         buf[4] = (bl_len >> 24) & 0xff;
 656         buf[5] = (bl_len >> 16) & 0xff;
 657         buf[6] = (bl_len >> 8) & 0xff;
 658         buf[7] = (bl_len >> 0) & 0xff;
 659
 660         usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
 661
 662         return USB_STOR_TRANSPORT_GOOD;
 663 }
 664
 665 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
 666 {
 667         int result;
 668         unsigned char *cdb = srb->cmnd;
 669         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 670         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 671
 672         u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
 673                  ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
 674         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
 675         u32 bnByte = bn * 0x200;
 676         u32 blenByte = blen * 0x200;
 677
 678         if (bn > info->bl_num)
 679                 return USB_STOR_TRANSPORT_ERROR;
 680
 681         result = ene_load_bincode(us, SD_RW_PATTERN);
 682         if (result != USB_STOR_XFER_GOOD) {
 683                 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
 684                 return USB_STOR_TRANSPORT_ERROR;
 685         }
 686
 687         if (info->SD_Status.HiCapacity)
 688                 bnByte = bn;
 689
 690         /* set up the command wrapper */
 691         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 692         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 693         bcb->DataTransferLength = blenByte;
 694         bcb->Flags  = US_BULK_FLAG_IN;
 695         bcb->CDB[0] = 0xF1;
 696         bcb->CDB[5] = (unsigned char)(bnByte);
 697         bcb->CDB[4] = (unsigned char)(bnByte>>8);
 698         bcb->CDB[3] = (unsigned char)(bnByte>>16);
 699         bcb->CDB[2] = (unsigned char)(bnByte>>24);
 700
 701         result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
 702         return result;
 703 }
 704
 705 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
 706 {
 707         int result;
 708         unsigned char *cdb = srb->cmnd;
 709         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 710         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 711
 712         u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
 713                  ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
 714         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
 715         u32 bnByte = bn * 0x200;
 716         u32 blenByte = blen * 0x200;
 717
 718         if (bn > info->bl_num)
 719                 return USB_STOR_TRANSPORT_ERROR;
 720
 721         result = ene_load_bincode(us, SD_RW_PATTERN);
 722         if (result != USB_STOR_XFER_GOOD) {
 723                 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
 724                 return USB_STOR_TRANSPORT_ERROR;
 725         }
 726
 727         if (info->SD_Status.HiCapacity)
 728                 bnByte = bn;
 729
 730         /* set up the command wrapper */
 731         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 732         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 733         bcb->DataTransferLength = blenByte;
 734         bcb->Flags  = 0x00;
 735         bcb->CDB[0] = 0xF0;
 736         bcb->CDB[5] = (unsigned char)(bnByte);
 737         bcb->CDB[4] = (unsigned char)(bnByte>>8);
 738         bcb->CDB[3] = (unsigned char)(bnByte>>16);
 739         bcb->CDB[2] = (unsigned char)(bnByte>>24);
 740
 741         result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
 742         return result;
 743 }
 744
 745 /*
 746  * ENE MS Card
 747  */
 748
 749 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
 750 {
 751         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 752
 753         if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
 754                 return (u32)-1;
 755
 756         info->MS_Lib.Phy2LogMap[phyblk] = logblk;
 757         info->MS_Lib.Log2PhyMap[logblk] = phyblk;
 758
 759         return 0;
 760 }
 761
 762 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
 763 {
 764         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 765
 766         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
 767                 return (u32)-1;
 768
 769         info->MS_Lib.Phy2LogMap[phyblk] = mark;
 770
 771         return 0;
 772 }
 773
 774 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
 775 {
 776         return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
 777 }
 778
 779 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
 780 {
 781         return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
 782 }
 783
 784 static int ms_lib_free_logicalmap(struct us_data *us)
 785 {
 786         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 787
 788         kfree(info->MS_Lib.Phy2LogMap);
 789         info->MS_Lib.Phy2LogMap = NULL;
 790
 791         kfree(info->MS_Lib.Log2PhyMap);
 792         info->MS_Lib.Log2PhyMap = NULL;
 793
 794         return 0;
 795 }
 796
 797 static int ms_lib_alloc_logicalmap(struct us_data *us)
 798 {
 799         u32  i;
 800         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 801
 802         info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL);
 803         info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL);
 804
 805         if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
 806                 ms_lib_free_logicalmap(us);
 807                 return (u32)-1;
 808         }
 809
 810         for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
 811                 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
 812
 813         for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
 814                 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
 815
 816         return 0;
 817 }
 818
 819 static void ms_lib_clear_writebuf(struct us_data *us)
 820 {
 821         int i;
 822         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 823
 824         info->MS_Lib.wrtblk = (u16)-1;
 825         ms_lib_clear_pagemap(info);
 826
 827         if (info->MS_Lib.blkpag)
 828                 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
 829
 830         if (info->MS_Lib.blkext) {
 831                 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
 832                         info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
 833                         info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
 834                         info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
 835                         info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
 836                 }
 837         }
 838 }
 839
 840 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
 841 {
 842         u32 Ende, Count;
 843         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 844
 845         Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 846         for (Count = 0; PhyBlock < Ende; PhyBlock++) {
 847                 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
 848                 case MS_LB_NOT_USED:
 849                 case MS_LB_NOT_USED_ERASED:
 850                         Count++;
 851                 default:
 852                         break;
 853                 }
 854         }
 855
 856         return Count;
 857 }
 858
 859 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
 860                 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
 861 {
 862         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
 863         int result;
 864         u8 ExtBuf[4];
 865         u32 bn = PhyBlockAddr * 0x20 + PageNum;
 866
 867         result = ene_load_bincode(us, MS_RW_PATTERN);
 868         if (result != USB_STOR_XFER_GOOD)
 869                 return USB_STOR_TRANSPORT_ERROR;
 870
 871         /* Read Page Data */
 872         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 873         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 874         bcb->DataTransferLength = 0x200;
 875         bcb->Flags      = US_BULK_FLAG_IN;
 876         bcb->CDB[0]     = 0xF1;
 877
 878         bcb->CDB[1]     = 0x02; /* in init.c ENE_MSInit() is 0x01 */
 879
 880         bcb->CDB[5]     = (unsigned char)(bn);
 881         bcb->CDB[4]     = (unsigned char)(bn>>8);
 882         bcb->CDB[3]     = (unsigned char)(bn>>16);
 883         bcb->CDB[2]     = (unsigned char)(bn>>24);
 884
 885         result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
 886         if (result != USB_STOR_XFER_GOOD)
 887                 return USB_STOR_TRANSPORT_ERROR;
 888
 889
 890         /* Read Extra Data */
 891         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
 892         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
 893         bcb->DataTransferLength = 0x4;
 894         bcb->Flags      = US_BULK_FLAG_IN;
 895         bcb->CDB[0]     = 0xF1;
 896         bcb->CDB[1]     = 0x03;
 897
 898         bcb->CDB[5]     = (unsigned char)(PageNum);
 899         bcb->CDB[4]     = (unsigned char)(PhyBlockAddr);
 900         bcb->CDB[3]     = (unsigned char)(PhyBlockAddr>>8);
 901         bcb->CDB[2]     = (unsigned char)(PhyBlockAddr>>16);
 902         bcb->CDB[6]     = 0x01;
 903
 904         result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
 905         if (result != USB_STOR_XFER_GOOD)
 906                 return USB_STOR_TRANSPORT_ERROR;
 907
 908         ExtraDat->reserved = 0;
 909         ExtraDat->intr     = 0x80;  /* Not yet,fireware support */
 910         ExtraDat->status0  = 0x10;  /* Not yet,fireware support */
 911
 912         ExtraDat->status1  = 0x00;  /* Not yet,fireware support */
 913         ExtraDat->ovrflg   = ExtBuf[0];
 914         ExtraDat->mngflg   = ExtBuf[1];
 915         ExtraDat->logadr   = memstick_logaddr(ExtBuf[2], ExtBuf[3]);
 916
 917         return USB_STOR_TRANSPORT_GOOD;
 918 }
 919
 920 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
 921 {
 922         struct ms_bootblock_sysent *SysEntry;
 923         struct ms_bootblock_sysinf *SysInfo;
 924         u32 i, result;
 925         u8 PageNumber;
 926         u8 *PageBuffer;
 927         struct ms_lib_type_extdat ExtraData;
 928         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 929
 930         PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
 931         if (PageBuffer == NULL)
 932                 return (u32)-1;
 933
 934         result = (u32)-1;
 935
 936         SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
 937
 938         if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
 939                 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
 940                 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
 941                 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
 942                 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
 943                 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
 944                 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
 945                 goto exit;
 946                 /* */
 947         switch (info->MS_Lib.cardType = SysInfo->bCardType) {
 948         case MS_SYSINF_CARDTYPE_RDONLY:
 949                 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
 950                 break;
 951         case MS_SYSINF_CARDTYPE_RDWR:
 952                 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
 953                 break;
 954         case MS_SYSINF_CARDTYPE_HYBRID:
 955         default:
 956                 goto exit;
 957         }
 958
 959         info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
 960         info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
 961         info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
 962         info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
 963         info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
 964         info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
 965
 966         /*Allocate to all number of logicalblock and physicalblock */
 967         if (ms_lib_alloc_logicalmap(us))
 968                 goto exit;
 969
 970         /* Mark the book block */
 971         ms_lib_set_bootblockmark(us, PhyBlock);
 972
 973         SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
 974
 975         for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
 976                 u32  EntryOffset, EntrySize;
 977
 978                 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
 979
 980                 if (EntryOffset == 0xffffff)
 981                         continue;
 982                 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
 983
 984                 if (EntrySize == 0)
 985                         continue;
 986
 987                 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
 988                         continue;
 989
 990                 if (i == 0) {
 991                         u8 PrevPageNumber = 0;
 992                         u16 phyblk;
 993
 994                         if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
 995                                 goto exit;
 996
 997                         while (EntrySize > 0) {
 998
 999                                 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1000                                 if (PageNumber != PrevPageNumber) {
1001                                         switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1002                                         case MS_STATUS_SUCCESS:
1003                                                 break;
1004                                         case MS_STATUS_WRITE_PROTECT:
1005                                         case MS_ERROR_FLASH_READ:
1006                                         case MS_STATUS_ERROR:
1007                                         default:
1008                                                 goto exit;
1009                                         }
1010
1011                                         PrevPageNumber = PageNumber;
1012                                 }
1013
1014                                 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1015                                 if (phyblk < 0x0fff)
1016                                         ms_lib_set_initialerrorblock(us, phyblk);
1017
1018                                 EntryOffset += 2;
1019                                 EntrySize -= 2;
1020                         }
1021                 } else if (i == 1) {  /* CIS/IDI */
1022                         struct ms_bootblock_idi *idi;
1023
1024                         if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1025                                 goto exit;
1026
1027                         switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1028                         case MS_STATUS_SUCCESS:
1029                                 break;
1030                         case MS_STATUS_WRITE_PROTECT:
1031                         case MS_ERROR_FLASH_READ:
1032                         case MS_STATUS_ERROR:
1033                         default:
1034                                 goto exit;
1035                         }
1036
1037                         idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1038                         if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1039                                 goto exit;
1040
1041                         info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1042                         if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1043                                 goto exit;
1044                 }
1045         } /* End for .. */
1046
1047         result = 0;
1048
1049 exit:
1050         if (result)
1051                 ms_lib_free_logicalmap(us);
1052
1053         kfree(PageBuffer);
1054
1055         result = 0;
1056         return result;
1057 }
1058
1059 static void ms_lib_free_writebuf(struct us_data *us)
1060 {
1061         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1062         info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1063
1064         /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1065
1066         ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1067
1068         if (info->MS_Lib.blkpag) {
1069                 kfree(info->MS_Lib.blkpag);  /* Arnold test ... */
1070                 info->MS_Lib.blkpag = NULL;
1071         }
1072
1073         if (info->MS_Lib.blkext) {
1074                 kfree(info->MS_Lib.blkext);  /* Arnold test ... */
1075                 info->MS_Lib.blkext = NULL;
1076         }
1077 }
1078
1079
1080 static void ms_lib_free_allocatedarea(struct us_data *us)
1081 {
1082         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1083
1084         ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1085         ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1086
1087         /* set struct us point flag to 0 */
1088         info->MS_Lib.flags = 0;
1089         info->MS_Lib.BytesPerSector = 0;
1090         info->MS_Lib.SectorsPerCylinder = 0;
1091
1092         info->MS_Lib.cardType = 0;
1093         info->MS_Lib.blockSize = 0;
1094         info->MS_Lib.PagesPerBlock = 0;
1095
1096         info->MS_Lib.NumberOfPhyBlock = 0;
1097         info->MS_Lib.NumberOfLogBlock = 0;
1098 }
1099
1100
1101 static int ms_lib_alloc_writebuf(struct us_data *us)
1102 {
1103         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1104
1105         info->MS_Lib.wrtblk = (u16)-1;
1106
1107         info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL);
1108         info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL);
1109
1110         if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1111                 ms_lib_free_writebuf(us);
1112                 return (u32)-1;
1113         }
1114
1115         ms_lib_clear_writebuf(us);
1116
1117 return 0;
1118 }
1119
1120 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1121 {
1122         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1123
1124         if (logblk == MS_LB_NOT_USED)
1125                 return 0;
1126
1127         if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1128                 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1129                 return (u32)-1;
1130
1131         info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1132         info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1133
1134         return 0;
1135 }
1136
1137 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1138                         u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1139 {
1140         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1141         int result;
1142
1143         result = ene_load_bincode(us, MS_RW_PATTERN);
1144         if (result != USB_STOR_XFER_GOOD)
1145                 return USB_STOR_TRANSPORT_ERROR;
1146
1147         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1148         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1149         bcb->DataTransferLength = 0x200*len;
1150         bcb->Flags = 0x00;
1151         bcb->CDB[0] = 0xF0;
1152         bcb->CDB[1] = 0x08;
1153         bcb->CDB[4] = (unsigned char)(oldphy);
1154         bcb->CDB[3] = (unsigned char)(oldphy>>8);
1155         bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1156         bcb->CDB[7] = (unsigned char)(newphy);
1157         bcb->CDB[6] = (unsigned char)(newphy>>8);
1158         bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1159         bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1160         bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1161         bcb->CDB[10] = PageNum;
1162
1163         result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1164         if (result != USB_STOR_XFER_GOOD)
1165                 return USB_STOR_TRANSPORT_ERROR;
1166
1167         return USB_STOR_TRANSPORT_GOOD;
1168 }
1169
1170 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1171 {
1172         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1173         int result;
1174         u32 bn = PhyBlockAddr;
1175
1176         result = ene_load_bincode(us, MS_RW_PATTERN);
1177         if (result != USB_STOR_XFER_GOOD)
1178                 return USB_STOR_TRANSPORT_ERROR;
1179
1180         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1181         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1182         bcb->DataTransferLength = 0x200;
1183         bcb->Flags = US_BULK_FLAG_IN;
1184         bcb->CDB[0] = 0xF2;
1185         bcb->CDB[1] = 0x06;
1186         bcb->CDB[4] = (unsigned char)(bn);
1187         bcb->CDB[3] = (unsigned char)(bn>>8);
1188         bcb->CDB[2] = (unsigned char)(bn>>16);
1189
1190         result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1191         if (result != USB_STOR_XFER_GOOD)
1192                 return USB_STOR_TRANSPORT_ERROR;
1193
1194         return USB_STOR_TRANSPORT_GOOD;
1195 }
1196
1197 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1198 {
1199         unsigned char *PageBuf = NULL;
1200         u16 result = MS_STATUS_SUCCESS;
1201         u16 blk, index = 0;
1202         struct ms_lib_type_extdat extdat;
1203         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1204
1205         PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1206         if (PageBuf == NULL) {
1207                 result = MS_NO_MEMORY_ERROR;
1208                 goto exit;
1209         }
1210
1211         ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1212         do {
1213                 blk = be16_to_cpu(PageBuf[index]);
1214                 if (blk == MS_LB_NOT_USED)
1215                         break;
1216                 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1217                         result = MS_ERROR_FLASH_READ;
1218                         break;
1219                 }
1220                 index++;
1221         } while (1);
1222
1223 exit:
1224         kfree(PageBuf);
1225         return result;
1226 }
1227
1228 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1229 {
1230         u16 log;
1231         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1232
1233         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1234                 return (u32)-1;
1235
1236         log = info->MS_Lib.Phy2LogMap[phyblk];
1237
1238         if (log < info->MS_Lib.NumberOfLogBlock)
1239                 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1240
1241         if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1242                 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1243
1244         return 0;
1245 }
1246
1247 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1248                                 u8 PageNum, u8 OverwriteFlag)
1249 {
1250         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1251         int result;
1252
1253         result = ene_load_bincode(us, MS_RW_PATTERN);
1254         if (result != USB_STOR_XFER_GOOD)
1255                 return USB_STOR_TRANSPORT_ERROR;
1256
1257         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1258         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1259         bcb->DataTransferLength = 0x4;
1260         bcb->Flags = US_BULK_FLAG_IN;
1261         bcb->CDB[0] = 0xF2;
1262         bcb->CDB[1] = 0x05;
1263         bcb->CDB[5] = (unsigned char)(PageNum);
1264         bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1265         bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1266         bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1267         bcb->CDB[6] = OverwriteFlag;
1268         bcb->CDB[7] = 0xFF;
1269         bcb->CDB[8] = 0xFF;
1270         bcb->CDB[9] = 0xFF;
1271
1272         result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1273         if (result != USB_STOR_XFER_GOOD)
1274                 return USB_STOR_TRANSPORT_ERROR;
1275
1276         return USB_STOR_TRANSPORT_GOOD;
1277 }
1278
1279 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1280 {
1281         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1282
1283         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1284                 return MS_STATUS_ERROR;
1285
1286         ms_lib_setacquired_errorblock(us, phyblk);
1287
1288         if (ms_lib_iswritable(info))
1289                 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1290
1291         return MS_STATUS_SUCCESS;
1292 }
1293
1294 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1295 {
1296         u16 log;
1297         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1298
1299         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1300                 return MS_STATUS_ERROR;
1301
1302         log = info->MS_Lib.Phy2LogMap[phyblk];
1303
1304         if (log < info->MS_Lib.NumberOfLogBlock)
1305                 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1306
1307         info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1308
1309         if (ms_lib_iswritable(info)) {
1310                 switch (ms_read_eraseblock(us, phyblk)) {
1311                 case MS_STATUS_SUCCESS:
1312                         info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1313                         return MS_STATUS_SUCCESS;
1314                 case MS_ERROR_FLASH_ERASE:
1315                 case MS_STATUS_INT_ERROR:
1316                         ms_lib_error_phyblock(us, phyblk);
1317                         return MS_ERROR_FLASH_ERASE;
1318                 case MS_STATUS_ERROR:
1319                 default:
1320                         ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1321                         ms_lib_setacquired_errorblock(us, phyblk);
1322                         return MS_STATUS_ERROR;
1323                 }
1324         }
1325
1326         ms_lib_setacquired_errorblock(us, phyblk);
1327
1328         return MS_STATUS_SUCCESS;
1329 }
1330
1331 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1332                                 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1333 {
1334         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1335         int result;
1336         u8 ExtBuf[4];
1337
1338         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1339         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1340         bcb->DataTransferLength = 0x4;
1341         bcb->Flags      = US_BULK_FLAG_IN;
1342         bcb->CDB[0]     = 0xF1;
1343         bcb->CDB[1]     = 0x03;
1344         bcb->CDB[5]     = (unsigned char)(PageNum);
1345         bcb->CDB[4]     = (unsigned char)(PhyBlock);
1346         bcb->CDB[3]     = (unsigned char)(PhyBlock>>8);
1347         bcb->CDB[2]     = (unsigned char)(PhyBlock>>16);
1348         bcb->CDB[6]     = 0x01;
1349
1350         result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
1351         if (result != USB_STOR_XFER_GOOD)
1352                 return USB_STOR_TRANSPORT_ERROR;
1353
1354         ExtraDat->reserved = 0;
1355         ExtraDat->intr     = 0x80;  /* Not yet, waiting for fireware support */
1356         ExtraDat->status0  = 0x10;  /* Not yet, waiting for fireware support */
1357         ExtraDat->status1  = 0x00;  /* Not yet, waiting for fireware support */
1358         ExtraDat->ovrflg   = ExtBuf[0];
1359         ExtraDat->mngflg   = ExtBuf[1];
1360         ExtraDat->logadr   = memstick_logaddr(ExtBuf[2], ExtBuf[3]);
1361
1362         return USB_STOR_TRANSPORT_GOOD;
1363 }
1364
1365 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1366 {
1367         u16 Newblk;
1368         u16 blk;
1369         struct ms_lib_type_extdat extdat; /* need check */
1370         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1371
1372
1373         if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1374                 return MS_LB_ERROR;
1375
1376         for (blk = phyblk + 1; blk != phyblk; blk++) {
1377                 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1378                         blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1379
1380                 Newblk = info->MS_Lib.Phy2LogMap[blk];
1381                 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1382                         return blk;
1383                 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1384                         switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1385                         case MS_STATUS_SUCCESS:
1386                         case MS_STATUS_SUCCESS_WITH_ECC:
1387                                 break;
1388                         case MS_NOCARD_ERROR:
1389                                 return MS_NOCARD_ERROR;
1390                         case MS_STATUS_INT_ERROR:
1391                                 return MS_LB_ERROR;
1392                         case MS_ERROR_FLASH_READ:
1393                         default:
1394                                 ms_lib_setacquired_errorblock(us, blk);
1395                                 continue;
1396                         } /* End switch */
1397
1398                         if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1399                                 ms_lib_setacquired_errorblock(us, blk);
1400                                 continue;
1401                         }
1402
1403                         switch (ms_lib_erase_phyblock(us, blk)) {
1404                         case MS_STATUS_SUCCESS:
1405                                 return blk;
1406                         case MS_STATUS_ERROR:
1407                                 return MS_LB_ERROR;
1408                         case MS_ERROR_FLASH_ERASE:
1409                         default:
1410                                 ms_lib_error_phyblock(us, blk);
1411                                 break;
1412                         }
1413                 }
1414         } /* End for */
1415
1416         return MS_LB_ERROR;
1417 }
1418 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1419 {
1420         u16 phyblk;
1421         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1422
1423         phyblk = ms_libconv_to_physical(info, logblk);
1424         if (phyblk >= MS_LB_ERROR) {
1425                 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1426                         return MS_LB_ERROR;
1427
1428                 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1429                 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1430                 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1431         }
1432
1433         return ms_libsearch_block_from_physical(us, phyblk);
1434 }
1435
1436 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1437 {
1438         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1439
1440         /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1441         if (info->MS_Status.Insert && info->MS_Status.Ready) {
1442                 return USB_STOR_TRANSPORT_GOOD;
1443         } else {
1444                 ene_ms_init(us);
1445                 return USB_STOR_TRANSPORT_GOOD;
1446         }
1447
1448         return USB_STOR_TRANSPORT_GOOD;
1449 }
1450
1451 static int ms_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
1452 {
1453         /* pr_info("MS_SCSI_Inquiry\n"); */
1454         unsigned char data_ptr[36] = {
1455                 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
1456                 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
1457                 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
1458                 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
1459
1460         usb_stor_set_xfer_buf(data_ptr, 36, srb);
1461         return USB_STOR_TRANSPORT_GOOD;
1462 }
1463
1464 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1465 {
1466         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1467         unsigned char mediaNoWP[12] = {
1468                 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1469                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1470         unsigned char mediaWP[12]   = {
1471                 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1472                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1473
1474         if (info->MS_Status.WtP)
1475                 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1476         else
1477                 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1478
1479         return USB_STOR_TRANSPORT_GOOD;
1480 }
1481
1482 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1483 {
1484         u32   bl_num;
1485         u16    bl_len;
1486         unsigned int offset = 0;
1487         unsigned char    buf[8];
1488         struct scatterlist *sg = NULL;
1489         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1490
1491         usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1492         bl_len = 0x200;
1493         if (info->MS_Status.IsMSPro)
1494                 bl_num = info->MSP_TotalBlock - 1;
1495         else
1496                 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1497
1498         info->bl_num = bl_num;
1499         usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1500         usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1501
1502         /*srb->request_bufflen = 8; */
1503         buf[0] = (bl_num >> 24) & 0xff;
1504         buf[1] = (bl_num >> 16) & 0xff;
1505         buf[2] = (bl_num >> 8) & 0xff;
1506         buf[3] = (bl_num >> 0) & 0xff;
1507         buf[4] = (bl_len >> 24) & 0xff;
1508         buf[5] = (bl_len >> 16) & 0xff;
1509         buf[6] = (bl_len >> 8) & 0xff;
1510         buf[7] = (bl_len >> 0) & 0xff;
1511
1512         usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1513
1514         return USB_STOR_TRANSPORT_GOOD;
1515 }
1516
1517 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1518 {
1519         PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1520
1521         if (PhyBlock) {
1522                 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1523                 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1524         } else {
1525                 *LogStart = 0;
1526                 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1527         }
1528 }
1529
1530 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1531         u8 PageNum, u8 blen, void *buf)
1532 {
1533         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1534         int     result;
1535
1536         /* Read Extra Data */
1537         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1538         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1539         bcb->DataTransferLength = 0x4 * blen;
1540         bcb->Flags      = US_BULK_FLAG_IN;
1541         bcb->CDB[0]     = 0xF1;
1542         bcb->CDB[1]     = 0x03;
1543         bcb->CDB[5]     = (unsigned char)(PageNum);
1544         bcb->CDB[4]     = (unsigned char)(PhyBlock);
1545         bcb->CDB[3]     = (unsigned char)(PhyBlock>>8);
1546         bcb->CDB[2]     = (unsigned char)(PhyBlock>>16);
1547         bcb->CDB[6]     = blen;
1548
1549         result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1550         if (result != USB_STOR_XFER_GOOD)
1551                 return USB_STOR_TRANSPORT_ERROR;
1552
1553         return USB_STOR_TRANSPORT_GOOD;
1554 }
1555
1556 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1557 {
1558         u16 PhyBlock, newblk, i;
1559         u16 LogStart, LogEnde;
1560         struct ms_lib_type_extdat extdat;
1561         u8 buf[0x200];
1562         u32 count = 0, index = 0;
1563         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1564
1565         for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1566                 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1567
1568                 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1569                         switch (ms_libconv_to_logical(info, PhyBlock)) {
1570                         case MS_STATUS_ERROR:
1571                                 continue;
1572                         default:
1573                                 break;
1574                         }
1575
1576                         if (count == PhyBlock) {
1577                                 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, &buf);
1578                                 count += 0x80;
1579                         }
1580                         index = (PhyBlock % 0x80) * 4;
1581
1582                         extdat.ovrflg = buf[index];
1583                         extdat.mngflg = buf[index+1];
1584                         extdat.logadr = memstick_logaddr(buf[index+2], buf[index+3]);
1585
1586                         if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1587                                 ms_lib_setacquired_errorblock(us, PhyBlock);
1588                                 continue;
1589                         }
1590
1591                         if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1592                                 ms_lib_erase_phyblock(us, PhyBlock);
1593                                 continue;
1594                         }
1595
1596                         if (extdat.logadr != MS_LB_NOT_USED) {
1597                                 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1598                                         ms_lib_erase_phyblock(us, PhyBlock);
1599                                         continue;
1600                                 }
1601
1602                                 newblk = ms_libconv_to_physical(info, extdat.logadr);
1603
1604                                 if (newblk != MS_LB_NOT_USED) {
1605                                         if (extdat.logadr == 0) {
1606                                                 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1607                                                 if (ms_lib_check_disableblock(us, btBlk1st)) {
1608                                                         ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1609                                                         continue;
1610                                                 }
1611                                         }
1612
1613                                         ms_lib_read_extra(us, newblk, 0, &extdat);
1614                                         if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1615                                                 ms_lib_erase_phyblock(us, PhyBlock);
1616                                                 continue;
1617                                         } else {
1618                                                 ms_lib_erase_phyblock(us, newblk);
1619                                         }
1620                                 }
1621
1622                                 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1623                         }
1624                 }
1625         } /* End for ... */
1626
1627         return MS_STATUS_SUCCESS;
1628 }
1629
1630
1631 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1632 {
1633         int result;
1634         unsigned char *cdb = srb->cmnd;
1635         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1636         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1637
1638         u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1639                 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1640         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1641         u32 blenByte = blen * 0x200;
1642
1643         if (bn > info->bl_num)
1644                 return USB_STOR_TRANSPORT_ERROR;
1645
1646         if (info->MS_Status.IsMSPro) {
1647                 result = ene_load_bincode(us, MSP_RW_PATTERN);
1648                 if (result != USB_STOR_XFER_GOOD) {
1649                         usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1650                         return USB_STOR_TRANSPORT_ERROR;
1651                 }
1652
1653                 /* set up the command wrapper */
1654                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1655                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1656                 bcb->DataTransferLength = blenByte;
1657                 bcb->Flags  = US_BULK_FLAG_IN;
1658                 bcb->CDB[0] = 0xF1;
1659                 bcb->CDB[1] = 0x02;
1660                 bcb->CDB[5] = (unsigned char)(bn);
1661                 bcb->CDB[4] = (unsigned char)(bn>>8);
1662                 bcb->CDB[3] = (unsigned char)(bn>>16);
1663                 bcb->CDB[2] = (unsigned char)(bn>>24);
1664
1665                 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1666         } else {
1667                 void *buf;
1668                 int offset = 0;
1669                 u16 phyblk, logblk;
1670                 u8 PageNum;
1671                 u16 len;
1672                 u32 blkno;
1673
1674                 buf = kmalloc(blenByte, GFP_KERNEL);
1675                 if (buf == NULL)
1676                         return USB_STOR_TRANSPORT_ERROR;
1677
1678                 result = ene_load_bincode(us, MS_RW_PATTERN);
1679                 if (result != USB_STOR_XFER_GOOD) {
1680                         pr_info("Load MS RW pattern Fail !!\n");
1681                         result = USB_STOR_TRANSPORT_ERROR;
1682                         goto exit;
1683                 }
1684
1685                 logblk  = (u16)(bn / info->MS_Lib.PagesPerBlock);
1686                 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1687
1688                 while (1) {
1689                         if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1690                                 len = info->MS_Lib.PagesPerBlock-PageNum;
1691                         else
1692                                 len = blen;
1693
1694                         phyblk = ms_libconv_to_physical(info, logblk);
1695                         blkno  = phyblk * 0x20 + PageNum;
1696
1697                         /* set up the command wrapper */
1698                         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1699                         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1700                         bcb->DataTransferLength = 0x200 * len;
1701                         bcb->Flags  = US_BULK_FLAG_IN;
1702                         bcb->CDB[0] = 0xF1;
1703                         bcb->CDB[1] = 0x02;
1704                         bcb->CDB[5] = (unsigned char)(blkno);
1705                         bcb->CDB[4] = (unsigned char)(blkno>>8);
1706                         bcb->CDB[3] = (unsigned char)(blkno>>16);
1707                         bcb->CDB[2] = (unsigned char)(blkno>>24);
1708
1709                         result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1710                         if (result != USB_STOR_XFER_GOOD) {
1711                                 pr_info("MS_SCSI_Read --- result = %x\n", result);
1712                                 result = USB_STOR_TRANSPORT_ERROR;
1713                                 goto exit;
1714                         }
1715
1716                         blen -= len;
1717                         if (blen <= 0)
1718                                 break;
1719                         logblk++;
1720                         PageNum = 0;
1721                         offset += MS_BYTES_PER_PAGE*len;
1722                 }
1723                 usb_stor_set_xfer_buf(buf, blenByte, srb);
1724 exit:
1725                 kfree(buf);
1726         }
1727         return result;
1728 }
1729
1730 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1731 {
1732         int result;
1733         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1734         unsigned char *cdb = srb->cmnd;
1735         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1736
1737         u32 bn = ((cdb[2] << 24) & 0xff000000) |
1738                         ((cdb[3] << 16) & 0x00ff0000) |
1739                         ((cdb[4] << 8) & 0x0000ff00) |
1740                         ((cdb[5] << 0) & 0x000000ff);
1741         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1742         u32 blenByte = blen * 0x200;
1743
1744         if (bn > info->bl_num)
1745                 return USB_STOR_TRANSPORT_ERROR;
1746
1747         if (info->MS_Status.IsMSPro) {
1748                 result = ene_load_bincode(us, MSP_RW_PATTERN);
1749                 if (result != USB_STOR_XFER_GOOD) {
1750                         pr_info("Load MSP RW pattern Fail !!\n");
1751                         return USB_STOR_TRANSPORT_ERROR;
1752                 }
1753
1754                 /* set up the command wrapper */
1755                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1756                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1757                 bcb->DataTransferLength = blenByte;
1758                 bcb->Flags  = 0x00;
1759                 bcb->CDB[0] = 0xF0;
1760                 bcb->CDB[1] = 0x04;
1761                 bcb->CDB[5] = (unsigned char)(bn);
1762                 bcb->CDB[4] = (unsigned char)(bn>>8);
1763                 bcb->CDB[3] = (unsigned char)(bn>>16);
1764                 bcb->CDB[2] = (unsigned char)(bn>>24);
1765
1766                 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1767         } else {
1768                 void *buf;
1769                 int offset = 0;
1770                 u16 PhyBlockAddr;
1771                 u8 PageNum;
1772                 u16 len, oldphy, newphy;
1773
1774                 buf = kmalloc(blenByte, GFP_KERNEL);
1775                 if (buf == NULL)
1776                         return USB_STOR_TRANSPORT_ERROR;
1777                 usb_stor_set_xfer_buf(buf, blenByte, srb);
1778
1779                 result = ene_load_bincode(us, MS_RW_PATTERN);
1780                 if (result != USB_STOR_XFER_GOOD) {
1781                         pr_info("Load MS RW pattern Fail !!\n");
1782                         result = USB_STOR_TRANSPORT_ERROR;
1783                         goto exit;
1784                 }
1785
1786                 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1787                 PageNum      = (u8)(bn % info->MS_Lib.PagesPerBlock);
1788
1789                 while (1) {
1790                         if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1791                                 len = info->MS_Lib.PagesPerBlock-PageNum;
1792                         else
1793                                 len = blen;
1794
1795                         oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1796                         newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1797
1798                         result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1799
1800                         if (result != USB_STOR_XFER_GOOD) {
1801                                 pr_info("MS_SCSI_Write --- result = %x\n", result);
1802                                 result =  USB_STOR_TRANSPORT_ERROR;
1803                                 goto exit;
1804                         }
1805
1806                         info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1807                         ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1808
1809                         blen -= len;
1810                         if (blen <= 0)
1811                                 break;
1812                         PhyBlockAddr++;
1813                         PageNum = 0;
1814                         offset += MS_BYTES_PER_PAGE*len;
1815                 }
1816 exit:
1817                 kfree(buf);
1818         }
1819         return result;
1820 }
1821
1822 /*
1823  * ENE MS Card
1824  */
1825
1826 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1827 {
1828         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1829         int result;
1830
1831         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1832         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1833         bcb->DataTransferLength = 0x01;
1834         bcb->Flags                      = US_BULK_FLAG_IN;
1835         bcb->CDB[0]                     = 0xED;
1836         bcb->CDB[2]                     = (unsigned char)(index>>8);
1837         bcb->CDB[3]                     = (unsigned char)index;
1838
1839         result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1840         return result;
1841 }
1842
1843 static int ene_get_card_status(struct us_data *us, u8 *buf)
1844 {
1845         u16 tmpreg;
1846         u32 reg4b;
1847         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1848
1849         /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1850         reg4b = *(u32 *)&buf[0x18];
1851         info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1852
1853         tmpreg = (u16) reg4b;
1854         reg4b = *(u32 *)(&buf[0x14]);
1855         if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1856                 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1857
1858         info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1859         info->SD_C_SIZE_MULT = (u8)(reg4b >> 7)  & 0x07;
1860         if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1861                 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1862
1863         if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1864                 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1865                 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1866         } else {
1867                 info->SD_Block_Mult = 1;
1868         }
1869
1870         return USB_STOR_TRANSPORT_GOOD;
1871 }
1872
1873 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1874 {
1875         int err;
1876         char *fw_name = NULL;
1877         unsigned char *buf = NULL;
1878         const struct firmware *sd_fw = NULL;
1879         int result = USB_STOR_TRANSPORT_ERROR;
1880         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1881         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1882
1883         if (info->BIN_FLAG == flag)
1884                 return USB_STOR_TRANSPORT_GOOD;
1885
1886         switch (flag) {
1887         /* For SD */
1888         case SD_INIT1_PATTERN:
1889                 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1890                 fw_name = SD_INIT1_FIRMWARE;
1891                 break;
1892         case SD_INIT2_PATTERN:
1893                 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1894                 fw_name = SD_INIT2_FIRMWARE;
1895                 break;
1896         case SD_RW_PATTERN:
1897                 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1898                 fw_name = SD_RW_FIRMWARE;
1899                 break;
1900         /* For MS */
1901         case MS_INIT_PATTERN:
1902                 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1903                 fw_name = MS_INIT_FIRMWARE;
1904                 break;
1905         case MSP_RW_PATTERN:
1906                 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1907                 fw_name = MSP_RW_FIRMWARE;
1908                 break;
1909         case MS_RW_PATTERN:
1910                 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1911                 fw_name = MS_RW_FIRMWARE;
1912                 break;
1913         default:
1914                 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1915                 goto nofw;
1916         }
1917
1918         err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1919         if (err) {
1920                 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1921                 goto nofw;
1922         }
1923         buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1924         if (buf == NULL)
1925                 goto nofw;
1926
1927         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1928         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1929         bcb->DataTransferLength = sd_fw->size;
1930         bcb->Flags = 0x00;
1931         bcb->CDB[0] = 0xEF;
1932
1933         result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1934         info->BIN_FLAG = flag;
1935         kfree(buf);
1936
1937 nofw:
1938         release_firmware(sd_fw);
1939         return result;
1940 }
1941
1942 static int ms_card_init(struct us_data *us)
1943 {
1944         u32 result;
1945         u16 TmpBlock;
1946         unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1947         struct ms_lib_type_extdat extdat;
1948         u16 btBlk1st, btBlk2nd;
1949         u32 btBlk1stErred;
1950         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1951
1952         printk(KERN_INFO "MS_CardInit start\n");
1953
1954         ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1955
1956         /* get two PageBuffer */
1957         PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1958         PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1959         if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1960                 result = MS_NO_MEMORY_ERROR;
1961                 goto exit;
1962         }
1963
1964         btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1965         btBlk1stErred = 0;
1966
1967         for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1968
1969                 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1970                 case MS_STATUS_SUCCESS:
1971                         break;
1972                 case MS_STATUS_INT_ERROR:
1973                         break;
1974                 case MS_STATUS_ERROR:
1975                 default:
1976                         continue;
1977                 }
1978
1979                 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1980                         continue;
1981
1982                 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1983                         (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1984                         (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1985                         (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1986                                 continue;
1987
1988                 if (btBlk1st != MS_LB_NOT_USED) {
1989                         btBlk2nd = TmpBlock;
1990                         break;
1991                 }
1992
1993                 btBlk1st = TmpBlock;
1994                 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
1995                 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
1996                         btBlk1stErred = 1;
1997         }
1998
1999         if (btBlk1st == MS_LB_NOT_USED) {
2000                 result = MS_STATUS_ERROR;
2001                 goto exit;
2002         }
2003
2004         /* write protect */
2005         if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2006                 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2007
2008         result = MS_STATUS_ERROR;
2009         /* 1st Boot Block */
2010         if (btBlk1stErred == 0)
2011                 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2012                 /* 1st */
2013         /* 2nd Boot Block */
2014         if (result && (btBlk2nd != MS_LB_NOT_USED))
2015                 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2016
2017         if (result) {
2018                 result = MS_STATUS_ERROR;
2019                 goto exit;
2020         }
2021
2022         for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2023                 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2024
2025         info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2026
2027         if (btBlk2nd != MS_LB_NOT_USED) {
2028                 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2029                         info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2030
2031                 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2032         }
2033
2034         result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2035         if (result)
2036                 goto exit;
2037
2038         for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2039                 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2040                 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2041                 if (ms_count_freeblock(us, TmpBlock) == 0) {
2042                         ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2043                         break;
2044                 }
2045         }
2046
2047         /* write */
2048         if (ms_lib_alloc_writebuf(us)) {
2049                 result = MS_NO_MEMORY_ERROR;
2050                 goto exit;
2051         }
2052
2053         result = MS_STATUS_SUCCESS;
2054
2055 exit:
2056         kfree(PageBuffer1);
2057         kfree(PageBuffer0);
2058
2059         printk(KERN_INFO "MS_CardInit end\n");
2060         return result;
2061 }
2062
2063 static int ene_ms_init(struct us_data *us)
2064 {
2065         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2066         int result;
2067         u8 buf[0x200];
2068         u16 MSP_BlockSize, MSP_UserAreaBlocks;
2069         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2070
2071         printk(KERN_INFO "transport --- ENE_MSInit\n");
2072
2073         /* the same part to test ENE */
2074
2075         result = ene_load_bincode(us, MS_INIT_PATTERN);
2076         if (result != USB_STOR_XFER_GOOD) {
2077                 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2078                 return USB_STOR_TRANSPORT_ERROR;
2079         }
2080
2081         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2082         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2083         bcb->DataTransferLength = 0x200;
2084         bcb->Flags      = US_BULK_FLAG_IN;
2085         bcb->CDB[0]     = 0xF1;
2086         bcb->CDB[1]     = 0x01;
2087
2088         result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2089         if (result != USB_STOR_XFER_GOOD) {
2090                 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2091                 return USB_STOR_TRANSPORT_ERROR;
2092         }
2093         /* the same part to test ENE */
2094         info->MS_Status = *(struct MS_STATUS *)&buf[0];
2095
2096         if (info->MS_Status.Insert && info->MS_Status.Ready) {
2097                 printk(KERN_INFO "Insert     = %x\n", info->MS_Status.Insert);
2098                 printk(KERN_INFO "Ready      = %x\n", info->MS_Status.Ready);
2099                 printk(KERN_INFO "IsMSPro    = %x\n", info->MS_Status.IsMSPro);
2100                 printk(KERN_INFO "IsMSPHG    = %x\n", info->MS_Status.IsMSPHG);
2101                 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2102                 if (info->MS_Status.IsMSPro) {
2103                         MSP_BlockSize      = (buf[6] << 8) | buf[7];
2104                         MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
2105                         info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2106                 } else {
2107                         ms_card_init(us); /* Card is MS (to ms.c)*/
2108                 }
2109                 usb_stor_dbg(us, "MS Init Code OK !!\n");
2110         } else {
2111                 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", buf[0]);
2112                 return USB_STOR_TRANSPORT_ERROR;
2113         }
2114
2115         return USB_STOR_TRANSPORT_GOOD;
2116 }
2117
2118 static int ene_sd_init(struct us_data *us)
2119 {
2120         int result;
2121         u8  buf[0x200];
2122         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2123         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2124
2125         usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2126         /* SD Init Part-1 */
2127         result = ene_load_bincode(us, SD_INIT1_PATTERN);
2128         if (result != USB_STOR_XFER_GOOD) {
2129                 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2130                 return USB_STOR_TRANSPORT_ERROR;
2131         }
2132
2133         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2134         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2135         bcb->Flags = US_BULK_FLAG_IN;
2136         bcb->CDB[0] = 0xF2;
2137
2138         result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2139         if (result != USB_STOR_XFER_GOOD) {
2140                 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2141                 return USB_STOR_TRANSPORT_ERROR;
2142         }
2143
2144         /* SD Init Part-2 */
2145         result = ene_load_bincode(us, SD_INIT2_PATTERN);
2146         if (result != USB_STOR_XFER_GOOD) {
2147                 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2148                 return USB_STOR_TRANSPORT_ERROR;
2149         }
2150
2151         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2152         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2153         bcb->DataTransferLength = 0x200;
2154         bcb->Flags              = US_BULK_FLAG_IN;
2155         bcb->CDB[0]             = 0xF1;
2156
2157         result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2158         if (result != USB_STOR_XFER_GOOD) {
2159                 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2160                 return USB_STOR_TRANSPORT_ERROR;
2161         }
2162
2163         info->SD_Status =  *(struct SD_STATUS *)&buf[0];
2164         if (info->SD_Status.Insert && info->SD_Status.Ready) {
2165                 struct SD_STATUS *s = &info->SD_Status;
2166
2167                 ene_get_card_status(us, (unsigned char *)&buf);
2168                 usb_stor_dbg(us, "Insert     = %x\n", s->Insert);
2169                 usb_stor_dbg(us, "Ready      = %x\n", s->Ready);
2170                 usb_stor_dbg(us, "IsMMC      = %x\n", s->IsMMC);
2171                 usb_stor_dbg(us, "HiCapacity = %x\n", s->HiCapacity);
2172                 usb_stor_dbg(us, "HiSpeed    = %x\n", s->HiSpeed);
2173                 usb_stor_dbg(us, "WtP        = %x\n", s->WtP);
2174         } else {
2175                 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", buf[0]);
2176                 return USB_STOR_TRANSPORT_ERROR;
2177         }
2178         return USB_STOR_TRANSPORT_GOOD;
2179 }
2180
2181
2182 static int ene_init(struct us_data *us)
2183 {
2184         int result;
2185         u8  misc_reg03 = 0;
2186         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2187
2188         result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2189         if (result != USB_STOR_XFER_GOOD)
2190                 return USB_STOR_TRANSPORT_ERROR;
2191
2192         if (misc_reg03 & 0x01) {
2193                 if (!info->SD_Status.Ready) {
2194                         result = ene_sd_init(us);
2195                         if (result != USB_STOR_XFER_GOOD)
2196                                 return USB_STOR_TRANSPORT_ERROR;
2197                 }
2198         }
2199         if (misc_reg03 & 0x02) {
2200                 if (!info->MS_Status.Ready) {
2201                         result = ene_ms_init(us);
2202                         if (result != USB_STOR_XFER_GOOD)
2203                                 return USB_STOR_TRANSPORT_ERROR;
2204                 }
2205         }
2206         return result;
2207 }
2208
2209 /*----- sd_scsi_irp() ---------*/
2210 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2211 {
2212         int    result;
2213         struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2214
2215         info->SrbStatus = SS_SUCCESS;
2216         switch (srb->cmnd[0]) {
2217         case TEST_UNIT_READY:
2218                 result = sd_scsi_test_unit_ready(us, srb);
2219                 break; /* 0x00 */
2220         case INQUIRY:
2221                 result = sd_scsi_inquiry(us, srb);
2222                 break; /* 0x12 */
2223         case MODE_SENSE:
2224                 result = sd_scsi_mode_sense(us, srb);
2225                 break; /* 0x1A */
2226         /*
2227         case START_STOP:
2228                 result = SD_SCSI_Start_Stop(us, srb);
2229                 break; //0x1B
2230         */
2231         case READ_CAPACITY:
2232                 result = sd_scsi_read_capacity(us, srb);
2233                 break; /* 0x25 */
2234         case READ_10:
2235                 result = sd_scsi_read(us, srb);
2236                 break; /* 0x28 */
2237         case WRITE_10:
2238                 result = sd_scsi_write(us, srb);
2239                 break; /* 0x2A */
2240         default:
2241                 info->SrbStatus = SS_ILLEGAL_REQUEST;
2242                 result = USB_STOR_TRANSPORT_FAILED;
2243                 break;
2244         }
2245         return result;
2246 }
2247
2248 /*
2249  * ms_scsi_irp()
2250  */
2251 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2252 {
2253         int result;
2254         struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2255         info->SrbStatus = SS_SUCCESS;
2256         switch (srb->cmnd[0]) {
2257         case TEST_UNIT_READY:
2258                 result = ms_scsi_test_unit_ready(us, srb);
2259                 break; /* 0x00 */
2260         case INQUIRY:
2261                 result = ms_scsi_inquiry(us, srb);
2262                 break; /* 0x12 */
2263         case MODE_SENSE:
2264                 result = ms_scsi_mode_sense(us, srb);
2265                 break; /* 0x1A */
2266         case READ_CAPACITY:
2267                 result = ms_scsi_read_capacity(us, srb);
2268                 break; /* 0x25 */
2269         case READ_10:
2270                 result = ms_scsi_read(us, srb);
2271                 break; /* 0x28 */
2272         case WRITE_10:
2273                 result = ms_scsi_write(us, srb);
2274                 break;  /* 0x2A */
2275         default:
2276                 info->SrbStatus = SS_ILLEGAL_REQUEST;
2277                 result = USB_STOR_TRANSPORT_FAILED;
2278                 break;
2279         }
2280         return result;
2281 }
2282
2283 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2284 {
2285         int result = 0;
2286         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2287
2288         /*US_DEBUG(usb_stor_show_command(us, srb)); */
2289         scsi_set_resid(srb, 0);
2290         if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) {
2291                 result = ene_init(us);
2292         } else {
2293                 if (info->SD_Status.Ready)
2294                         result = sd_scsi_irp(us, srb);
2295
2296                 if (info->MS_Status.Ready)
2297                         result = ms_scsi_irp(us, srb);
2298         }
2299         return 0;
2300 }
2301
2302 static struct scsi_host_template ene_ub6250_host_template;
2303
2304 static int ene_ub6250_probe(struct usb_interface *intf,
2305                          const struct usb_device_id *id)
2306 {
2307         int result;
2308         u8  misc_reg03 = 0;
2309         struct us_data *us;
2310
2311         result = usb_stor_probe1(&us, intf, id,
2312                    (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2313                    &ene_ub6250_host_template);
2314         if (result)
2315                 return result;
2316
2317         /* FIXME: where should the code alloc extra buf ? */
2318         if (!us->extra) {
2319                 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2320                 if (!us->extra)
2321                         return -ENOMEM;
2322                 us->extra_destructor = ene_ub6250_info_destructor;
2323         }
2324
2325         us->transport_name = "ene_ub6250";
2326         us->transport = ene_transport;
2327         us->max_lun = 0;
2328
2329         result = usb_stor_probe2(us);
2330         if (result)
2331                 return result;
2332
2333         /* probe card type */
2334         result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2335         if (result != USB_STOR_XFER_GOOD) {
2336                 usb_stor_disconnect(intf);
2337                 return USB_STOR_TRANSPORT_ERROR;
2338         }
2339
2340         if (!(misc_reg03 & 0x01)) {
2341                 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2342                         "It does not support SM cards.\n");
2343         }
2344
2345         return result;
2346 }
2347
2348
2349 #ifdef CONFIG_PM
2350
2351 static int ene_ub6250_resume(struct usb_interface *iface)
2352 {
2353         u8 tmp = 0;
2354         struct us_data *us = usb_get_intfdata(iface);
2355         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2356
2357         mutex_lock(&us->dev_mutex);
2358
2359         if (us->suspend_resume_hook)
2360                 (us->suspend_resume_hook)(us, US_RESUME);
2361
2362         mutex_unlock(&us->dev_mutex);
2363
2364         info->Power_IsResum = true;
2365         /*info->SD_Status.Ready = 0; */
2366         info->SD_Status = *(struct SD_STATUS *)&tmp;
2367         info->MS_Status = *(struct MS_STATUS *)&tmp;
2368         info->SM_Status = *(struct SM_STATUS *)&tmp;
2369
2370         return 0;
2371 }
2372
2373 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2374 {
2375         u8 tmp = 0;
2376         struct us_data *us = usb_get_intfdata(iface);
2377         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2378
2379         /* Report the reset to the SCSI core */
2380         usb_stor_reset_resume(iface);
2381
2382         /*
2383          * FIXME: Notify the subdrivers that they need to reinitialize
2384          * the device
2385          */
2386         info->Power_IsResum = true;
2387         /*info->SD_Status.Ready = 0; */
2388         info->SD_Status = *(struct SD_STATUS *)&tmp;
2389         info->MS_Status = *(struct MS_STATUS *)&tmp;
2390         info->SM_Status = *(struct SM_STATUS *)&tmp;
2391
2392         return 0;
2393 }
2394
2395 #else
2396
2397 #define ene_ub6250_resume               NULL
2398 #define ene_ub6250_reset_resume         NULL
2399
2400 #endif
2401
2402 static struct usb_driver ene_ub6250_driver = {
2403         .name =         DRV_NAME,
2404         .probe =        ene_ub6250_probe,
2405         .disconnect =   usb_stor_disconnect,
2406         .suspend =      usb_stor_suspend,
2407         .resume =       ene_ub6250_resume,
2408         .reset_resume = ene_ub6250_reset_resume,
2409         .pre_reset =    usb_stor_pre_reset,
2410         .post_reset =   usb_stor_post_reset,
2411         .id_table =     ene_ub6250_usb_ids,
2412         .soft_unbind =  1,
2413         .no_dynamic_id = 1,
2414 };
2415
2416 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);