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 const 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 const 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 u32 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