drivers/usb/storage/ene_ub6250.c

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