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