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