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