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