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