drivers/usb/storage/ene_ub6250.c

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