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