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