drivers/usb/storage/ene_ub6250.c

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