Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 #include <linux/jiffies.h>
0003 #include <linux/errno.h>
0004 #include <linux/module.h>
0005 #include <linux/slab.h>
0006 
0007 #include <scsi/scsi.h>
0008 #include <scsi/scsi_cmnd.h>
0009 
0010 #include <linux/firmware.h>
0011 
0012 #include "usb.h"
0013 #include "transport.h"
0014 #include "protocol.h"
0015 #include "debug.h"
0016 #include "scsiglue.h"
0017 
0018 #define SD_INIT1_FIRMWARE "ene-ub6250/sd_init1.bin"
0019 #define SD_INIT2_FIRMWARE "ene-ub6250/sd_init2.bin"
0020 #define SD_RW_FIRMWARE "ene-ub6250/sd_rdwr.bin"
0021 #define MS_INIT_FIRMWARE "ene-ub6250/ms_init.bin"
0022 #define MSP_RW_FIRMWARE "ene-ub6250/msp_rdwr.bin"
0023 #define MS_RW_FIRMWARE "ene-ub6250/ms_rdwr.bin"
0024 
0025 #define DRV_NAME "ums_eneub6250"
0026 
0027 MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
0028 MODULE_LICENSE("GPL");
0029 MODULE_IMPORT_NS(USB_STORAGE);
0030 MODULE_FIRMWARE(SD_INIT1_FIRMWARE);
0031 MODULE_FIRMWARE(SD_INIT2_FIRMWARE);
0032 MODULE_FIRMWARE(SD_RW_FIRMWARE);
0033 MODULE_FIRMWARE(MS_INIT_FIRMWARE);
0034 MODULE_FIRMWARE(MSP_RW_FIRMWARE);
0035 MODULE_FIRMWARE(MS_RW_FIRMWARE);
0036 
0037 /*
0038  * The table of devices
0039  */
0040 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
0041             vendorName, productName, useProtocol, useTransport, \
0042             initFunction, flags) \
0043 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
0044     .driver_info = (flags)}
0045 
0046 static struct usb_device_id ene_ub6250_usb_ids[] = {
0047 #   include "unusual_ene_ub6250.h"
0048     { }     /* Terminating entry */
0049 };
0050 MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
0051 
0052 #undef UNUSUAL_DEV
0053 
0054 /*
0055  * The flags table
0056  */
0057 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
0058             vendor_name, product_name, use_protocol, use_transport, \
0059             init_function, Flags) \
0060 { \
0061     .vendorName = vendor_name,  \
0062     .productName = product_name,    \
0063     .useProtocol = use_protocol,    \
0064     .useTransport = use_transport,  \
0065     .initFunction = init_function,  \
0066 }
0067 
0068 static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
0069 #   include "unusual_ene_ub6250.h"
0070     { }     /* Terminating entry */
0071 };
0072 
0073 #undef UNUSUAL_DEV
0074 
0075 
0076 
0077 /* ENE bin code len */
0078 #define ENE_BIN_CODE_LEN    0x800
0079 /* EnE HW Register */
0080 #define REG_CARD_STATUS     0xFF83
0081 #define REG_HW_TRAP1        0xFF89
0082 
0083 /* SRB Status */
0084 #define SS_SUCCESS      0x000000    /* No Sense */
0085 #define SS_NOT_READY        0x023A00    /* Medium not present */
0086 #define SS_MEDIUM_ERR       0x031100    /* Unrecovered read error */
0087 #define SS_HW_ERR       0x040800    /* Communication failure */
0088 #define SS_ILLEGAL_REQUEST  0x052000    /* Invalid command */
0089 #define SS_UNIT_ATTENTION   0x062900    /* Reset occurred */
0090 
0091 /* ENE Load FW Pattern */
0092 #define SD_INIT1_PATTERN   1
0093 #define SD_INIT2_PATTERN   2
0094 #define SD_RW_PATTERN      3
0095 #define MS_INIT_PATTERN    4
0096 #define MSP_RW_PATTERN     5
0097 #define MS_RW_PATTERN      6
0098 #define SM_INIT_PATTERN    7
0099 #define SM_RW_PATTERN      8
0100 
0101 #define FDIR_WRITE         0
0102 #define FDIR_READ          1
0103 
0104 /* For MS Card */
0105 
0106 /* Status Register 1 */
0107 #define MS_REG_ST1_MB           0x80    /* media busy */
0108 #define MS_REG_ST1_FB1          0x40    /* flush busy 1 */
0109 #define MS_REG_ST1_DTER         0x20    /* error on data(corrected) */
0110 #define MS_REG_ST1_UCDT         0x10    /* unable to correct data */
0111 #define MS_REG_ST1_EXER         0x08    /* error on extra(corrected) */
0112 #define MS_REG_ST1_UCEX         0x04    /* unable to correct extra */
0113 #define MS_REG_ST1_FGER         0x02    /* error on overwrite flag(corrected) */
0114 #define MS_REG_ST1_UCFG         0x01    /* unable to correct overwrite flag */
0115 #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)
0116 
0117 /* Overwrite Area */
0118 #define MS_REG_OVR_BKST     0x80            /* block status */
0119 #define MS_REG_OVR_BKST_OK  MS_REG_OVR_BKST     /* OK */
0120 #define MS_REG_OVR_BKST_NG  0x00            /* NG */
0121 #define MS_REG_OVR_PGST0    0x40            /* page status */
0122 #define MS_REG_OVR_PGST1    0x20
0123 #define MS_REG_OVR_PGST_MASK    (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
0124 #define MS_REG_OVR_PGST_OK  (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
0125 #define MS_REG_OVR_PGST_NG  MS_REG_OVR_PGST1                      /* NG */
0126 #define MS_REG_OVR_PGST_DATA_ERROR  0x00        /* data error */
0127 #define MS_REG_OVR_UDST         0x10        /* update status */
0128 #define MS_REG_OVR_UDST_UPDATING    0x00        /* updating */
0129 #define MS_REG_OVR_UDST_NO_UPDATE   MS_REG_OVR_UDST
0130 #define MS_REG_OVR_RESERVED 0x08
0131 #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)
0132 
0133 /* Management Flag */
0134 #define MS_REG_MNG_SCMS0    0x20    /* serial copy management system */
0135 #define MS_REG_MNG_SCMS1    0x10
0136 #define MS_REG_MNG_SCMS_MASK        (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
0137 #define MS_REG_MNG_SCMS_COPY_OK     (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
0138 #define MS_REG_MNG_SCMS_ONE_COPY    MS_REG_MNG_SCMS1
0139 #define MS_REG_MNG_SCMS_NO_COPY 0x00
0140 #define MS_REG_MNG_ATFLG    0x08    /* address transfer table flag */
0141 #define MS_REG_MNG_ATFLG_OTHER  MS_REG_MNG_ATFLG    /* other */
0142 #define MS_REG_MNG_ATFLG_ATTBL  0x00    /* address transfer table */
0143 #define MS_REG_MNG_SYSFLG   0x04    /* system flag */
0144 #define MS_REG_MNG_SYSFLG_USER  MS_REG_MNG_SYSFLG   /* user block */
0145 #define MS_REG_MNG_SYSFLG_BOOT  0x00    /* system block */
0146 #define MS_REG_MNG_RESERVED 0xc3
0147 #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)
0148 
0149 
0150 #define MS_MAX_PAGES_PER_BLOCK      32
0151 #define MS_MAX_INITIAL_ERROR_BLOCKS     10
0152 #define MS_LIB_BITS_PER_BYTE        8
0153 
0154 #define MS_SYSINF_FORMAT_FAT        1
0155 #define MS_SYSINF_USAGE_GENERAL     0
0156 
0157 #define MS_SYSINF_MSCLASS_TYPE_1    1
0158 #define MS_SYSINF_PAGE_SIZE     MS_BYTES_PER_PAGE /* fixed */
0159 
0160 #define MS_SYSINF_CARDTYPE_RDONLY   1
0161 #define MS_SYSINF_CARDTYPE_RDWR     2
0162 #define MS_SYSINF_CARDTYPE_HYBRID   3
0163 #define MS_SYSINF_SECURITY      0x01
0164 #define MS_SYSINF_SECURITY_NO_SUPPORT   MS_SYSINF_SECURITY
0165 #define MS_SYSINF_SECURITY_SUPPORT  0
0166 
0167 #define MS_SYSINF_RESERVED1     1
0168 #define MS_SYSINF_RESERVED2     1
0169 
0170 #define MS_SYSENT_TYPE_INVALID_BLOCK    0x01
0171 #define MS_SYSENT_TYPE_CIS_IDI      0x0a    /* CIS/IDI */
0172 
0173 #define SIZE_OF_KIRO        1024
0174 #define BYTE_MASK       0xff
0175 
0176 /* ms error code */
0177 #define MS_STATUS_WRITE_PROTECT 0x0106
0178 #define MS_STATUS_SUCCESS   0x0000
0179 #define MS_ERROR_FLASH_READ 0x8003
0180 #define MS_ERROR_FLASH_ERASE    0x8005
0181 #define MS_LB_ERROR     0xfff0
0182 #define MS_LB_BOOT_BLOCK    0xfff1
0183 #define MS_LB_INITIAL_ERROR 0xfff2
0184 #define MS_STATUS_SUCCESS_WITH_ECC 0xfff3
0185 #define MS_LB_ACQUIRED_ERROR    0xfff4
0186 #define MS_LB_NOT_USED_ERASED   0xfff5
0187 #define MS_NOCARD_ERROR     0xfff8
0188 #define MS_NO_MEMORY_ERROR  0xfff9
0189 #define MS_STATUS_INT_ERROR 0xfffa
0190 #define MS_STATUS_ERROR     0xfffe
0191 #define MS_LB_NOT_USED      0xffff
0192 
0193 #define MS_REG_MNG_SYSFLG   0x04    /* system flag */
0194 #define MS_REG_MNG_SYSFLG_USER  MS_REG_MNG_SYSFLG   /* user block */
0195 
0196 #define MS_BOOT_BLOCK_ID                        0x0001
0197 #define MS_BOOT_BLOCK_FORMAT_VERSION            0x0100
0198 #define MS_BOOT_BLOCK_DATA_ENTRIES              2
0199 
0200 #define MS_NUMBER_OF_SYSTEM_ENTRY           4
0201 #define MS_NUMBER_OF_BOOT_BLOCK         2
0202 #define MS_BYTES_PER_PAGE           512
0203 #define MS_LOGICAL_BLOCKS_PER_SEGMENT       496
0204 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT        494
0205 
0206 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT      0x200 /* 512 */
0207 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK     0x1ff
0208 
0209 /* overwrite area */
0210 #define MS_REG_OVR_BKST     0x80        /* block status */
0211 #define MS_REG_OVR_BKST_OK  MS_REG_OVR_BKST /* OK */
0212 #define MS_REG_OVR_BKST_NG  0x00            /* NG */
0213 
0214 /* Status Register 1 */
0215 #define MS_REG_ST1_DTER     0x20    /* error on data(corrected) */
0216 #define MS_REG_ST1_EXER     0x08    /* error on extra(corrected) */
0217 #define MS_REG_ST1_FGER     0x02    /* error on overwrite flag(corrected) */
0218 
0219 /* MemoryStick Register */
0220 /* Status Register 0 */
0221 #define MS_REG_ST0_WP       0x01    /* write protected */
0222 #define MS_REG_ST0_WP_ON    MS_REG_ST0_WP
0223 
0224 #define MS_LIB_CTRL_RDONLY      0
0225 #define MS_LIB_CTRL_WRPROTECT   1
0226 
0227 /*dphy->log table */
0228 #define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
0229 #define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
0230 
0231 #define ms_lib_ctrl_set(pdx, Flag)  ((pdx)->MS_Lib.flags |= (1 << (Flag)))
0232 #define ms_lib_ctrl_reset(pdx, Flag)    ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
0233 #define ms_lib_ctrl_check(pdx, Flag)    ((pdx)->MS_Lib.flags & (1 << (Flag)))
0234 
0235 #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))
0236 #define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
0237 #define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0))
0238 
0239 
0240 /* SD_STATUS bits */
0241 #define SD_Insert   BIT(0)
0242 #define SD_Ready    BIT(1)
0243 #define SD_MediaChange  BIT(2)
0244 #define SD_IsMMC    BIT(3)
0245 #define SD_HiCapacity   BIT(4)
0246 #define SD_HiSpeed  BIT(5)
0247 #define SD_WtP      BIT(6)
0248             /* Bit 7 reserved */
0249 
0250 /* MS_STATUS bits */
0251 #define MS_Insert   BIT(0)
0252 #define MS_Ready    BIT(1)
0253 #define MS_MediaChange  BIT(2)
0254 #define MS_IsMSPro  BIT(3)
0255 #define MS_IsMSPHG  BIT(4)
0256             /* Bit 5 reserved */
0257 #define MS_WtP      BIT(6)
0258             /* Bit 7 reserved */
0259 
0260 /* SM_STATUS bits */
0261 #define SM_Insert   BIT(0)
0262 #define SM_Ready    BIT(1)
0263 #define SM_MediaChange  BIT(2)
0264             /* Bits 3-5 reserved */
0265 #define SM_WtP      BIT(6)
0266 #define SM_IsMS     BIT(7)
0267 
0268 struct ms_bootblock_cis {
0269     u8 bCistplDEVICE[6];    /* 0 */
0270     u8 bCistplDEVICE0C[6];  /* 6 */
0271     u8 bCistplJEDECC[4];    /* 12 */
0272     u8 bCistplMANFID[6];    /* 16 */
0273     u8 bCistplVER1[32];     /* 22 */
0274     u8 bCistplFUNCID[4];    /* 54 */
0275     u8 bCistplFUNCE0[4];    /* 58 */
0276     u8 bCistplFUNCE1[5];    /* 62 */
0277     u8 bCistplCONF[7];      /* 67 */
0278     u8 bCistplCFTBLENT0[10];/* 74 */
0279     u8 bCistplCFTBLENT1[8]; /* 84 */
0280     u8 bCistplCFTBLENT2[12];/* 92 */
0281     u8 bCistplCFTBLENT3[8]; /* 104 */
0282     u8 bCistplCFTBLENT4[17];/* 112 */
0283     u8 bCistplCFTBLENT5[8]; /* 129 */
0284     u8 bCistplCFTBLENT6[17];/* 137 */
0285     u8 bCistplCFTBLENT7[8]; /* 154 */
0286     u8 bCistplNOLINK[3];    /* 162 */
0287 } ;
0288 
0289 struct ms_bootblock_idi {
0290 #define MS_IDI_GENERAL_CONF 0x848A
0291     u16 wIDIgeneralConfiguration;   /* 0 */
0292     u16 wIDInumberOfCylinder;   /* 1 */
0293     u16 wIDIreserved0;      /* 2 */
0294     u16 wIDInumberOfHead;       /* 3 */
0295     u16 wIDIbytesPerTrack;      /* 4 */
0296     u16 wIDIbytesPerSector;     /* 5 */
0297     u16 wIDIsectorsPerTrack;    /* 6 */
0298     u16 wIDItotalSectors[2];    /* 7-8  high,low */
0299     u16 wIDIreserved1[11];      /* 9-19 */
0300     u16 wIDIbufferType;     /* 20 */
0301     u16 wIDIbufferSize;     /* 21 */
0302     u16 wIDIlongCmdECC;     /* 22 */
0303     u16 wIDIfirmVersion[4];     /* 23-26 */
0304     u16 wIDImodelName[20];      /* 27-46 */
0305     u16 wIDIreserved2;      /* 47 */
0306     u16 wIDIlongWordSupported;  /* 48 */
0307     u16 wIDIdmaSupported;       /* 49 */
0308     u16 wIDIreserved3;      /* 50 */
0309     u16 wIDIpioTiming;      /* 51 */
0310     u16 wIDIdmaTiming;      /* 52 */
0311     u16 wIDItransferParameter;  /* 53 */
0312     u16 wIDIformattedCylinder;  /* 54 */
0313     u16 wIDIformattedHead;      /* 55 */
0314     u16 wIDIformattedSectorsPerTrack;/* 56 */
0315     u16 wIDIformattedTotalSectors[2];/* 57-58 */
0316     u16 wIDImultiSector;        /* 59 */
0317     u16 wIDIlbaSectors[2];      /* 60-61 */
0318     u16 wIDIsingleWordDMA;      /* 62 */
0319     u16 wIDImultiWordDMA;       /* 63 */
0320     u16 wIDIreserved4[192];     /* 64-255 */
0321 };
0322 
0323 struct ms_bootblock_sysent_rec {
0324     u32 dwStart;
0325     u32 dwSize;
0326     u8 bType;
0327     u8 bReserved[3];
0328 };
0329 
0330 struct ms_bootblock_sysent {
0331     struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
0332 };
0333 
0334 struct ms_bootblock_sysinf {
0335     u8 bMsClass;            /* must be 1 */
0336     u8 bCardType;           /* see below */
0337     u16 wBlockSize;         /* n KB */
0338     u16 wBlockNumber;       /* number of physical block */
0339     u16 wTotalBlockNumber;      /* number of logical block */
0340     u16 wPageSize;          /* must be 0x200 */
0341     u8 bExtraSize;          /* 0x10 */
0342     u8 bSecuritySupport;
0343     u8 bAssemblyDate[8];
0344     u8 bFactoryArea[4];
0345     u8 bAssemblyMakerCode;
0346     u8 bAssemblyMachineCode[3];
0347     u16 wMemoryMakerCode;
0348     u16 wMemoryDeviceCode;
0349     u16 wMemorySize;
0350     u8 bReserved1;
0351     u8 bReserved2;
0352     u8 bVCC;
0353     u8 bVPP;
0354     u16 wControllerChipNumber;
0355     u16 wControllerFunction;    /* New MS */
0356     u8 bReserved3[9];       /* New MS */
0357     u8 bParallelSupport;        /* New MS */
0358     u16 wFormatValue;       /* New MS */
0359     u8 bFormatType;
0360     u8 bUsage;
0361     u8 bDeviceType;
0362     u8 bReserved4[22];
0363     u8 bFUValue3;
0364     u8 bFUValue4;
0365     u8 bReserved5[15];
0366 };
0367 
0368 struct ms_bootblock_header {
0369     u16 wBlockID;
0370     u16 wFormatVersion;
0371     u8 bReserved1[184];
0372     u8 bNumberOfDataEntry;
0373     u8 bReserved2[179];
0374 };
0375 
0376 struct ms_bootblock_page0 {
0377     struct ms_bootblock_header header;
0378     struct ms_bootblock_sysent sysent;
0379     struct ms_bootblock_sysinf sysinf;
0380 };
0381 
0382 struct ms_bootblock_cis_idi {
0383     union {
0384         struct ms_bootblock_cis cis;
0385         u8 dmy[256];
0386     } cis;
0387 
0388     union {
0389         struct ms_bootblock_idi idi;
0390         u8 dmy[256];
0391     } idi;
0392 
0393 };
0394 
0395 /* ENE MS Lib struct */
0396 struct ms_lib_type_extdat {
0397     u8 reserved;
0398     u8 intr;
0399     u8 status0;
0400     u8 status1;
0401     u8 ovrflg;
0402     u8 mngflg;
0403     u16 logadr;
0404 };
0405 
0406 struct ms_lib_ctrl {
0407     u32 flags;
0408     u32 BytesPerSector;
0409     u32 NumberOfCylinder;
0410     u32 SectorsPerCylinder;
0411     u16 cardType;           /* R/W, RO, Hybrid */
0412     u16 blockSize;
0413     u16 PagesPerBlock;
0414     u16 NumberOfPhyBlock;
0415     u16 NumberOfLogBlock;
0416     u16 NumberOfSegment;
0417     u16 *Phy2LogMap;        /* phy2log table */
0418     u16 *Log2PhyMap;        /* log2phy table */
0419     u16 wrtblk;
0420     unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
0421     unsigned char *blkpag;
0422     struct ms_lib_type_extdat *blkext;
0423     unsigned char copybuf[512];
0424 };
0425 
0426 
0427 /* SD Block Length */
0428 /* 2^9 = 512 Bytes, The HW maximum read/write data length */
0429 #define SD_BLOCK_LEN  9
0430 
0431 struct ene_ub6250_info {
0432 
0433     /* I/O bounce buffer */
0434     u8      *bbuf;
0435 
0436     /* for 6250 code */
0437     u8      SD_Status;
0438     u8      MS_Status;
0439     u8      SM_Status;
0440 
0441     /* ----- SD Control Data ---------------- */
0442     /*SD_REGISTER SD_Regs; */
0443     u16     SD_Block_Mult;
0444     u8      SD_READ_BL_LEN;
0445     u16     SD_C_SIZE;
0446     u8      SD_C_SIZE_MULT;
0447 
0448     /* SD/MMC New spec. */
0449     u8      SD_SPEC_VER;
0450     u8      SD_CSD_VER;
0451     u8      SD20_HIGH_CAPACITY;
0452     u32     HC_C_SIZE;
0453     u8      MMC_SPEC_VER;
0454     u8      MMC_BusWidth;
0455     u8      MMC_HIGH_CAPACITY;
0456 
0457     /*----- MS Control Data ---------------- */
0458     bool        MS_SWWP;
0459     u32     MSP_TotalBlock;
0460     struct ms_lib_ctrl MS_Lib;
0461     bool        MS_IsRWPage;
0462     u16     MS_Model;
0463 
0464     /*----- SM Control Data ---------------- */
0465     u8      SM_DeviceID;
0466     u8      SM_CardID;
0467 
0468     unsigned char   *testbuf;
0469     u8      BIN_FLAG;
0470     u32     bl_num;
0471     int     SrbStatus;
0472 
0473     /*------Power Managerment ---------------*/
0474     bool        Power_IsResum;
0475 };
0476 
0477 static int ene_sd_init(struct us_data *us);
0478 static int ene_ms_init(struct us_data *us);
0479 static int ene_load_bincode(struct us_data *us, unsigned char flag);
0480 
0481 static void ene_ub6250_info_destructor(void *extra)
0482 {
0483     struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra;
0484 
0485     if (!extra)
0486         return;
0487     kfree(info->bbuf);
0488 }
0489 
0490 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
0491 {
0492     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
0493     struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
0494 
0495     int result;
0496     unsigned int residue;
0497     unsigned int cswlen = 0, partial = 0;
0498     unsigned int transfer_length = bcb->DataTransferLength;
0499 
0500     /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
0501     /* send cmd to out endpoint */
0502     result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
0503                         bcb, US_BULK_CB_WRAP_LEN, NULL);
0504     if (result != USB_STOR_XFER_GOOD) {
0505         usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
0506         return USB_STOR_TRANSPORT_ERROR;
0507     }
0508 
0509     if (buf) {
0510         unsigned int pipe = fDir;
0511 
0512         if (fDir  == FDIR_READ)
0513             pipe = us->recv_bulk_pipe;
0514         else
0515             pipe = us->send_bulk_pipe;
0516 
0517         /* Bulk */
0518         if (use_sg) {
0519             result = usb_stor_bulk_srb(us, pipe, us->srb);
0520         } else {
0521             result = usb_stor_bulk_transfer_sg(us, pipe, buf,
0522                         transfer_length, 0, &partial);
0523         }
0524         if (result != USB_STOR_XFER_GOOD) {
0525             usb_stor_dbg(us, "data transfer fail ---\n");
0526             return USB_STOR_TRANSPORT_ERROR;
0527         }
0528     }
0529 
0530     /* Get CSW for device status */
0531     result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
0532                         US_BULK_CS_WRAP_LEN, &cswlen);
0533 
0534     if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
0535         usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
0536         result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
0537                         bcs, US_BULK_CS_WRAP_LEN, &cswlen);
0538     }
0539 
0540     if (result == USB_STOR_XFER_STALLED) {
0541         /* get the status again */
0542         usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
0543         result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
0544                         bcs, US_BULK_CS_WRAP_LEN, NULL);
0545     }
0546 
0547     if (result != USB_STOR_XFER_GOOD)
0548         return USB_STOR_TRANSPORT_ERROR;
0549 
0550     /* check bulk status */
0551     residue = le32_to_cpu(bcs->Residue);
0552 
0553     /*
0554      * try to compute the actual residue, based on how much data
0555      * was really transferred and what the device tells us
0556      */
0557     if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
0558         residue = min(residue, transfer_length);
0559         if (us->srb != NULL)
0560             scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
0561                                 residue));
0562     }
0563 
0564     if (bcs->Status != US_BULK_STAT_OK)
0565         return USB_STOR_TRANSPORT_ERROR;
0566 
0567     return USB_STOR_TRANSPORT_GOOD;
0568 }
0569 
0570 static int do_scsi_request_sense(struct us_data *us, struct scsi_cmnd *srb)
0571 {
0572     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0573     unsigned char buf[18];
0574 
0575     memset(buf, 0, 18);
0576     buf[0] = 0x70;              /* Current error */
0577     buf[2] = info->SrbStatus >> 16;     /* Sense key */
0578     buf[7] = 10;                /* Additional length */
0579     buf[12] = info->SrbStatus >> 8;     /* ASC */
0580     buf[13] = info->SrbStatus;      /* ASCQ */
0581 
0582     usb_stor_set_xfer_buf(buf, sizeof(buf), srb);
0583     return USB_STOR_TRANSPORT_GOOD;
0584 }
0585 
0586 static int do_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
0587 {
0588     unsigned char data_ptr[36] = {
0589         0x00, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
0590         0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
0591         0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
0592         0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
0593 
0594     usb_stor_set_xfer_buf(data_ptr, 36, srb);
0595     return USB_STOR_TRANSPORT_GOOD;
0596 }
0597 
0598 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
0599 {
0600     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0601 
0602     if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready))
0603         return USB_STOR_TRANSPORT_GOOD;
0604     else {
0605         ene_sd_init(us);
0606         return USB_STOR_TRANSPORT_GOOD;
0607     }
0608 
0609     return USB_STOR_TRANSPORT_GOOD;
0610 }
0611 
0612 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
0613 {
0614     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0615     unsigned char mediaNoWP[12] = {
0616         0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
0617         0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
0618     unsigned char mediaWP[12]   = {
0619         0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
0620         0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
0621 
0622     if (info->SD_Status & SD_WtP)
0623         usb_stor_set_xfer_buf(mediaWP, 12, srb);
0624     else
0625         usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
0626 
0627 
0628     return USB_STOR_TRANSPORT_GOOD;
0629 }
0630 
0631 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
0632 {
0633     u32 bl_num;
0634     u32 bl_len;
0635     unsigned int offset = 0;
0636     unsigned char    buf[8];
0637     struct scatterlist *sg = NULL;
0638     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0639 
0640     usb_stor_dbg(us, "sd_scsi_read_capacity\n");
0641     if (info->SD_Status & SD_HiCapacity) {
0642         bl_len = 0x200;
0643         if (info->SD_Status & SD_IsMMC)
0644             bl_num = info->HC_C_SIZE-1;
0645         else
0646             bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
0647     } else {
0648         bl_len = 1 << (info->SD_READ_BL_LEN);
0649         bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
0650                 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
0651     }
0652     info->bl_num = bl_num;
0653     usb_stor_dbg(us, "bl_len = %x\n", bl_len);
0654     usb_stor_dbg(us, "bl_num = %x\n", bl_num);
0655 
0656     /*srb->request_bufflen = 8; */
0657     buf[0] = (bl_num >> 24) & 0xff;
0658     buf[1] = (bl_num >> 16) & 0xff;
0659     buf[2] = (bl_num >> 8) & 0xff;
0660     buf[3] = (bl_num >> 0) & 0xff;
0661     buf[4] = (bl_len >> 24) & 0xff;
0662     buf[5] = (bl_len >> 16) & 0xff;
0663     buf[6] = (bl_len >> 8) & 0xff;
0664     buf[7] = (bl_len >> 0) & 0xff;
0665 
0666     usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
0667 
0668     return USB_STOR_TRANSPORT_GOOD;
0669 }
0670 
0671 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
0672 {
0673     int result;
0674     unsigned char *cdb = srb->cmnd;
0675     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
0676     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0677 
0678     u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
0679          ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
0680     u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
0681     u32 bnByte = bn * 0x200;
0682     u32 blenByte = blen * 0x200;
0683 
0684     if (bn > info->bl_num)
0685         return USB_STOR_TRANSPORT_ERROR;
0686 
0687     result = ene_load_bincode(us, SD_RW_PATTERN);
0688     if (result != USB_STOR_XFER_GOOD) {
0689         usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
0690         return USB_STOR_TRANSPORT_ERROR;
0691     }
0692 
0693     if (info->SD_Status & SD_HiCapacity)
0694         bnByte = bn;
0695 
0696     /* set up the command wrapper */
0697     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
0698     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
0699     bcb->DataTransferLength = blenByte;
0700     bcb->Flags  = US_BULK_FLAG_IN;
0701     bcb->CDB[0] = 0xF1;
0702     bcb->CDB[5] = (unsigned char)(bnByte);
0703     bcb->CDB[4] = (unsigned char)(bnByte>>8);
0704     bcb->CDB[3] = (unsigned char)(bnByte>>16);
0705     bcb->CDB[2] = (unsigned char)(bnByte>>24);
0706 
0707     result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
0708     return result;
0709 }
0710 
0711 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
0712 {
0713     int result;
0714     unsigned char *cdb = srb->cmnd;
0715     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
0716     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0717 
0718     u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
0719          ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
0720     u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
0721     u32 bnByte = bn * 0x200;
0722     u32 blenByte = blen * 0x200;
0723 
0724     if (bn > info->bl_num)
0725         return USB_STOR_TRANSPORT_ERROR;
0726 
0727     result = ene_load_bincode(us, SD_RW_PATTERN);
0728     if (result != USB_STOR_XFER_GOOD) {
0729         usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
0730         return USB_STOR_TRANSPORT_ERROR;
0731     }
0732 
0733     if (info->SD_Status & SD_HiCapacity)
0734         bnByte = bn;
0735 
0736     /* set up the command wrapper */
0737     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
0738     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
0739     bcb->DataTransferLength = blenByte;
0740     bcb->Flags  = 0x00;
0741     bcb->CDB[0] = 0xF0;
0742     bcb->CDB[5] = (unsigned char)(bnByte);
0743     bcb->CDB[4] = (unsigned char)(bnByte>>8);
0744     bcb->CDB[3] = (unsigned char)(bnByte>>16);
0745     bcb->CDB[2] = (unsigned char)(bnByte>>24);
0746 
0747     result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
0748     return result;
0749 }
0750 
0751 /*
0752  * ENE MS Card
0753  */
0754 
0755 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
0756 {
0757     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0758 
0759     if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
0760         return (u32)-1;
0761 
0762     info->MS_Lib.Phy2LogMap[phyblk] = logblk;
0763     info->MS_Lib.Log2PhyMap[logblk] = phyblk;
0764 
0765     return 0;
0766 }
0767 
0768 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
0769 {
0770     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0771 
0772     if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
0773         return (u32)-1;
0774 
0775     info->MS_Lib.Phy2LogMap[phyblk] = mark;
0776 
0777     return 0;
0778 }
0779 
0780 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
0781 {
0782     return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
0783 }
0784 
0785 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
0786 {
0787     return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
0788 }
0789 
0790 static int ms_lib_free_logicalmap(struct us_data *us)
0791 {
0792     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0793 
0794     kfree(info->MS_Lib.Phy2LogMap);
0795     info->MS_Lib.Phy2LogMap = NULL;
0796 
0797     kfree(info->MS_Lib.Log2PhyMap);
0798     info->MS_Lib.Log2PhyMap = NULL;
0799 
0800     return 0;
0801 }
0802 
0803 static int ms_lib_alloc_logicalmap(struct us_data *us)
0804 {
0805     u32  i;
0806     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0807 
0808     info->MS_Lib.Phy2LogMap = kmalloc_array(info->MS_Lib.NumberOfPhyBlock,
0809                         sizeof(u16),
0810                         GFP_KERNEL);
0811     info->MS_Lib.Log2PhyMap = kmalloc_array(info->MS_Lib.NumberOfLogBlock,
0812                         sizeof(u16),
0813                         GFP_KERNEL);
0814 
0815     if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
0816         ms_lib_free_logicalmap(us);
0817         return (u32)-1;
0818     }
0819 
0820     for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
0821         info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
0822 
0823     for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
0824         info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
0825 
0826     return 0;
0827 }
0828 
0829 static void ms_lib_clear_writebuf(struct us_data *us)
0830 {
0831     int i;
0832     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0833 
0834     info->MS_Lib.wrtblk = (u16)-1;
0835     ms_lib_clear_pagemap(info);
0836 
0837     if (info->MS_Lib.blkpag)
0838         memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
0839 
0840     if (info->MS_Lib.blkext) {
0841         for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
0842             info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
0843             info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
0844             info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
0845             info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
0846         }
0847     }
0848 }
0849 
0850 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
0851 {
0852     u32 Ende, Count;
0853     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0854 
0855     Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
0856     for (Count = 0; PhyBlock < Ende; PhyBlock++) {
0857         switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
0858         case MS_LB_NOT_USED:
0859         case MS_LB_NOT_USED_ERASED:
0860             Count++;
0861             break;
0862         default:
0863             break;
0864         }
0865     }
0866 
0867     return Count;
0868 }
0869 
0870 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
0871         u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
0872 {
0873     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
0874     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0875     u8 *bbuf = info->bbuf;
0876     int result;
0877     u32 bn = PhyBlockAddr * 0x20 + PageNum;
0878 
0879     result = ene_load_bincode(us, MS_RW_PATTERN);
0880     if (result != USB_STOR_XFER_GOOD)
0881         return USB_STOR_TRANSPORT_ERROR;
0882 
0883     /* Read Page Data */
0884     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
0885     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
0886     bcb->DataTransferLength = 0x200;
0887     bcb->Flags      = US_BULK_FLAG_IN;
0888     bcb->CDB[0]     = 0xF1;
0889 
0890     bcb->CDB[1]     = 0x02; /* in init.c ENE_MSInit() is 0x01 */
0891 
0892     bcb->CDB[5]     = (unsigned char)(bn);
0893     bcb->CDB[4]     = (unsigned char)(bn>>8);
0894     bcb->CDB[3]     = (unsigned char)(bn>>16);
0895     bcb->CDB[2]     = (unsigned char)(bn>>24);
0896 
0897     result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
0898     if (result != USB_STOR_XFER_GOOD)
0899         return USB_STOR_TRANSPORT_ERROR;
0900 
0901 
0902     /* Read Extra Data */
0903     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
0904     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
0905     bcb->DataTransferLength = 0x4;
0906     bcb->Flags      = US_BULK_FLAG_IN;
0907     bcb->CDB[0]     = 0xF1;
0908     bcb->CDB[1]     = 0x03;
0909 
0910     bcb->CDB[5]     = (unsigned char)(PageNum);
0911     bcb->CDB[4]     = (unsigned char)(PhyBlockAddr);
0912     bcb->CDB[3]     = (unsigned char)(PhyBlockAddr>>8);
0913     bcb->CDB[2]     = (unsigned char)(PhyBlockAddr>>16);
0914     bcb->CDB[6]     = 0x01;
0915 
0916     result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
0917     if (result != USB_STOR_XFER_GOOD)
0918         return USB_STOR_TRANSPORT_ERROR;
0919 
0920     ExtraDat->reserved = 0;
0921     ExtraDat->intr     = 0x80;  /* Not yet,fireware support */
0922     ExtraDat->status0  = 0x10;  /* Not yet,fireware support */
0923 
0924     ExtraDat->status1  = 0x00;  /* Not yet,fireware support */
0925     ExtraDat->ovrflg   = bbuf[0];
0926     ExtraDat->mngflg   = bbuf[1];
0927     ExtraDat->logadr   = memstick_logaddr(bbuf[2], bbuf[3]);
0928 
0929     return USB_STOR_TRANSPORT_GOOD;
0930 }
0931 
0932 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
0933 {
0934     struct ms_bootblock_sysent *SysEntry;
0935     struct ms_bootblock_sysinf *SysInfo;
0936     u32 i, result;
0937     u8 PageNumber;
0938     u8 *PageBuffer;
0939     struct ms_lib_type_extdat ExtraData;
0940     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
0941 
0942     PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
0943     if (PageBuffer == NULL)
0944         return (u32)-1;
0945 
0946     result = (u32)-1;
0947 
0948     SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
0949 
0950     if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
0951         (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
0952         ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
0953         (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
0954         (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
0955         (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
0956         (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
0957         goto exit;
0958         /* */
0959     switch (info->MS_Lib.cardType = SysInfo->bCardType) {
0960     case MS_SYSINF_CARDTYPE_RDONLY:
0961         ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
0962         break;
0963     case MS_SYSINF_CARDTYPE_RDWR:
0964         ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
0965         break;
0966     case MS_SYSINF_CARDTYPE_HYBRID:
0967     default:
0968         goto exit;
0969     }
0970 
0971     info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
0972     info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
0973     info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
0974     info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
0975     info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
0976     info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
0977 
0978     /*Allocate to all number of logicalblock and physicalblock */
0979     if (ms_lib_alloc_logicalmap(us))
0980         goto exit;
0981 
0982     /* Mark the book block */
0983     ms_lib_set_bootblockmark(us, PhyBlock);
0984 
0985     SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
0986 
0987     for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
0988         u32  EntryOffset, EntrySize;
0989 
0990         EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
0991 
0992         if (EntryOffset == 0xffffff)
0993             continue;
0994         EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
0995 
0996         if (EntrySize == 0)
0997             continue;
0998 
0999         if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
1000             continue;
1001 
1002         if (i == 0) {
1003             u8 PrevPageNumber = 0;
1004             u16 phyblk;
1005 
1006             if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
1007                 goto exit;
1008 
1009             while (EntrySize > 0) {
1010 
1011                 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1012                 if (PageNumber != PrevPageNumber) {
1013                     switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1014                     case MS_STATUS_SUCCESS:
1015                         break;
1016                     case MS_STATUS_WRITE_PROTECT:
1017                     case MS_ERROR_FLASH_READ:
1018                     case MS_STATUS_ERROR:
1019                     default:
1020                         goto exit;
1021                     }
1022 
1023                     PrevPageNumber = PageNumber;
1024                 }
1025 
1026                 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1027                 if (phyblk < 0x0fff)
1028                     ms_lib_set_initialerrorblock(us, phyblk);
1029 
1030                 EntryOffset += 2;
1031                 EntrySize -= 2;
1032             }
1033         } else if (i == 1) {  /* CIS/IDI */
1034             struct ms_bootblock_idi *idi;
1035 
1036             if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1037                 goto exit;
1038 
1039             switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1040             case MS_STATUS_SUCCESS:
1041                 break;
1042             case MS_STATUS_WRITE_PROTECT:
1043             case MS_ERROR_FLASH_READ:
1044             case MS_STATUS_ERROR:
1045             default:
1046                 goto exit;
1047             }
1048 
1049             idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1050             if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1051                 goto exit;
1052 
1053             info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1054             if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1055                 goto exit;
1056         }
1057     } /* End for .. */
1058 
1059     result = 0;
1060 
1061 exit:
1062     if (result)
1063         ms_lib_free_logicalmap(us);
1064 
1065     kfree(PageBuffer);
1066 
1067     result = 0;
1068     return result;
1069 }
1070 
1071 static void ms_lib_free_writebuf(struct us_data *us)
1072 {
1073     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1074     info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1075 
1076     /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1077 
1078     ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1079 
1080     if (info->MS_Lib.blkpag) {
1081         kfree(info->MS_Lib.blkpag);  /* Arnold test ... */
1082         info->MS_Lib.blkpag = NULL;
1083     }
1084 
1085     if (info->MS_Lib.blkext) {
1086         kfree(info->MS_Lib.blkext);  /* Arnold test ... */
1087         info->MS_Lib.blkext = NULL;
1088     }
1089 }
1090 
1091 
1092 static void ms_lib_free_allocatedarea(struct us_data *us)
1093 {
1094     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1095 
1096     ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1097     ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1098 
1099     /* set struct us point flag to 0 */
1100     info->MS_Lib.flags = 0;
1101     info->MS_Lib.BytesPerSector = 0;
1102     info->MS_Lib.SectorsPerCylinder = 0;
1103 
1104     info->MS_Lib.cardType = 0;
1105     info->MS_Lib.blockSize = 0;
1106     info->MS_Lib.PagesPerBlock = 0;
1107 
1108     info->MS_Lib.NumberOfPhyBlock = 0;
1109     info->MS_Lib.NumberOfLogBlock = 0;
1110 }
1111 
1112 
1113 static int ms_lib_alloc_writebuf(struct us_data *us)
1114 {
1115     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1116 
1117     info->MS_Lib.wrtblk = (u16)-1;
1118 
1119     info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock,
1120                         info->MS_Lib.BytesPerSector,
1121                         GFP_KERNEL);
1122     info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock,
1123                         sizeof(struct ms_lib_type_extdat),
1124                         GFP_KERNEL);
1125 
1126     if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1127         ms_lib_free_writebuf(us);
1128         return (u32)-1;
1129     }
1130 
1131     ms_lib_clear_writebuf(us);
1132 
1133     return 0;
1134 }
1135 
1136 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1137 {
1138     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1139 
1140     if (logblk == MS_LB_NOT_USED)
1141         return 0;
1142 
1143     if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1144         (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1145         return (u32)-1;
1146 
1147     info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1148     info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1149 
1150     return 0;
1151 }
1152 
1153 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1154             u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1155 {
1156     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1157     int result;
1158 
1159     result = ene_load_bincode(us, MS_RW_PATTERN);
1160     if (result != USB_STOR_XFER_GOOD)
1161         return USB_STOR_TRANSPORT_ERROR;
1162 
1163     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1164     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1165     bcb->DataTransferLength = 0x200*len;
1166     bcb->Flags = 0x00;
1167     bcb->CDB[0] = 0xF0;
1168     bcb->CDB[1] = 0x08;
1169     bcb->CDB[4] = (unsigned char)(oldphy);
1170     bcb->CDB[3] = (unsigned char)(oldphy>>8);
1171     bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1172     bcb->CDB[7] = (unsigned char)(newphy);
1173     bcb->CDB[6] = (unsigned char)(newphy>>8);
1174     bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1175     bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1176     bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1177     bcb->CDB[10] = PageNum;
1178 
1179     result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1180     if (result != USB_STOR_XFER_GOOD)
1181         return USB_STOR_TRANSPORT_ERROR;
1182 
1183     return USB_STOR_TRANSPORT_GOOD;
1184 }
1185 
1186 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1187 {
1188     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1189     int result;
1190     u32 bn = PhyBlockAddr;
1191 
1192     result = ene_load_bincode(us, MS_RW_PATTERN);
1193     if (result != USB_STOR_XFER_GOOD)
1194         return USB_STOR_TRANSPORT_ERROR;
1195 
1196     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1197     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1198     bcb->DataTransferLength = 0x200;
1199     bcb->Flags = US_BULK_FLAG_IN;
1200     bcb->CDB[0] = 0xF2;
1201     bcb->CDB[1] = 0x06;
1202     bcb->CDB[4] = (unsigned char)(bn);
1203     bcb->CDB[3] = (unsigned char)(bn>>8);
1204     bcb->CDB[2] = (unsigned char)(bn>>16);
1205 
1206     result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1207     if (result != USB_STOR_XFER_GOOD)
1208         return USB_STOR_TRANSPORT_ERROR;
1209 
1210     return USB_STOR_TRANSPORT_GOOD;
1211 }
1212 
1213 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1214 {
1215     unsigned char *PageBuf = NULL;
1216     u16 result = MS_STATUS_SUCCESS;
1217     u16 blk, index = 0;
1218     struct ms_lib_type_extdat extdat;
1219     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1220 
1221     PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1222     if (PageBuf == NULL) {
1223         result = MS_NO_MEMORY_ERROR;
1224         goto exit;
1225     }
1226 
1227     ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1228     do {
1229         blk = be16_to_cpu(PageBuf[index]);
1230         if (blk == MS_LB_NOT_USED)
1231             break;
1232         if (blk == info->MS_Lib.Log2PhyMap[0]) {
1233             result = MS_ERROR_FLASH_READ;
1234             break;
1235         }
1236         index++;
1237     } while (1);
1238 
1239 exit:
1240     kfree(PageBuf);
1241     return result;
1242 }
1243 
1244 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1245 {
1246     u16 log;
1247     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1248 
1249     if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1250         return (u32)-1;
1251 
1252     log = info->MS_Lib.Phy2LogMap[phyblk];
1253 
1254     if (log < info->MS_Lib.NumberOfLogBlock)
1255         info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1256 
1257     if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1258         info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1259 
1260     return 0;
1261 }
1262 
1263 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1264                 u8 PageNum, u8 OverwriteFlag)
1265 {
1266     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1267     int result;
1268 
1269     result = ene_load_bincode(us, MS_RW_PATTERN);
1270     if (result != USB_STOR_XFER_GOOD)
1271         return USB_STOR_TRANSPORT_ERROR;
1272 
1273     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1274     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1275     bcb->DataTransferLength = 0x4;
1276     bcb->Flags = US_BULK_FLAG_IN;
1277     bcb->CDB[0] = 0xF2;
1278     bcb->CDB[1] = 0x05;
1279     bcb->CDB[5] = (unsigned char)(PageNum);
1280     bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1281     bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1282     bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1283     bcb->CDB[6] = OverwriteFlag;
1284     bcb->CDB[7] = 0xFF;
1285     bcb->CDB[8] = 0xFF;
1286     bcb->CDB[9] = 0xFF;
1287 
1288     result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1289     if (result != USB_STOR_XFER_GOOD)
1290         return USB_STOR_TRANSPORT_ERROR;
1291 
1292     return USB_STOR_TRANSPORT_GOOD;
1293 }
1294 
1295 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1296 {
1297     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1298 
1299     if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1300         return MS_STATUS_ERROR;
1301 
1302     ms_lib_setacquired_errorblock(us, phyblk);
1303 
1304     if (ms_lib_iswritable(info))
1305         return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1306 
1307     return MS_STATUS_SUCCESS;
1308 }
1309 
1310 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1311 {
1312     u16 log;
1313     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1314 
1315     if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1316         return MS_STATUS_ERROR;
1317 
1318     log = info->MS_Lib.Phy2LogMap[phyblk];
1319 
1320     if (log < info->MS_Lib.NumberOfLogBlock)
1321         info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1322 
1323     info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1324 
1325     if (ms_lib_iswritable(info)) {
1326         switch (ms_read_eraseblock(us, phyblk)) {
1327         case MS_STATUS_SUCCESS:
1328             info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1329             return MS_STATUS_SUCCESS;
1330         case MS_ERROR_FLASH_ERASE:
1331         case MS_STATUS_INT_ERROR:
1332             ms_lib_error_phyblock(us, phyblk);
1333             return MS_ERROR_FLASH_ERASE;
1334         case MS_STATUS_ERROR:
1335         default:
1336             ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1337             ms_lib_setacquired_errorblock(us, phyblk);
1338             return MS_STATUS_ERROR;
1339         }
1340     }
1341 
1342     ms_lib_setacquired_errorblock(us, phyblk);
1343 
1344     return MS_STATUS_SUCCESS;
1345 }
1346 
1347 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1348                 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1349 {
1350     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1351     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1352     u8 *bbuf = info->bbuf;
1353     int result;
1354 
1355     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1356     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1357     bcb->DataTransferLength = 0x4;
1358     bcb->Flags      = US_BULK_FLAG_IN;
1359     bcb->CDB[0]     = 0xF1;
1360     bcb->CDB[1]     = 0x03;
1361     bcb->CDB[5]     = (unsigned char)(PageNum);
1362     bcb->CDB[4]     = (unsigned char)(PhyBlock);
1363     bcb->CDB[3]     = (unsigned char)(PhyBlock>>8);
1364     bcb->CDB[2]     = (unsigned char)(PhyBlock>>16);
1365     bcb->CDB[6]     = 0x01;
1366 
1367     result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1368     if (result != USB_STOR_XFER_GOOD)
1369         return USB_STOR_TRANSPORT_ERROR;
1370 
1371     ExtraDat->reserved = 0;
1372     ExtraDat->intr     = 0x80;  /* Not yet, waiting for fireware support */
1373     ExtraDat->status0  = 0x10;  /* Not yet, waiting for fireware support */
1374     ExtraDat->status1  = 0x00;  /* Not yet, waiting for fireware support */
1375     ExtraDat->ovrflg   = bbuf[0];
1376     ExtraDat->mngflg   = bbuf[1];
1377     ExtraDat->logadr   = memstick_logaddr(bbuf[2], bbuf[3]);
1378 
1379     return USB_STOR_TRANSPORT_GOOD;
1380 }
1381 
1382 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1383 {
1384     u16 blk;
1385     struct ms_lib_type_extdat extdat; /* need check */
1386     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1387 
1388 
1389     if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1390         return MS_LB_ERROR;
1391 
1392     for (blk = phyblk + 1; blk != phyblk; blk++) {
1393         if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1394             blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1395 
1396         if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1397             return blk;
1398         } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1399             switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1400             case MS_STATUS_SUCCESS:
1401             case MS_STATUS_SUCCESS_WITH_ECC:
1402                 break;
1403             case MS_NOCARD_ERROR:
1404                 return MS_NOCARD_ERROR;
1405             case MS_STATUS_INT_ERROR:
1406                 return MS_LB_ERROR;
1407             case MS_ERROR_FLASH_READ:
1408             default:
1409                 ms_lib_setacquired_errorblock(us, blk);
1410                 continue;
1411             } /* End switch */
1412 
1413             if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1414                 ms_lib_setacquired_errorblock(us, blk);
1415                 continue;
1416             }
1417 
1418             switch (ms_lib_erase_phyblock(us, blk)) {
1419             case MS_STATUS_SUCCESS:
1420                 return blk;
1421             case MS_STATUS_ERROR:
1422                 return MS_LB_ERROR;
1423             case MS_ERROR_FLASH_ERASE:
1424             default:
1425                 ms_lib_error_phyblock(us, blk);
1426                 break;
1427             }
1428         }
1429     } /* End for */
1430 
1431     return MS_LB_ERROR;
1432 }
1433 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1434 {
1435     u16 phyblk;
1436     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1437 
1438     phyblk = ms_libconv_to_physical(info, logblk);
1439     if (phyblk >= MS_LB_ERROR) {
1440         if (logblk >= info->MS_Lib.NumberOfLogBlock)
1441             return MS_LB_ERROR;
1442 
1443         phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1444         phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1445         phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1446     }
1447 
1448     return ms_libsearch_block_from_physical(us, phyblk);
1449 }
1450 
1451 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1452 {
1453     struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1454 
1455     /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1456     if ((info->MS_Status & MS_Insert) && (info->MS_Status & MS_Ready)) {
1457         return USB_STOR_TRANSPORT_GOOD;
1458     } else {
1459         ene_ms_init(us);
1460         return USB_STOR_TRANSPORT_GOOD;
1461     }
1462 
1463     return USB_STOR_TRANSPORT_GOOD;
1464 }
1465 
1466 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1467 {
1468     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1469     unsigned char mediaNoWP[12] = {
1470         0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1471         0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1472     unsigned char mediaWP[12]   = {
1473         0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1474         0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1475 
1476     if (info->MS_Status & MS_WtP)
1477         usb_stor_set_xfer_buf(mediaWP, 12, srb);
1478     else
1479         usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1480 
1481     return USB_STOR_TRANSPORT_GOOD;
1482 }
1483 
1484 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1485 {
1486     u32   bl_num;
1487     u16    bl_len;
1488     unsigned int offset = 0;
1489     unsigned char    buf[8];
1490     struct scatterlist *sg = NULL;
1491     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1492 
1493     usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1494     bl_len = 0x200;
1495     if (info->MS_Status & MS_IsMSPro)
1496         bl_num = info->MSP_TotalBlock - 1;
1497     else
1498         bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1499 
1500     info->bl_num = bl_num;
1501     usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1502     usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1503 
1504     /*srb->request_bufflen = 8; */
1505     buf[0] = (bl_num >> 24) & 0xff;
1506     buf[1] = (bl_num >> 16) & 0xff;
1507     buf[2] = (bl_num >> 8) & 0xff;
1508     buf[3] = (bl_num >> 0) & 0xff;
1509     buf[4] = (bl_len >> 24) & 0xff;
1510     buf[5] = (bl_len >> 16) & 0xff;
1511     buf[6] = (bl_len >> 8) & 0xff;
1512     buf[7] = (bl_len >> 0) & 0xff;
1513 
1514     usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1515 
1516     return USB_STOR_TRANSPORT_GOOD;
1517 }
1518 
1519 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1520 {
1521     PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1522 
1523     if (PhyBlock) {
1524         *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1525         *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1526     } else {
1527         *LogStart = 0;
1528         *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1529     }
1530 }
1531 
1532 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1533     u8 PageNum, u8 blen, void *buf)
1534 {
1535     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1536     int     result;
1537 
1538     /* Read Extra Data */
1539     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1540     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1541     bcb->DataTransferLength = 0x4 * blen;
1542     bcb->Flags      = US_BULK_FLAG_IN;
1543     bcb->CDB[0]     = 0xF1;
1544     bcb->CDB[1]     = 0x03;
1545     bcb->CDB[5]     = (unsigned char)(PageNum);
1546     bcb->CDB[4]     = (unsigned char)(PhyBlock);
1547     bcb->CDB[3]     = (unsigned char)(PhyBlock>>8);
1548     bcb->CDB[2]     = (unsigned char)(PhyBlock>>16);
1549     bcb->CDB[6]     = blen;
1550 
1551     result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1552     if (result != USB_STOR_XFER_GOOD)
1553         return USB_STOR_TRANSPORT_ERROR;
1554 
1555     return USB_STOR_TRANSPORT_GOOD;
1556 }
1557 
1558 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1559 {
1560     u16 PhyBlock, newblk, i;
1561     u16 LogStart, LogEnde;
1562     struct ms_lib_type_extdat extdat;
1563     u32 count = 0, index = 0;
1564     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1565     u8 *bbuf = info->bbuf;
1566 
1567     for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1568         ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1569 
1570         for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1571             switch (ms_libconv_to_logical(info, PhyBlock)) {
1572             case MS_STATUS_ERROR:
1573                 continue;
1574             default:
1575                 break;
1576             }
1577 
1578             if (count == PhyBlock) {
1579                 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1580                         bbuf);
1581                 count += 0x80;
1582             }
1583             index = (PhyBlock % 0x80) * 4;
1584 
1585             extdat.ovrflg = bbuf[index];
1586             extdat.mngflg = bbuf[index+1];
1587             extdat.logadr = memstick_logaddr(bbuf[index+2],
1588                     bbuf[index+3]);
1589 
1590             if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1591                 ms_lib_setacquired_errorblock(us, PhyBlock);
1592                 continue;
1593             }
1594 
1595             if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1596                 ms_lib_erase_phyblock(us, PhyBlock);
1597                 continue;
1598             }
1599 
1600             if (extdat.logadr != MS_LB_NOT_USED) {
1601                 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1602                     ms_lib_erase_phyblock(us, PhyBlock);
1603                     continue;
1604                 }
1605 
1606                 newblk = ms_libconv_to_physical(info, extdat.logadr);
1607 
1608                 if (newblk != MS_LB_NOT_USED) {
1609                     if (extdat.logadr == 0) {
1610                         ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1611                         if (ms_lib_check_disableblock(us, btBlk1st)) {
1612                             ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1613                             continue;
1614                         }
1615                     }
1616 
1617                     ms_lib_read_extra(us, newblk, 0, &extdat);
1618                     if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1619                         ms_lib_erase_phyblock(us, PhyBlock);
1620                         continue;
1621                     } else {
1622                         ms_lib_erase_phyblock(us, newblk);
1623                     }
1624                 }
1625 
1626                 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1627             }
1628         }
1629     } /* End for ... */
1630 
1631     return MS_STATUS_SUCCESS;
1632 }
1633 
1634 
1635 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1636 {
1637     int result;
1638     unsigned char *cdb = srb->cmnd;
1639     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1640     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1641 
1642     u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1643         ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1644     u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1645     u32 blenByte = blen * 0x200;
1646 
1647     if (bn > info->bl_num)
1648         return USB_STOR_TRANSPORT_ERROR;
1649 
1650     if (info->MS_Status & MS_IsMSPro) {
1651         result = ene_load_bincode(us, MSP_RW_PATTERN);
1652         if (result != USB_STOR_XFER_GOOD) {
1653             usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1654             return USB_STOR_TRANSPORT_ERROR;
1655         }
1656 
1657         /* set up the command wrapper */
1658         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1659         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1660         bcb->DataTransferLength = blenByte;
1661         bcb->Flags  = US_BULK_FLAG_IN;
1662         bcb->CDB[0] = 0xF1;
1663         bcb->CDB[1] = 0x02;
1664         bcb->CDB[5] = (unsigned char)(bn);
1665         bcb->CDB[4] = (unsigned char)(bn>>8);
1666         bcb->CDB[3] = (unsigned char)(bn>>16);
1667         bcb->CDB[2] = (unsigned char)(bn>>24);
1668 
1669         result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1670     } else {
1671         void *buf;
1672         int offset = 0;
1673         u16 phyblk, logblk;
1674         u8 PageNum;
1675         u16 len;
1676         u32 blkno;
1677 
1678         buf = kmalloc(blenByte, GFP_KERNEL);
1679         if (buf == NULL)
1680             return USB_STOR_TRANSPORT_ERROR;
1681 
1682         result = ene_load_bincode(us, MS_RW_PATTERN);
1683         if (result != USB_STOR_XFER_GOOD) {
1684             pr_info("Load MS RW pattern Fail !!\n");
1685             result = USB_STOR_TRANSPORT_ERROR;
1686             goto exit;
1687         }
1688 
1689         logblk  = (u16)(bn / info->MS_Lib.PagesPerBlock);
1690         PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1691 
1692         while (1) {
1693             if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1694                 len = info->MS_Lib.PagesPerBlock-PageNum;
1695             else
1696                 len = blen;
1697 
1698             phyblk = ms_libconv_to_physical(info, logblk);
1699             blkno  = phyblk * 0x20 + PageNum;
1700 
1701             /* set up the command wrapper */
1702             memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1703             bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1704             bcb->DataTransferLength = 0x200 * len;
1705             bcb->Flags  = US_BULK_FLAG_IN;
1706             bcb->CDB[0] = 0xF1;
1707             bcb->CDB[1] = 0x02;
1708             bcb->CDB[5] = (unsigned char)(blkno);
1709             bcb->CDB[4] = (unsigned char)(blkno>>8);
1710             bcb->CDB[3] = (unsigned char)(blkno>>16);
1711             bcb->CDB[2] = (unsigned char)(blkno>>24);
1712 
1713             result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1714             if (result != USB_STOR_XFER_GOOD) {
1715                 pr_info("MS_SCSI_Read --- result = %x\n", result);
1716                 result = USB_STOR_TRANSPORT_ERROR;
1717                 goto exit;
1718             }
1719 
1720             blen -= len;
1721             if (blen <= 0)
1722                 break;
1723             logblk++;
1724             PageNum = 0;
1725             offset += MS_BYTES_PER_PAGE*len;
1726         }
1727         usb_stor_set_xfer_buf(buf, blenByte, srb);
1728 exit:
1729         kfree(buf);
1730     }
1731     return result;
1732 }
1733 
1734 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1735 {
1736     int result;
1737     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1738     unsigned char *cdb = srb->cmnd;
1739     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1740 
1741     u32 bn = ((cdb[2] << 24) & 0xff000000) |
1742             ((cdb[3] << 16) & 0x00ff0000) |
1743             ((cdb[4] << 8) & 0x0000ff00) |
1744             ((cdb[5] << 0) & 0x000000ff);
1745     u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1746     u32 blenByte = blen * 0x200;
1747 
1748     if (bn > info->bl_num)
1749         return USB_STOR_TRANSPORT_ERROR;
1750 
1751     if (info->MS_Status & MS_IsMSPro) {
1752         result = ene_load_bincode(us, MSP_RW_PATTERN);
1753         if (result != USB_STOR_XFER_GOOD) {
1754             pr_info("Load MSP RW pattern Fail !!\n");
1755             return USB_STOR_TRANSPORT_ERROR;
1756         }
1757 
1758         /* set up the command wrapper */
1759         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1760         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1761         bcb->DataTransferLength = blenByte;
1762         bcb->Flags  = 0x00;
1763         bcb->CDB[0] = 0xF0;
1764         bcb->CDB[1] = 0x04;
1765         bcb->CDB[5] = (unsigned char)(bn);
1766         bcb->CDB[4] = (unsigned char)(bn>>8);
1767         bcb->CDB[3] = (unsigned char)(bn>>16);
1768         bcb->CDB[2] = (unsigned char)(bn>>24);
1769 
1770         result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1771     } else {
1772         void *buf;
1773         int offset = 0;
1774         u16 PhyBlockAddr;
1775         u8 PageNum;
1776         u16 len, oldphy, newphy;
1777 
1778         buf = kmalloc(blenByte, GFP_KERNEL);
1779         if (buf == NULL)
1780             return USB_STOR_TRANSPORT_ERROR;
1781         usb_stor_set_xfer_buf(buf, blenByte, srb);
1782 
1783         result = ene_load_bincode(us, MS_RW_PATTERN);
1784         if (result != USB_STOR_XFER_GOOD) {
1785             pr_info("Load MS RW pattern Fail !!\n");
1786             result = USB_STOR_TRANSPORT_ERROR;
1787             goto exit;
1788         }
1789 
1790         PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1791         PageNum      = (u8)(bn % info->MS_Lib.PagesPerBlock);
1792 
1793         while (1) {
1794             if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1795                 len = info->MS_Lib.PagesPerBlock-PageNum;
1796             else
1797                 len = blen;
1798 
1799             oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1800             newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1801 
1802             result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1803 
1804             if (result != USB_STOR_XFER_GOOD) {
1805                 pr_info("MS_SCSI_Write --- result = %x\n", result);
1806                 result =  USB_STOR_TRANSPORT_ERROR;
1807                 goto exit;
1808             }
1809 
1810             info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1811             ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1812 
1813             blen -= len;
1814             if (blen <= 0)
1815                 break;
1816             PhyBlockAddr++;
1817             PageNum = 0;
1818             offset += MS_BYTES_PER_PAGE*len;
1819         }
1820 exit:
1821         kfree(buf);
1822     }
1823     return result;
1824 }
1825 
1826 /*
1827  * ENE MS Card
1828  */
1829 
1830 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1831 {
1832     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1833     int result;
1834 
1835     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1836     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1837     bcb->DataTransferLength = 0x01;
1838     bcb->Flags          = US_BULK_FLAG_IN;
1839     bcb->CDB[0]         = 0xED;
1840     bcb->CDB[2]         = (unsigned char)(index>>8);
1841     bcb->CDB[3]         = (unsigned char)index;
1842 
1843     result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1844     return result;
1845 }
1846 
1847 static int ene_get_card_status(struct us_data *us, u8 *buf)
1848 {
1849     u16 tmpreg;
1850     u32 reg4b;
1851     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1852 
1853     /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1854     reg4b = *(u32 *)&buf[0x18];
1855     info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1856 
1857     tmpreg = (u16) reg4b;
1858     reg4b = *(u32 *)(&buf[0x14]);
1859     if ((info->SD_Status & SD_HiCapacity) && !(info->SD_Status & SD_IsMMC))
1860         info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1861 
1862     info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1863     info->SD_C_SIZE_MULT = (u8)(reg4b >> 7)  & 0x07;
1864     if ((info->SD_Status & SD_HiCapacity) && (info->SD_Status & SD_IsMMC))
1865         info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1866 
1867     if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1868         info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1869         info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1870     } else {
1871         info->SD_Block_Mult = 1;
1872     }
1873 
1874     return USB_STOR_TRANSPORT_GOOD;
1875 }
1876 
1877 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1878 {
1879     int err;
1880     char *fw_name = NULL;
1881     unsigned char *buf = NULL;
1882     const struct firmware *sd_fw = NULL;
1883     int result = USB_STOR_TRANSPORT_ERROR;
1884     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1885     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1886 
1887     if (info->BIN_FLAG == flag)
1888         return USB_STOR_TRANSPORT_GOOD;
1889 
1890     switch (flag) {
1891     /* For SD */
1892     case SD_INIT1_PATTERN:
1893         usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1894         fw_name = SD_INIT1_FIRMWARE;
1895         break;
1896     case SD_INIT2_PATTERN:
1897         usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1898         fw_name = SD_INIT2_FIRMWARE;
1899         break;
1900     case SD_RW_PATTERN:
1901         usb_stor_dbg(us, "SD_RW_PATTERN\n");
1902         fw_name = SD_RW_FIRMWARE;
1903         break;
1904     /* For MS */
1905     case MS_INIT_PATTERN:
1906         usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1907         fw_name = MS_INIT_FIRMWARE;
1908         break;
1909     case MSP_RW_PATTERN:
1910         usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1911         fw_name = MSP_RW_FIRMWARE;
1912         break;
1913     case MS_RW_PATTERN:
1914         usb_stor_dbg(us, "MS_RW_PATTERN\n");
1915         fw_name = MS_RW_FIRMWARE;
1916         break;
1917     default:
1918         usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1919         goto nofw;
1920     }
1921 
1922     err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1923     if (err) {
1924         usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1925         goto nofw;
1926     }
1927     buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1928     if (buf == NULL)
1929         goto nofw;
1930 
1931     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1932     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1933     bcb->DataTransferLength = sd_fw->size;
1934     bcb->Flags = 0x00;
1935     bcb->CDB[0] = 0xEF;
1936 
1937     result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1938     if (us->srb != NULL)
1939         scsi_set_resid(us->srb, 0);
1940     info->BIN_FLAG = flag;
1941     kfree(buf);
1942 
1943 nofw:
1944     release_firmware(sd_fw);
1945     return result;
1946 }
1947 
1948 static int ms_card_init(struct us_data *us)
1949 {
1950     u32 result;
1951     u16 TmpBlock;
1952     unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1953     struct ms_lib_type_extdat extdat;
1954     u16 btBlk1st, btBlk2nd;
1955     u32 btBlk1stErred;
1956     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1957 
1958     printk(KERN_INFO "MS_CardInit start\n");
1959 
1960     ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1961 
1962     /* get two PageBuffer */
1963     PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1964     PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1965     if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1966         result = MS_NO_MEMORY_ERROR;
1967         goto exit;
1968     }
1969 
1970     btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1971     btBlk1stErred = 0;
1972 
1973     for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1974 
1975         switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1976         case MS_STATUS_SUCCESS:
1977             break;
1978         case MS_STATUS_INT_ERROR:
1979             break;
1980         case MS_STATUS_ERROR:
1981         default:
1982             continue;
1983         }
1984 
1985         if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1986             continue;
1987 
1988         if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1989             (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1990             (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1991             (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1992                 continue;
1993 
1994         if (btBlk1st != MS_LB_NOT_USED) {
1995             btBlk2nd = TmpBlock;
1996             break;
1997         }
1998 
1999         btBlk1st = TmpBlock;
2000         memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
2001         if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2002             btBlk1stErred = 1;
2003     }
2004 
2005     if (btBlk1st == MS_LB_NOT_USED) {
2006         result = MS_STATUS_ERROR;
2007         goto exit;
2008     }
2009 
2010     /* write protect */
2011     if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2012         ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2013 
2014     result = MS_STATUS_ERROR;
2015     /* 1st Boot Block */
2016     if (btBlk1stErred == 0)
2017         result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2018         /* 1st */
2019     /* 2nd Boot Block */
2020     if (result && (btBlk2nd != MS_LB_NOT_USED))
2021         result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2022 
2023     if (result) {
2024         result = MS_STATUS_ERROR;
2025         goto exit;
2026     }
2027 
2028     for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2029         info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2030 
2031     info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2032 
2033     if (btBlk2nd != MS_LB_NOT_USED) {
2034         for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2035             info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2036 
2037         info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2038     }
2039 
2040     result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2041     if (result)
2042         goto exit;
2043 
2044     for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2045         TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2046         TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2047         if (ms_count_freeblock(us, TmpBlock) == 0) {
2048             ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2049             break;
2050         }
2051     }
2052 
2053     /* write */
2054     if (ms_lib_alloc_writebuf(us)) {
2055         result = MS_NO_MEMORY_ERROR;
2056         goto exit;
2057     }
2058 
2059     result = MS_STATUS_SUCCESS;
2060 
2061 exit:
2062     kfree(PageBuffer1);
2063     kfree(PageBuffer0);
2064 
2065     printk(KERN_INFO "MS_CardInit end\n");
2066     return result;
2067 }
2068 
2069 static int ene_ms_init(struct us_data *us)
2070 {
2071     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2072     int result;
2073     u16 MSP_BlockSize, MSP_UserAreaBlocks;
2074     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2075     u8 *bbuf = info->bbuf;
2076     unsigned int s;
2077 
2078     printk(KERN_INFO "transport --- ENE_MSInit\n");
2079 
2080     /* the same part to test ENE */
2081 
2082     result = ene_load_bincode(us, MS_INIT_PATTERN);
2083     if (result != USB_STOR_XFER_GOOD) {
2084         printk(KERN_ERR "Load MS Init Code Fail !!\n");
2085         return USB_STOR_TRANSPORT_ERROR;
2086     }
2087 
2088     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2089     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2090     bcb->DataTransferLength = 0x200;
2091     bcb->Flags      = US_BULK_FLAG_IN;
2092     bcb->CDB[0]     = 0xF1;
2093     bcb->CDB[1]     = 0x01;
2094 
2095     result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2096     if (result != USB_STOR_XFER_GOOD) {
2097         printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2098         return USB_STOR_TRANSPORT_ERROR;
2099     }
2100     /* the same part to test ENE */
2101     info->MS_Status = bbuf[0];
2102 
2103     s = info->MS_Status;
2104     if ((s & MS_Insert) && (s & MS_Ready)) {
2105         printk(KERN_INFO "Insert     = %x\n", !!(s & MS_Insert));
2106         printk(KERN_INFO "Ready      = %x\n", !!(s & MS_Ready));
2107         printk(KERN_INFO "IsMSPro    = %x\n", !!(s & MS_IsMSPro));
2108         printk(KERN_INFO "IsMSPHG    = %x\n", !!(s & MS_IsMSPHG));
2109         printk(KERN_INFO "WtP= %x\n", !!(s & MS_WtP));
2110         if (s & MS_IsMSPro) {
2111             MSP_BlockSize      = (bbuf[6] << 8) | bbuf[7];
2112             MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
2113             info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2114         } else {
2115             ms_card_init(us); /* Card is MS (to ms.c)*/
2116         }
2117         usb_stor_dbg(us, "MS Init Code OK !!\n");
2118     } else {
2119         usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
2120         return USB_STOR_TRANSPORT_ERROR;
2121     }
2122 
2123     return USB_STOR_TRANSPORT_GOOD;
2124 }
2125 
2126 static int ene_sd_init(struct us_data *us)
2127 {
2128     int result;
2129     struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2130     struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2131     u8 *bbuf = info->bbuf;
2132 
2133     usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2134     /* SD Init Part-1 */
2135     result = ene_load_bincode(us, SD_INIT1_PATTERN);
2136     if (result != USB_STOR_XFER_GOOD) {
2137         usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2138         return USB_STOR_TRANSPORT_ERROR;
2139     }
2140 
2141     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2142     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2143     bcb->Flags = US_BULK_FLAG_IN;
2144     bcb->CDB[0] = 0xF2;
2145 
2146     result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2147     if (result != USB_STOR_XFER_GOOD) {
2148         usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2149         return USB_STOR_TRANSPORT_ERROR;
2150     }
2151 
2152     /* SD Init Part-2 */
2153     result = ene_load_bincode(us, SD_INIT2_PATTERN);
2154     if (result != USB_STOR_XFER_GOOD) {
2155         usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2156         return USB_STOR_TRANSPORT_ERROR;
2157     }
2158 
2159     memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2160     bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2161     bcb->DataTransferLength = 0x200;
2162     bcb->Flags              = US_BULK_FLAG_IN;
2163     bcb->CDB[0]             = 0xF1;
2164 
2165     result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2166     if (result != USB_STOR_XFER_GOOD) {
2167         usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2168         return USB_STOR_TRANSPORT_ERROR;
2169     }
2170 
2171     info->SD_Status = bbuf[0];
2172     if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready)) {
2173         unsigned int s = info->SD_Status;
2174 
2175         ene_get_card_status(us, bbuf);
2176         usb_stor_dbg(us, "Insert     = %x\n", !!(s & SD_Insert));
2177         usb_stor_dbg(us, "Ready      = %x\n", !!(s & SD_Ready));
2178         usb_stor_dbg(us, "IsMMC      = %x\n", !!(s & SD_IsMMC));
2179         usb_stor_dbg(us, "HiCapacity = %x\n", !!(s & SD_HiCapacity));
2180         usb_stor_dbg(us, "HiSpeed    = %x\n", !!(s & SD_HiSpeed));
2181         usb_stor_dbg(us, "WtP        = %x\n", !!(s & SD_WtP));
2182     } else {
2183         usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
2184         return USB_STOR_TRANSPORT_ERROR;
2185     }
2186     return USB_STOR_TRANSPORT_GOOD;
2187 }
2188 
2189 
2190 static int ene_init(struct us_data *us)
2191 {
2192     int result;
2193     u8  misc_reg03;
2194     struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2195     u8 *bbuf = info->bbuf;
2196 
2197     result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
2198     if (result != USB_STOR_XFER_GOOD)
2199         return USB_STOR_TRANSPORT_ERROR;
2200 
2201     misc_reg03 = bbuf[0];
2202     if (misc_reg03 & 0x01) {
2203         if (!(info->SD_Status & SD_Ready)) {
2204             result = ene_sd_init(us);
2205             if (result != USB_STOR_XFER_GOOD)
2206                 return USB_STOR_TRANSPORT_ERROR;
2207         }
2208     }
2209     if (misc_reg03 & 0x02) {
2210         if (!(info->MS_Status & MS_Ready)) {
2211             result = ene_ms_init(us);
2212             if (result != USB_STOR_XFER_GOOD)
2213                 return USB_STOR_TRANSPORT_ERROR;
2214         }
2215     }
2216     return result;
2217 }
2218 
2219 /*----- sd_scsi_irp() ---------*/
2220 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2221 {
2222     int    result;
2223     struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2224 
2225     switch (srb->cmnd[0]) {
2226     case TEST_UNIT_READY:
2227         result = sd_scsi_test_unit_ready(us, srb);
2228         break; /* 0x00 */
2229     case REQUEST_SENSE:
2230         result = do_scsi_request_sense(us, srb);
2231         break; /* 0x03 */
2232     case INQUIRY:
2233         result = do_scsi_inquiry(us, srb);
2234         break; /* 0x12 */
2235     case MODE_SENSE:
2236         result = sd_scsi_mode_sense(us, srb);
2237         break; /* 0x1A */
2238     /*
2239     case START_STOP:
2240         result = SD_SCSI_Start_Stop(us, srb);
2241         break; //0x1B
2242     */
2243     case READ_CAPACITY:
2244         result = sd_scsi_read_capacity(us, srb);
2245         break; /* 0x25 */
2246     case READ_10:
2247         result = sd_scsi_read(us, srb);
2248         break; /* 0x28 */
2249     case WRITE_10:
2250         result = sd_scsi_write(us, srb);
2251         break; /* 0x2A */
2252     default:
2253         info->SrbStatus = SS_ILLEGAL_REQUEST;
2254         result = USB_STOR_TRANSPORT_FAILED;
2255         break;
2256     }
2257     if (result == USB_STOR_TRANSPORT_GOOD)
2258         info->SrbStatus = SS_SUCCESS;
2259     return result;
2260 }
2261 
2262 /*
2263  * ms_scsi_irp()
2264  */
2265 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2266 {
2267     int result;
2268     struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2269 
2270     switch (srb->cmnd[0]) {
2271     case TEST_UNIT_READY:
2272         result = ms_scsi_test_unit_ready(us, srb);
2273         break; /* 0x00 */
2274     case REQUEST_SENSE:
2275         result = do_scsi_request_sense(us, srb);
2276         break; /* 0x03 */
2277     case INQUIRY:
2278         result = do_scsi_inquiry(us, srb);
2279         break; /* 0x12 */
2280     case MODE_SENSE:
2281         result = ms_scsi_mode_sense(us, srb);
2282         break; /* 0x1A */
2283     case READ_CAPACITY:
2284         result = ms_scsi_read_capacity(us, srb);
2285         break; /* 0x25 */
2286     case READ_10:
2287         result = ms_scsi_read(us, srb);
2288         break; /* 0x28 */
2289     case WRITE_10:
2290         result = ms_scsi_write(us, srb);
2291         break;  /* 0x2A */
2292     default:
2293         info->SrbStatus = SS_ILLEGAL_REQUEST;
2294         result = USB_STOR_TRANSPORT_FAILED;
2295         break;
2296     }
2297     if (result == USB_STOR_TRANSPORT_GOOD)
2298         info->SrbStatus = SS_SUCCESS;
2299     return result;
2300 }
2301 
2302 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2303 {
2304     int result = USB_STOR_XFER_GOOD;
2305     struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2306 
2307     /*US_DEBUG(usb_stor_show_command(us, srb)); */
2308     scsi_set_resid(srb, 0);
2309     if (unlikely(!(info->SD_Status & SD_Ready) || (info->MS_Status & MS_Ready)))
2310         result = ene_init(us);
2311     if (result == USB_STOR_XFER_GOOD) {
2312         result = USB_STOR_TRANSPORT_ERROR;
2313         if (info->SD_Status & SD_Ready)
2314             result = sd_scsi_irp(us, srb);
2315 
2316         if (info->MS_Status & MS_Ready)
2317             result = ms_scsi_irp(us, srb);
2318     }
2319     return result;
2320 }
2321 
2322 static struct scsi_host_template ene_ub6250_host_template;
2323 
2324 static int ene_ub6250_probe(struct usb_interface *intf,
2325              const struct usb_device_id *id)
2326 {
2327     int result;
2328     u8  misc_reg03;
2329     struct us_data *us;
2330     struct ene_ub6250_info *info;
2331 
2332     result = usb_stor_probe1(&us, intf, id,
2333            (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2334            &ene_ub6250_host_template);
2335     if (result)
2336         return result;
2337 
2338     /* FIXME: where should the code alloc extra buf ? */
2339     us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2340     if (!us->extra)
2341         return -ENOMEM;
2342     us->extra_destructor = ene_ub6250_info_destructor;
2343 
2344     info = (struct ene_ub6250_info *)(us->extra);
2345     info->bbuf = kmalloc(512, GFP_KERNEL);
2346     if (!info->bbuf) {
2347         kfree(us->extra);
2348         return -ENOMEM;
2349     }
2350 
2351     us->transport_name = "ene_ub6250";
2352     us->transport = ene_transport;
2353     us->max_lun = 0;
2354 
2355     result = usb_stor_probe2(us);
2356     if (result)
2357         return result;
2358 
2359     /* probe card type */
2360     result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2361     if (result != USB_STOR_XFER_GOOD) {
2362         usb_stor_disconnect(intf);
2363         return USB_STOR_TRANSPORT_ERROR;
2364     }
2365 
2366     misc_reg03 = info->bbuf[0];
2367     if (!(misc_reg03 & 0x01)) {
2368         pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2369             "It does not support SM cards.\n");
2370     }
2371 
2372     return result;
2373 }
2374 
2375 
2376 #ifdef CONFIG_PM
2377 
2378 static int ene_ub6250_resume(struct usb_interface *iface)
2379 {
2380     struct us_data *us = usb_get_intfdata(iface);
2381     struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2382 
2383     mutex_lock(&us->dev_mutex);
2384 
2385     if (us->suspend_resume_hook)
2386         (us->suspend_resume_hook)(us, US_RESUME);
2387 
2388     mutex_unlock(&us->dev_mutex);
2389 
2390     info->Power_IsResum = true;
2391     /* info->SD_Status &= ~SD_Ready; */
2392     info->SD_Status = 0;
2393     info->MS_Status = 0;
2394     info->SM_Status = 0;
2395 
2396     return 0;
2397 }
2398 
2399 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2400 {
2401     struct us_data *us = usb_get_intfdata(iface);
2402     struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2403 
2404     /* Report the reset to the SCSI core */
2405     usb_stor_reset_resume(iface);
2406 
2407     /*
2408      * FIXME: Notify the subdrivers that they need to reinitialize
2409      * the device
2410      */
2411     info->Power_IsResum = true;
2412     /* info->SD_Status &= ~SD_Ready; */
2413     info->SD_Status = 0;
2414     info->MS_Status = 0;
2415     info->SM_Status = 0;
2416 
2417     return 0;
2418 }
2419 
2420 #else
2421 
2422 #define ene_ub6250_resume       NULL
2423 #define ene_ub6250_reset_resume     NULL
2424 
2425 #endif
2426 
2427 static struct usb_driver ene_ub6250_driver = {
2428     .name =     DRV_NAME,
2429     .probe =    ene_ub6250_probe,
2430     .disconnect =   usb_stor_disconnect,
2431     .suspend =  usb_stor_suspend,
2432     .resume =   ene_ub6250_resume,
2433     .reset_resume = ene_ub6250_reset_resume,
2434     .pre_reset =    usb_stor_pre_reset,
2435     .post_reset =   usb_stor_post_reset,
2436     .id_table = ene_ub6250_usb_ids,
2437     .soft_unbind =  1,
2438     .no_dynamic_id = 1,
2439 };
2440 
2441 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!