kernel/drivers/usb/storage/ene_ub6250.c

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