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