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 sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
 597 {
 598         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
 599
 600         if (info->SD_Status.Insert && info->SD_Status.Ready)
 601                 return USB_STOR_TRANSPORT_GOOD;
 602         else {
 603                 ene_sd_init(us);
 604                 return USB_STOR_TRANSPORT_GOOD;
 605         }
 606
 607         return USB_STOR_TRANSPORT_GOOD;
 608 }
 609
 610 static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
 611 {
 612         unsigned char data_ptr[36] = {
 613                 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
 614                 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
 615                 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
 616                 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
 617
 618         usb_stor_set_xfer_buf(data_ptr, 36, srb);
 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_inquiry(struct us_data *us, struct scsi_cmnd *srb)
1466 {
1467         /* pr_info("MS_SCSI_Inquiry\n"); */
1468         unsigned char data_ptr[36] = {
1469                 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
1470                 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
1471                 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
1472                 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
1473
1474         usb_stor_set_xfer_buf(data_ptr, 36, srb);
1475         return USB_STOR_TRANSPORT_GOOD;
1476 }
1477
1478 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1479 {
1480         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1481         unsigned char mediaNoWP[12] = {
1482                 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1483                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1484         unsigned char mediaWP[12]   = {
1485                 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1486                 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1487
1488         if (info->MS_Status.WtP)
1489                 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1490         else
1491                 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1492
1493         return USB_STOR_TRANSPORT_GOOD;
1494 }
1495
1496 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1497 {
1498         u32   bl_num;
1499         u16    bl_len;
1500         unsigned int offset = 0;
1501         unsigned char    buf[8];
1502         struct scatterlist *sg = NULL;
1503         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1504
1505         usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1506         bl_len = 0x200;
1507         if (info->MS_Status.IsMSPro)
1508                 bl_num = info->MSP_TotalBlock - 1;
1509         else
1510                 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1511
1512         info->bl_num = bl_num;
1513         usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1514         usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1515
1516         /*srb->request_bufflen = 8; */
1517         buf[0] = (bl_num >> 24) & 0xff;
1518         buf[1] = (bl_num >> 16) & 0xff;
1519         buf[2] = (bl_num >> 8) & 0xff;
1520         buf[3] = (bl_num >> 0) & 0xff;
1521         buf[4] = (bl_len >> 24) & 0xff;
1522         buf[5] = (bl_len >> 16) & 0xff;
1523         buf[6] = (bl_len >> 8) & 0xff;
1524         buf[7] = (bl_len >> 0) & 0xff;
1525
1526         usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1527
1528         return USB_STOR_TRANSPORT_GOOD;
1529 }
1530
1531 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1532 {
1533         PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1534
1535         if (PhyBlock) {
1536                 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1537                 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1538         } else {
1539                 *LogStart = 0;
1540                 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1541         }
1542 }
1543
1544 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1545         u8 PageNum, u8 blen, void *buf)
1546 {
1547         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1548         int     result;
1549
1550         /* Read Extra Data */
1551         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1552         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1553         bcb->DataTransferLength = 0x4 * blen;
1554         bcb->Flags      = US_BULK_FLAG_IN;
1555         bcb->CDB[0]     = 0xF1;
1556         bcb->CDB[1]     = 0x03;
1557         bcb->CDB[5]     = (unsigned char)(PageNum);
1558         bcb->CDB[4]     = (unsigned char)(PhyBlock);
1559         bcb->CDB[3]     = (unsigned char)(PhyBlock>>8);
1560         bcb->CDB[2]     = (unsigned char)(PhyBlock>>16);
1561         bcb->CDB[6]     = blen;
1562
1563         result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1564         if (result != USB_STOR_XFER_GOOD)
1565                 return USB_STOR_TRANSPORT_ERROR;
1566
1567         return USB_STOR_TRANSPORT_GOOD;
1568 }
1569
1570 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1571 {
1572         u16 PhyBlock, newblk, i;
1573         u16 LogStart, LogEnde;
1574         struct ms_lib_type_extdat extdat;
1575         u8 buf[0x200];
1576         u32 count = 0, index = 0;
1577         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1578
1579         for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1580                 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1581
1582                 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1583                         switch (ms_libconv_to_logical(info, PhyBlock)) {
1584                         case MS_STATUS_ERROR:
1585                                 continue;
1586                         default:
1587                                 break;
1588                         }
1589
1590                         if (count == PhyBlock) {
1591                                 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, &buf);
1592                                 count += 0x80;
1593                         }
1594                         index = (PhyBlock % 0x80) * 4;
1595
1596                         extdat.ovrflg = buf[index];
1597                         extdat.mngflg = buf[index+1];
1598                         extdat.logadr = memstick_logaddr(buf[index+2], buf[index+3]);
1599
1600                         if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1601                                 ms_lib_setacquired_errorblock(us, PhyBlock);
1602                                 continue;
1603                         }
1604
1605                         if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1606                                 ms_lib_erase_phyblock(us, PhyBlock);
1607                                 continue;
1608                         }
1609
1610                         if (extdat.logadr != MS_LB_NOT_USED) {
1611                                 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1612                                         ms_lib_erase_phyblock(us, PhyBlock);
1613                                         continue;
1614                                 }
1615
1616                                 newblk = ms_libconv_to_physical(info, extdat.logadr);
1617
1618                                 if (newblk != MS_LB_NOT_USED) {
1619                                         if (extdat.logadr == 0) {
1620                                                 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1621                                                 if (ms_lib_check_disableblock(us, btBlk1st)) {
1622                                                         ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1623                                                         continue;
1624                                                 }
1625                                         }
1626
1627                                         ms_lib_read_extra(us, newblk, 0, &extdat);
1628                                         if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1629                                                 ms_lib_erase_phyblock(us, PhyBlock);
1630                                                 continue;
1631                                         } else {
1632                                                 ms_lib_erase_phyblock(us, newblk);
1633                                         }
1634                                 }
1635
1636                                 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1637                         }
1638                 }
1639         } /* End for ... */
1640
1641         return MS_STATUS_SUCCESS;
1642 }
1643
1644
1645 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1646 {
1647         int result;
1648         unsigned char *cdb = srb->cmnd;
1649         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1650         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1651
1652         u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1653                 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1654         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1655         u32 blenByte = blen * 0x200;
1656
1657         if (bn > info->bl_num)
1658                 return USB_STOR_TRANSPORT_ERROR;
1659
1660         if (info->MS_Status.IsMSPro) {
1661                 result = ene_load_bincode(us, MSP_RW_PATTERN);
1662                 if (result != USB_STOR_XFER_GOOD) {
1663                         usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1664                         return USB_STOR_TRANSPORT_ERROR;
1665                 }
1666
1667                 /* set up the command wrapper */
1668                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1669                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1670                 bcb->DataTransferLength = blenByte;
1671                 bcb->Flags  = US_BULK_FLAG_IN;
1672                 bcb->CDB[0] = 0xF1;
1673                 bcb->CDB[1] = 0x02;
1674                 bcb->CDB[5] = (unsigned char)(bn);
1675                 bcb->CDB[4] = (unsigned char)(bn>>8);
1676                 bcb->CDB[3] = (unsigned char)(bn>>16);
1677                 bcb->CDB[2] = (unsigned char)(bn>>24);
1678
1679                 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1680         } else {
1681                 void *buf;
1682                 int offset = 0;
1683                 u16 phyblk, logblk;
1684                 u8 PageNum;
1685                 u16 len;
1686                 u32 blkno;
1687
1688                 buf = kmalloc(blenByte, GFP_KERNEL);
1689                 if (buf == NULL)
1690                         return USB_STOR_TRANSPORT_ERROR;
1691
1692                 result = ene_load_bincode(us, MS_RW_PATTERN);
1693                 if (result != USB_STOR_XFER_GOOD) {
1694                         pr_info("Load MS RW pattern Fail !!\n");
1695                         result = USB_STOR_TRANSPORT_ERROR;
1696                         goto exit;
1697                 }
1698
1699                 logblk  = (u16)(bn / info->MS_Lib.PagesPerBlock);
1700                 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1701
1702                 while (1) {
1703                         if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1704                                 len = info->MS_Lib.PagesPerBlock-PageNum;
1705                         else
1706                                 len = blen;
1707
1708                         phyblk = ms_libconv_to_physical(info, logblk);
1709                         blkno  = phyblk * 0x20 + PageNum;
1710
1711                         /* set up the command wrapper */
1712                         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1713                         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1714                         bcb->DataTransferLength = 0x200 * len;
1715                         bcb->Flags  = US_BULK_FLAG_IN;
1716                         bcb->CDB[0] = 0xF1;
1717                         bcb->CDB[1] = 0x02;
1718                         bcb->CDB[5] = (unsigned char)(blkno);
1719                         bcb->CDB[4] = (unsigned char)(blkno>>8);
1720                         bcb->CDB[3] = (unsigned char)(blkno>>16);
1721                         bcb->CDB[2] = (unsigned char)(blkno>>24);
1722
1723                         result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1724                         if (result != USB_STOR_XFER_GOOD) {
1725                                 pr_info("MS_SCSI_Read --- result = %x\n", result);
1726                                 result = USB_STOR_TRANSPORT_ERROR;
1727                                 goto exit;
1728                         }
1729
1730                         blen -= len;
1731                         if (blen <= 0)
1732                                 break;
1733                         logblk++;
1734                         PageNum = 0;
1735                         offset += MS_BYTES_PER_PAGE*len;
1736                 }
1737                 usb_stor_set_xfer_buf(buf, blenByte, srb);
1738 exit:
1739                 kfree(buf);
1740         }
1741         return result;
1742 }
1743
1744 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1745 {
1746         int result;
1747         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1748         unsigned char *cdb = srb->cmnd;
1749         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1750
1751         u32 bn = ((cdb[2] << 24) & 0xff000000) |
1752                         ((cdb[3] << 16) & 0x00ff0000) |
1753                         ((cdb[4] << 8) & 0x0000ff00) |
1754                         ((cdb[5] << 0) & 0x000000ff);
1755         u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1756         u32 blenByte = blen * 0x200;
1757
1758         if (bn > info->bl_num)
1759                 return USB_STOR_TRANSPORT_ERROR;
1760
1761         if (info->MS_Status.IsMSPro) {
1762                 result = ene_load_bincode(us, MSP_RW_PATTERN);
1763                 if (result != USB_STOR_XFER_GOOD) {
1764                         pr_info("Load MSP RW pattern Fail !!\n");
1765                         return USB_STOR_TRANSPORT_ERROR;
1766                 }
1767
1768                 /* set up the command wrapper */
1769                 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1770                 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1771                 bcb->DataTransferLength = blenByte;
1772                 bcb->Flags  = 0x00;
1773                 bcb->CDB[0] = 0xF0;
1774                 bcb->CDB[1] = 0x04;
1775                 bcb->CDB[5] = (unsigned char)(bn);
1776                 bcb->CDB[4] = (unsigned char)(bn>>8);
1777                 bcb->CDB[3] = (unsigned char)(bn>>16);
1778                 bcb->CDB[2] = (unsigned char)(bn>>24);
1779
1780                 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1781         } else {
1782                 void *buf;
1783                 int offset = 0;
1784                 u16 PhyBlockAddr;
1785                 u8 PageNum;
1786                 u16 len, oldphy, newphy;
1787
1788                 buf = kmalloc(blenByte, GFP_KERNEL);
1789                 if (buf == NULL)
1790                         return USB_STOR_TRANSPORT_ERROR;
1791                 usb_stor_set_xfer_buf(buf, blenByte, srb);
1792
1793                 result = ene_load_bincode(us, MS_RW_PATTERN);
1794                 if (result != USB_STOR_XFER_GOOD) {
1795                         pr_info("Load MS RW pattern Fail !!\n");
1796                         result = USB_STOR_TRANSPORT_ERROR;
1797                         goto exit;
1798                 }
1799
1800                 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1801                 PageNum      = (u8)(bn % info->MS_Lib.PagesPerBlock);
1802
1803                 while (1) {
1804                         if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1805                                 len = info->MS_Lib.PagesPerBlock-PageNum;
1806                         else
1807                                 len = blen;
1808
1809                         oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1810                         newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1811
1812                         result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1813
1814                         if (result != USB_STOR_XFER_GOOD) {
1815                                 pr_info("MS_SCSI_Write --- result = %x\n", result);
1816                                 result =  USB_STOR_TRANSPORT_ERROR;
1817                                 goto exit;
1818                         }
1819
1820                         info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1821                         ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1822
1823                         blen -= len;
1824                         if (blen <= 0)
1825                                 break;
1826                         PhyBlockAddr++;
1827                         PageNum = 0;
1828                         offset += MS_BYTES_PER_PAGE*len;
1829                 }
1830 exit:
1831                 kfree(buf);
1832         }
1833         return result;
1834 }
1835
1836 /*
1837  * ENE MS Card
1838  */
1839
1840 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1841 {
1842         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1843         int result;
1844
1845         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1846         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1847         bcb->DataTransferLength = 0x01;
1848         bcb->Flags                      = US_BULK_FLAG_IN;
1849         bcb->CDB[0]                     = 0xED;
1850         bcb->CDB[2]                     = (unsigned char)(index>>8);
1851         bcb->CDB[3]                     = (unsigned char)index;
1852
1853         result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1854         return result;
1855 }
1856
1857 static int ene_get_card_status(struct us_data *us, u8 *buf)
1858 {
1859         u16 tmpreg;
1860         u32 reg4b;
1861         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1862
1863         /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1864         reg4b = *(u32 *)&buf[0x18];
1865         info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1866
1867         tmpreg = (u16) reg4b;
1868         reg4b = *(u32 *)(&buf[0x14]);
1869         if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1870                 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1871
1872         info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1873         info->SD_C_SIZE_MULT = (u8)(reg4b >> 7)  & 0x07;
1874         if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1875                 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1876
1877         if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1878                 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1879                 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1880         } else {
1881                 info->SD_Block_Mult = 1;
1882         }
1883
1884         return USB_STOR_TRANSPORT_GOOD;
1885 }
1886
1887 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1888 {
1889         int err;
1890         char *fw_name = NULL;
1891         unsigned char *buf = NULL;
1892         const struct firmware *sd_fw = NULL;
1893         int result = USB_STOR_TRANSPORT_ERROR;
1894         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1895         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1896
1897         if (info->BIN_FLAG == flag)
1898                 return USB_STOR_TRANSPORT_GOOD;
1899
1900         switch (flag) {
1901         /* For SD */
1902         case SD_INIT1_PATTERN:
1903                 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1904                 fw_name = SD_INIT1_FIRMWARE;
1905                 break;
1906         case SD_INIT2_PATTERN:
1907                 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1908                 fw_name = SD_INIT2_FIRMWARE;
1909                 break;
1910         case SD_RW_PATTERN:
1911                 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1912                 fw_name = SD_RW_FIRMWARE;
1913                 break;
1914         /* For MS */
1915         case MS_INIT_PATTERN:
1916                 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1917                 fw_name = MS_INIT_FIRMWARE;
1918                 break;
1919         case MSP_RW_PATTERN:
1920                 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1921                 fw_name = MSP_RW_FIRMWARE;
1922                 break;
1923         case MS_RW_PATTERN:
1924                 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1925                 fw_name = MS_RW_FIRMWARE;
1926                 break;
1927         default:
1928                 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1929                 goto nofw;
1930         }
1931
1932         err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1933         if (err) {
1934                 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1935                 goto nofw;
1936         }
1937         buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1938         if (buf == NULL)
1939                 goto nofw;
1940
1941         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1942         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1943         bcb->DataTransferLength = sd_fw->size;
1944         bcb->Flags = 0x00;
1945         bcb->CDB[0] = 0xEF;
1946
1947         result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1948         if (us->srb != NULL)
1949                 scsi_set_resid(us->srb, 0);
1950         info->BIN_FLAG = flag;
1951         kfree(buf);
1952
1953 nofw:
1954         release_firmware(sd_fw);
1955         return result;
1956 }
1957
1958 static int ms_card_init(struct us_data *us)
1959 {
1960         u32 result;
1961         u16 TmpBlock;
1962         unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1963         struct ms_lib_type_extdat extdat;
1964         u16 btBlk1st, btBlk2nd;
1965         u32 btBlk1stErred;
1966         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1967
1968         printk(KERN_INFO "MS_CardInit start\n");
1969
1970         ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1971
1972         /* get two PageBuffer */
1973         PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1974         PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1975         if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1976                 result = MS_NO_MEMORY_ERROR;
1977                 goto exit;
1978         }
1979
1980         btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1981         btBlk1stErred = 0;
1982
1983         for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1984
1985                 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1986                 case MS_STATUS_SUCCESS:
1987                         break;
1988                 case MS_STATUS_INT_ERROR:
1989                         break;
1990                 case MS_STATUS_ERROR:
1991                 default:
1992                         continue;
1993                 }
1994
1995                 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1996                         continue;
1997
1998                 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1999                         (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
2000                         (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
2001                         (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
2002                                 continue;
2003
2004                 if (btBlk1st != MS_LB_NOT_USED) {
2005                         btBlk2nd = TmpBlock;
2006                         break;
2007                 }
2008
2009                 btBlk1st = TmpBlock;
2010                 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
2011                 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2012                         btBlk1stErred = 1;
2013         }
2014
2015         if (btBlk1st == MS_LB_NOT_USED) {
2016                 result = MS_STATUS_ERROR;
2017                 goto exit;
2018         }
2019
2020         /* write protect */
2021         if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2022                 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2023
2024         result = MS_STATUS_ERROR;
2025         /* 1st Boot Block */
2026         if (btBlk1stErred == 0)
2027                 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2028                 /* 1st */
2029         /* 2nd Boot Block */
2030         if (result && (btBlk2nd != MS_LB_NOT_USED))
2031                 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2032
2033         if (result) {
2034                 result = MS_STATUS_ERROR;
2035                 goto exit;
2036         }
2037
2038         for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2039                 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2040
2041         info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2042
2043         if (btBlk2nd != MS_LB_NOT_USED) {
2044                 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2045                         info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2046
2047                 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2048         }
2049
2050         result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2051         if (result)
2052                 goto exit;
2053
2054         for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2055                 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2056                 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2057                 if (ms_count_freeblock(us, TmpBlock) == 0) {
2058                         ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2059                         break;
2060                 }
2061         }
2062
2063         /* write */
2064         if (ms_lib_alloc_writebuf(us)) {
2065                 result = MS_NO_MEMORY_ERROR;
2066                 goto exit;
2067         }
2068
2069         result = MS_STATUS_SUCCESS;
2070
2071 exit:
2072         kfree(PageBuffer1);
2073         kfree(PageBuffer0);
2074
2075         printk(KERN_INFO "MS_CardInit end\n");
2076         return result;
2077 }
2078
2079 static int ene_ms_init(struct us_data *us)
2080 {
2081         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2082         int result;
2083         u8 buf[0x200];
2084         u16 MSP_BlockSize, MSP_UserAreaBlocks;
2085         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2086
2087         printk(KERN_INFO "transport --- ENE_MSInit\n");
2088
2089         /* the same part to test ENE */
2090
2091         result = ene_load_bincode(us, MS_INIT_PATTERN);
2092         if (result != USB_STOR_XFER_GOOD) {
2093                 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2094                 return USB_STOR_TRANSPORT_ERROR;
2095         }
2096
2097         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2098         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2099         bcb->DataTransferLength = 0x200;
2100         bcb->Flags      = US_BULK_FLAG_IN;
2101         bcb->CDB[0]     = 0xF1;
2102         bcb->CDB[1]     = 0x01;
2103
2104         result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2105         if (result != USB_STOR_XFER_GOOD) {
2106                 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2107                 return USB_STOR_TRANSPORT_ERROR;
2108         }
2109         /* the same part to test ENE */
2110         info->MS_Status = *(struct MS_STATUS *)&buf[0];
2111
2112         if (info->MS_Status.Insert && info->MS_Status.Ready) {
2113                 printk(KERN_INFO "Insert     = %x\n", info->MS_Status.Insert);
2114                 printk(KERN_INFO "Ready      = %x\n", info->MS_Status.Ready);
2115                 printk(KERN_INFO "IsMSPro    = %x\n", info->MS_Status.IsMSPro);
2116                 printk(KERN_INFO "IsMSPHG    = %x\n", info->MS_Status.IsMSPHG);
2117                 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2118                 if (info->MS_Status.IsMSPro) {
2119                         MSP_BlockSize      = (buf[6] << 8) | buf[7];
2120                         MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
2121                         info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2122                 } else {
2123                         ms_card_init(us); /* Card is MS (to ms.c)*/
2124                 }
2125                 usb_stor_dbg(us, "MS Init Code OK !!\n");
2126         } else {
2127                 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", buf[0]);
2128                 return USB_STOR_TRANSPORT_ERROR;
2129         }
2130
2131         return USB_STOR_TRANSPORT_GOOD;
2132 }
2133
2134 static int ene_sd_init(struct us_data *us)
2135 {
2136         int result;
2137         u8  buf[0x200];
2138         struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2139         struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2140
2141         usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2142         /* SD Init Part-1 */
2143         result = ene_load_bincode(us, SD_INIT1_PATTERN);
2144         if (result != USB_STOR_XFER_GOOD) {
2145                 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2146                 return USB_STOR_TRANSPORT_ERROR;
2147         }
2148
2149         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2150         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2151         bcb->Flags = US_BULK_FLAG_IN;
2152         bcb->CDB[0] = 0xF2;
2153
2154         result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2155         if (result != USB_STOR_XFER_GOOD) {
2156                 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2157                 return USB_STOR_TRANSPORT_ERROR;
2158         }
2159
2160         /* SD Init Part-2 */
2161         result = ene_load_bincode(us, SD_INIT2_PATTERN);
2162         if (result != USB_STOR_XFER_GOOD) {
2163                 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2164                 return USB_STOR_TRANSPORT_ERROR;
2165         }
2166
2167         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2168         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2169         bcb->DataTransferLength = 0x200;
2170         bcb->Flags              = US_BULK_FLAG_IN;
2171         bcb->CDB[0]             = 0xF1;
2172
2173         result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2174         if (result != USB_STOR_XFER_GOOD) {
2175                 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2176                 return USB_STOR_TRANSPORT_ERROR;
2177         }
2178
2179         info->SD_Status =  *(struct SD_STATUS *)&buf[0];
2180         if (info->SD_Status.Insert && info->SD_Status.Ready) {
2181                 struct SD_STATUS *s = &info->SD_Status;
2182
2183                 ene_get_card_status(us, (unsigned char *)&buf);
2184                 usb_stor_dbg(us, "Insert     = %x\n", s->Insert);
2185                 usb_stor_dbg(us, "Ready      = %x\n", s->Ready);
2186                 usb_stor_dbg(us, "IsMMC      = %x\n", s->IsMMC);
2187                 usb_stor_dbg(us, "HiCapacity = %x\n", s->HiCapacity);
2188                 usb_stor_dbg(us, "HiSpeed    = %x\n", s->HiSpeed);
2189                 usb_stor_dbg(us, "WtP        = %x\n", s->WtP);
2190         } else {
2191                 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", buf[0]);
2192                 return USB_STOR_TRANSPORT_ERROR;
2193         }
2194         return USB_STOR_TRANSPORT_GOOD;
2195 }
2196
2197
2198 static int ene_init(struct us_data *us)
2199 {
2200         int result;
2201         u8  misc_reg03 = 0;
2202         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2203
2204         result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2205         if (result != USB_STOR_XFER_GOOD)
2206                 return USB_STOR_TRANSPORT_ERROR;
2207
2208         if (misc_reg03 & 0x01) {
2209                 if (!info->SD_Status.Ready) {
2210                         result = ene_sd_init(us);
2211                         if (result != USB_STOR_XFER_GOOD)
2212                                 return USB_STOR_TRANSPORT_ERROR;
2213                 }
2214         }
2215         if (misc_reg03 & 0x02) {
2216                 if (!info->MS_Status.Ready) {
2217                         result = ene_ms_init(us);
2218                         if (result != USB_STOR_XFER_GOOD)
2219                                 return USB_STOR_TRANSPORT_ERROR;
2220                 }
2221         }
2222         return result;
2223 }
2224
2225 /*----- sd_scsi_irp() ---------*/
2226 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2227 {
2228         int    result;
2229         struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2230
2231         switch (srb->cmnd[0]) {
2232         case TEST_UNIT_READY:
2233                 result = sd_scsi_test_unit_ready(us, srb);
2234                 break; /* 0x00 */
2235         case REQUEST_SENSE:
2236                 result = do_scsi_request_sense(us, srb);
2237                 break; /* 0x03 */
2238         case INQUIRY:
2239                 result = sd_scsi_inquiry(us, srb);
2240                 break; /* 0x12 */
2241         case MODE_SENSE:
2242                 result = sd_scsi_mode_sense(us, srb);
2243                 break; /* 0x1A */
2244         /*
2245         case START_STOP:
2246                 result = SD_SCSI_Start_Stop(us, srb);
2247                 break; //0x1B
2248         */
2249         case READ_CAPACITY:
2250                 result = sd_scsi_read_capacity(us, srb);
2251                 break; /* 0x25 */
2252         case READ_10:
2253                 result = sd_scsi_read(us, srb);
2254                 break; /* 0x28 */
2255         case WRITE_10:
2256                 result = sd_scsi_write(us, srb);
2257                 break; /* 0x2A */
2258         default:
2259                 info->SrbStatus = SS_ILLEGAL_REQUEST;
2260                 result = USB_STOR_TRANSPORT_FAILED;
2261                 break;
2262         }
2263         if (result == USB_STOR_TRANSPORT_GOOD)
2264                 info->SrbStatus = SS_SUCCESS;
2265         return result;
2266 }
2267
2268 /*
2269  * ms_scsi_irp()
2270  */
2271 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2272 {
2273         int result;
2274         struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2275
2276         switch (srb->cmnd[0]) {
2277         case TEST_UNIT_READY:
2278                 result = ms_scsi_test_unit_ready(us, srb);
2279                 break; /* 0x00 */
2280         case REQUEST_SENSE:
2281                 result = do_scsi_request_sense(us, srb);
2282                 break; /* 0x03 */
2283         case INQUIRY:
2284                 result = ms_scsi_inquiry(us, srb);
2285                 break; /* 0x12 */
2286         case MODE_SENSE:
2287                 result = ms_scsi_mode_sense(us, srb);
2288                 break; /* 0x1A */
2289         case READ_CAPACITY:
2290                 result = ms_scsi_read_capacity(us, srb);
2291                 break; /* 0x25 */
2292         case READ_10:
2293                 result = ms_scsi_read(us, srb);
2294                 break; /* 0x28 */
2295         case WRITE_10:
2296                 result = ms_scsi_write(us, srb);
2297                 break;  /* 0x2A */
2298         default:
2299                 info->SrbStatus = SS_ILLEGAL_REQUEST;
2300                 result = USB_STOR_TRANSPORT_FAILED;
2301                 break;
2302         }
2303         if (result == USB_STOR_TRANSPORT_GOOD)
2304                 info->SrbStatus = SS_SUCCESS;
2305         return result;
2306 }
2307
2308 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2309 {
2310         int result = USB_STOR_XFER_GOOD;
2311         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2312
2313         /*US_DEBUG(usb_stor_show_command(us, srb)); */
2314         scsi_set_resid(srb, 0);
2315         if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready)))
2316                 result = ene_init(us);
2317         if (result == USB_STOR_XFER_GOOD) {
2318                 result = USB_STOR_TRANSPORT_ERROR;
2319                 if (info->SD_Status.Ready)
2320                         result = sd_scsi_irp(us, srb);
2321
2322                 if (info->MS_Status.Ready)
2323                         result = ms_scsi_irp(us, srb);
2324         }
2325         return result;
2326 }
2327
2328 static struct scsi_host_template ene_ub6250_host_template;
2329
2330 static int ene_ub6250_probe(struct usb_interface *intf,
2331                          const struct usb_device_id *id)
2332 {
2333         int result;
2334         u8  misc_reg03 = 0;
2335         struct us_data *us;
2336
2337         result = usb_stor_probe1(&us, intf, id,
2338                    (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2339                    &ene_ub6250_host_template);
2340         if (result)
2341                 return result;
2342
2343         /* FIXME: where should the code alloc extra buf ? */
2344         if (!us->extra) {
2345                 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2346                 if (!us->extra)
2347                         return -ENOMEM;
2348                 us->extra_destructor = ene_ub6250_info_destructor;
2349         }
2350
2351         us->transport_name = "ene_ub6250";
2352         us->transport = ene_transport;
2353         us->max_lun = 0;
2354
2355         result = usb_stor_probe2(us);
2356         if (result)
2357                 return result;
2358
2359         /* probe card type */
2360         result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2361         if (result != USB_STOR_XFER_GOOD) {
2362                 usb_stor_disconnect(intf);
2363                 return USB_STOR_TRANSPORT_ERROR;
2364         }
2365
2366         if (!(misc_reg03 & 0x01)) {
2367                 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2368                         "It does not support SM cards.\n");
2369         }
2370
2371         return result;
2372 }
2373
2374
2375 #ifdef CONFIG_PM
2376
2377 static int ene_ub6250_resume(struct usb_interface *iface)
2378 {
2379         u8 tmp = 0;
2380         struct us_data *us = usb_get_intfdata(iface);
2381         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2382
2383         mutex_lock(&us->dev_mutex);
2384
2385         if (us->suspend_resume_hook)
2386                 (us->suspend_resume_hook)(us, US_RESUME);
2387
2388         mutex_unlock(&us->dev_mutex);
2389
2390         info->Power_IsResum = true;
2391         /*info->SD_Status.Ready = 0; */
2392         info->SD_Status = *(struct SD_STATUS *)&tmp;
2393         info->MS_Status = *(struct MS_STATUS *)&tmp;
2394         info->SM_Status = *(struct SM_STATUS *)&tmp;
2395
2396         return 0;
2397 }
2398
2399 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2400 {
2401         u8 tmp = 0;
2402         struct us_data *us = usb_get_intfdata(iface);
2403         struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2404
2405         /* Report the reset to the SCSI core */
2406         usb_stor_reset_resume(iface);
2407
2408         /*
2409          * FIXME: Notify the subdrivers that they need to reinitialize
2410          * the device
2411          */
2412         info->Power_IsResum = true;
2413         /*info->SD_Status.Ready = 0; */
2414         info->SD_Status = *(struct SD_STATUS *)&tmp;
2415         info->MS_Status = *(struct MS_STATUS *)&tmp;
2416         info->SM_Status = *(struct SM_STATUS *)&tmp;
2417
2418         return 0;
2419 }
2420
2421 #else
2422
2423 #define ene_ub6250_resume               NULL
2424 #define ene_ub6250_reset_resume         NULL
2425
2426 #endif
2427
2428 static struct usb_driver ene_ub6250_driver = {
2429         .name =         DRV_NAME,
2430         .probe =        ene_ub6250_probe,
2431         .disconnect =   usb_stor_disconnect,
2432         .suspend =      usb_stor_suspend,
2433         .resume =       ene_ub6250_resume,
2434         .reset_resume = ene_ub6250_reset_resume,
2435         .pre_reset =    usb_stor_pre_reset,
2436         .post_reset =   usb_stor_post_reset,
2437         .id_table =     ene_ub6250_usb_ids,
2438         .soft_unbind =  1,
2439         .no_dynamic_id = 1,
2440 };
2441
2442 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);