drivers/usb/storage/ene_ub6250.c

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