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