drivers/usb/storage/ene_ub6250.c

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