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