drivers/usb/storage/ene_ub6250.c

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