drivers/usb/storage/ene_ub6250.c

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