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