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 default:
862 break;
863 }
864 }
865
866 return Count;
867 }
868
ms_read_readpage(struct us_data * us,u32 PhyBlockAddr,u8 PageNum,u32 * PageBuf,struct ms_lib_type_extdat * ExtraDat)869 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
870 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
871 {
872 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
873 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
874 u8 *bbuf = info->bbuf;
875 int result;
876 u32 bn = PhyBlockAddr * 0x20 + PageNum;
877
878 result = ene_load_bincode(us, MS_RW_PATTERN);
879 if (result != USB_STOR_XFER_GOOD)
880 return USB_STOR_TRANSPORT_ERROR;
881
882 /* Read Page Data */
883 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
884 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
885 bcb->DataTransferLength = 0x200;
886 bcb->Flags = US_BULK_FLAG_IN;
887 bcb->CDB[0] = 0xF1;
888
889 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
890
891 bcb->CDB[5] = (unsigned char)(bn);
892 bcb->CDB[4] = (unsigned char)(bn>>8);
893 bcb->CDB[3] = (unsigned char)(bn>>16);
894 bcb->CDB[2] = (unsigned char)(bn>>24);
895
896 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
897 if (result != USB_STOR_XFER_GOOD)
898 return USB_STOR_TRANSPORT_ERROR;
899
900
901 /* Read Extra Data */
902 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
903 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
904 bcb->DataTransferLength = 0x4;
905 bcb->Flags = US_BULK_FLAG_IN;
906 bcb->CDB[0] = 0xF1;
907 bcb->CDB[1] = 0x03;
908
909 bcb->CDB[5] = (unsigned char)(PageNum);
910 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
911 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
912 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
913 bcb->CDB[6] = 0x01;
914
915 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
916 if (result != USB_STOR_XFER_GOOD)
917 return USB_STOR_TRANSPORT_ERROR;
918
919 ExtraDat->reserved = 0;
920 ExtraDat->intr = 0x80; /* Not yet,fireware support */
921 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
922
923 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
924 ExtraDat->ovrflg = bbuf[0];
925 ExtraDat->mngflg = bbuf[1];
926 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
927
928 return USB_STOR_TRANSPORT_GOOD;
929 }
930
ms_lib_process_bootblock(struct us_data * us,u16 PhyBlock,u8 * PageData)931 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
932 {
933 struct ms_bootblock_sysent *SysEntry;
934 struct ms_bootblock_sysinf *SysInfo;
935 u32 i, result;
936 u8 PageNumber;
937 u8 *PageBuffer;
938 struct ms_lib_type_extdat ExtraData;
939 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
940
941 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
942 if (PageBuffer == NULL)
943 return (u32)-1;
944
945 result = (u32)-1;
946
947 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
948
949 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
950 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
951 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
952 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
953 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
954 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
955 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
956 goto exit;
957 /* */
958 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
959 case MS_SYSINF_CARDTYPE_RDONLY:
960 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
961 break;
962 case MS_SYSINF_CARDTYPE_RDWR:
963 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
964 break;
965 case MS_SYSINF_CARDTYPE_HYBRID:
966 default:
967 goto exit;
968 }
969
970 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
971 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
972 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
973 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
974 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
975 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
976
977 /*Allocate to all number of logicalblock and physicalblock */
978 if (ms_lib_alloc_logicalmap(us))
979 goto exit;
980
981 /* Mark the book block */
982 ms_lib_set_bootblockmark(us, PhyBlock);
983
984 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
985
986 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
987 u32 EntryOffset, EntrySize;
988
989 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
990
991 if (EntryOffset == 0xffffff)
992 continue;
993 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
994
995 if (EntrySize == 0)
996 continue;
997
998 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
999 continue;
1000
1001 if (i == 0) {
1002 u8 PrevPageNumber = 0;
1003 u16 phyblk;
1004
1005 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
1006 goto exit;
1007
1008 while (EntrySize > 0) {
1009
1010 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1011 if (PageNumber != PrevPageNumber) {
1012 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1013 case MS_STATUS_SUCCESS:
1014 break;
1015 case MS_STATUS_WRITE_PROTECT:
1016 case MS_ERROR_FLASH_READ:
1017 case MS_STATUS_ERROR:
1018 default:
1019 goto exit;
1020 }
1021
1022 PrevPageNumber = PageNumber;
1023 }
1024
1025 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1026 if (phyblk < 0x0fff)
1027 ms_lib_set_initialerrorblock(us, phyblk);
1028
1029 EntryOffset += 2;
1030 EntrySize -= 2;
1031 }
1032 } else if (i == 1) { /* CIS/IDI */
1033 struct ms_bootblock_idi *idi;
1034
1035 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1036 goto exit;
1037
1038 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1039 case MS_STATUS_SUCCESS:
1040 break;
1041 case MS_STATUS_WRITE_PROTECT:
1042 case MS_ERROR_FLASH_READ:
1043 case MS_STATUS_ERROR:
1044 default:
1045 goto exit;
1046 }
1047
1048 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1049 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1050 goto exit;
1051
1052 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1053 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1054 goto exit;
1055 }
1056 } /* End for .. */
1057
1058 result = 0;
1059
1060 exit:
1061 if (result)
1062 ms_lib_free_logicalmap(us);
1063
1064 kfree(PageBuffer);
1065
1066 result = 0;
1067 return result;
1068 }
1069
ms_lib_free_writebuf(struct us_data * us)1070 static void ms_lib_free_writebuf(struct us_data *us)
1071 {
1072 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1073 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1074
1075 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1076
1077 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1078
1079 if (info->MS_Lib.blkpag) {
1080 kfree(info->MS_Lib.blkpag); /* Arnold test ... */
1081 info->MS_Lib.blkpag = NULL;
1082 }
1083
1084 if (info->MS_Lib.blkext) {
1085 kfree(info->MS_Lib.blkext); /* Arnold test ... */
1086 info->MS_Lib.blkext = NULL;
1087 }
1088 }
1089
1090
ms_lib_free_allocatedarea(struct us_data * us)1091 static void ms_lib_free_allocatedarea(struct us_data *us)
1092 {
1093 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1094
1095 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1096 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1097
1098 /* set struct us point flag to 0 */
1099 info->MS_Lib.flags = 0;
1100 info->MS_Lib.BytesPerSector = 0;
1101 info->MS_Lib.SectorsPerCylinder = 0;
1102
1103 info->MS_Lib.cardType = 0;
1104 info->MS_Lib.blockSize = 0;
1105 info->MS_Lib.PagesPerBlock = 0;
1106
1107 info->MS_Lib.NumberOfPhyBlock = 0;
1108 info->MS_Lib.NumberOfLogBlock = 0;
1109 }
1110
1111
ms_lib_alloc_writebuf(struct us_data * us)1112 static int ms_lib_alloc_writebuf(struct us_data *us)
1113 {
1114 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1115
1116 info->MS_Lib.wrtblk = (u16)-1;
1117
1118 info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock,
1119 info->MS_Lib.BytesPerSector,
1120 GFP_KERNEL);
1121 info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock,
1122 sizeof(struct ms_lib_type_extdat),
1123 GFP_KERNEL);
1124
1125 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1126 ms_lib_free_writebuf(us);
1127 return (u32)-1;
1128 }
1129
1130 ms_lib_clear_writebuf(us);
1131
1132 return 0;
1133 }
1134
ms_lib_force_setlogical_pair(struct us_data * us,u16 logblk,u16 phyblk)1135 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1136 {
1137 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1138
1139 if (logblk == MS_LB_NOT_USED)
1140 return 0;
1141
1142 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1143 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1144 return (u32)-1;
1145
1146 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1147 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1148
1149 return 0;
1150 }
1151
ms_read_copyblock(struct us_data * us,u16 oldphy,u16 newphy,u16 PhyBlockAddr,u8 PageNum,unsigned char * buf,u16 len)1152 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1153 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1154 {
1155 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1156 int result;
1157
1158 result = ene_load_bincode(us, MS_RW_PATTERN);
1159 if (result != USB_STOR_XFER_GOOD)
1160 return USB_STOR_TRANSPORT_ERROR;
1161
1162 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1163 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1164 bcb->DataTransferLength = 0x200*len;
1165 bcb->Flags = 0x00;
1166 bcb->CDB[0] = 0xF0;
1167 bcb->CDB[1] = 0x08;
1168 bcb->CDB[4] = (unsigned char)(oldphy);
1169 bcb->CDB[3] = (unsigned char)(oldphy>>8);
1170 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1171 bcb->CDB[7] = (unsigned char)(newphy);
1172 bcb->CDB[6] = (unsigned char)(newphy>>8);
1173 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1174 bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1175 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1176 bcb->CDB[10] = PageNum;
1177
1178 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1179 if (result != USB_STOR_XFER_GOOD)
1180 return USB_STOR_TRANSPORT_ERROR;
1181
1182 return USB_STOR_TRANSPORT_GOOD;
1183 }
1184
ms_read_eraseblock(struct us_data * us,u32 PhyBlockAddr)1185 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1186 {
1187 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1188 int result;
1189 u32 bn = PhyBlockAddr;
1190
1191 result = ene_load_bincode(us, MS_RW_PATTERN);
1192 if (result != USB_STOR_XFER_GOOD)
1193 return USB_STOR_TRANSPORT_ERROR;
1194
1195 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1196 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1197 bcb->DataTransferLength = 0x200;
1198 bcb->Flags = US_BULK_FLAG_IN;
1199 bcb->CDB[0] = 0xF2;
1200 bcb->CDB[1] = 0x06;
1201 bcb->CDB[4] = (unsigned char)(bn);
1202 bcb->CDB[3] = (unsigned char)(bn>>8);
1203 bcb->CDB[2] = (unsigned char)(bn>>16);
1204
1205 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1206 if (result != USB_STOR_XFER_GOOD)
1207 return USB_STOR_TRANSPORT_ERROR;
1208
1209 return USB_STOR_TRANSPORT_GOOD;
1210 }
1211
ms_lib_check_disableblock(struct us_data * us,u16 PhyBlock)1212 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1213 {
1214 unsigned char *PageBuf = NULL;
1215 u16 result = MS_STATUS_SUCCESS;
1216 u16 blk, index = 0;
1217 struct ms_lib_type_extdat extdat;
1218 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1219
1220 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1221 if (PageBuf == NULL) {
1222 result = MS_NO_MEMORY_ERROR;
1223 goto exit;
1224 }
1225
1226 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1227 do {
1228 blk = be16_to_cpu(PageBuf[index]);
1229 if (blk == MS_LB_NOT_USED)
1230 break;
1231 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1232 result = MS_ERROR_FLASH_READ;
1233 break;
1234 }
1235 index++;
1236 } while (1);
1237
1238 exit:
1239 kfree(PageBuf);
1240 return result;
1241 }
1242
ms_lib_setacquired_errorblock(struct us_data * us,u16 phyblk)1243 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1244 {
1245 u16 log;
1246 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1247
1248 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1249 return (u32)-1;
1250
1251 log = info->MS_Lib.Phy2LogMap[phyblk];
1252
1253 if (log < info->MS_Lib.NumberOfLogBlock)
1254 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1255
1256 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1257 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1258
1259 return 0;
1260 }
1261
ms_lib_overwrite_extra(struct us_data * us,u32 PhyBlockAddr,u8 PageNum,u8 OverwriteFlag)1262 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1263 u8 PageNum, u8 OverwriteFlag)
1264 {
1265 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1266 int result;
1267
1268 result = ene_load_bincode(us, MS_RW_PATTERN);
1269 if (result != USB_STOR_XFER_GOOD)
1270 return USB_STOR_TRANSPORT_ERROR;
1271
1272 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1273 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1274 bcb->DataTransferLength = 0x4;
1275 bcb->Flags = US_BULK_FLAG_IN;
1276 bcb->CDB[0] = 0xF2;
1277 bcb->CDB[1] = 0x05;
1278 bcb->CDB[5] = (unsigned char)(PageNum);
1279 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1280 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1281 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1282 bcb->CDB[6] = OverwriteFlag;
1283 bcb->CDB[7] = 0xFF;
1284 bcb->CDB[8] = 0xFF;
1285 bcb->CDB[9] = 0xFF;
1286
1287 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1288 if (result != USB_STOR_XFER_GOOD)
1289 return USB_STOR_TRANSPORT_ERROR;
1290
1291 return USB_STOR_TRANSPORT_GOOD;
1292 }
1293
ms_lib_error_phyblock(struct us_data * us,u16 phyblk)1294 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1295 {
1296 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1297
1298 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1299 return MS_STATUS_ERROR;
1300
1301 ms_lib_setacquired_errorblock(us, phyblk);
1302
1303 if (ms_lib_iswritable(info))
1304 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1305
1306 return MS_STATUS_SUCCESS;
1307 }
1308
ms_lib_erase_phyblock(struct us_data * us,u16 phyblk)1309 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1310 {
1311 u16 log;
1312 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1313
1314 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1315 return MS_STATUS_ERROR;
1316
1317 log = info->MS_Lib.Phy2LogMap[phyblk];
1318
1319 if (log < info->MS_Lib.NumberOfLogBlock)
1320 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1321
1322 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1323
1324 if (ms_lib_iswritable(info)) {
1325 switch (ms_read_eraseblock(us, phyblk)) {
1326 case MS_STATUS_SUCCESS:
1327 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1328 return MS_STATUS_SUCCESS;
1329 case MS_ERROR_FLASH_ERASE:
1330 case MS_STATUS_INT_ERROR:
1331 ms_lib_error_phyblock(us, phyblk);
1332 return MS_ERROR_FLASH_ERASE;
1333 case MS_STATUS_ERROR:
1334 default:
1335 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1336 ms_lib_setacquired_errorblock(us, phyblk);
1337 return MS_STATUS_ERROR;
1338 }
1339 }
1340
1341 ms_lib_setacquired_errorblock(us, phyblk);
1342
1343 return MS_STATUS_SUCCESS;
1344 }
1345
ms_lib_read_extra(struct us_data * us,u32 PhyBlock,u8 PageNum,struct ms_lib_type_extdat * ExtraDat)1346 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1347 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1348 {
1349 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1350 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1351 u8 *bbuf = info->bbuf;
1352 int result;
1353
1354 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1355 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1356 bcb->DataTransferLength = 0x4;
1357 bcb->Flags = US_BULK_FLAG_IN;
1358 bcb->CDB[0] = 0xF1;
1359 bcb->CDB[1] = 0x03;
1360 bcb->CDB[5] = (unsigned char)(PageNum);
1361 bcb->CDB[4] = (unsigned char)(PhyBlock);
1362 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1363 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1364 bcb->CDB[6] = 0x01;
1365
1366 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1367 if (result != USB_STOR_XFER_GOOD)
1368 return USB_STOR_TRANSPORT_ERROR;
1369
1370 ExtraDat->reserved = 0;
1371 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
1372 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
1373 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
1374 ExtraDat->ovrflg = bbuf[0];
1375 ExtraDat->mngflg = bbuf[1];
1376 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
1377
1378 return USB_STOR_TRANSPORT_GOOD;
1379 }
1380
ms_libsearch_block_from_physical(struct us_data * us,u16 phyblk)1381 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1382 {
1383 u16 blk;
1384 struct ms_lib_type_extdat extdat; /* need check */
1385 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1386
1387
1388 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1389 return MS_LB_ERROR;
1390
1391 for (blk = phyblk + 1; blk != phyblk; blk++) {
1392 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1393 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1394
1395 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1396 return blk;
1397 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1398 switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1399 case MS_STATUS_SUCCESS:
1400 case MS_STATUS_SUCCESS_WITH_ECC:
1401 break;
1402 case MS_NOCARD_ERROR:
1403 return MS_NOCARD_ERROR;
1404 case MS_STATUS_INT_ERROR:
1405 return MS_LB_ERROR;
1406 case MS_ERROR_FLASH_READ:
1407 default:
1408 ms_lib_setacquired_errorblock(us, blk);
1409 continue;
1410 } /* End switch */
1411
1412 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1413 ms_lib_setacquired_errorblock(us, blk);
1414 continue;
1415 }
1416
1417 switch (ms_lib_erase_phyblock(us, blk)) {
1418 case MS_STATUS_SUCCESS:
1419 return blk;
1420 case MS_STATUS_ERROR:
1421 return MS_LB_ERROR;
1422 case MS_ERROR_FLASH_ERASE:
1423 default:
1424 ms_lib_error_phyblock(us, blk);
1425 break;
1426 }
1427 }
1428 } /* End for */
1429
1430 return MS_LB_ERROR;
1431 }
ms_libsearch_block_from_logical(struct us_data * us,u16 logblk)1432 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1433 {
1434 u16 phyblk;
1435 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1436
1437 phyblk = ms_libconv_to_physical(info, logblk);
1438 if (phyblk >= MS_LB_ERROR) {
1439 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1440 return MS_LB_ERROR;
1441
1442 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1443 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1444 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1445 }
1446
1447 return ms_libsearch_block_from_physical(us, phyblk);
1448 }
1449
ms_scsi_test_unit_ready(struct us_data * us,struct scsi_cmnd * srb)1450 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1451 {
1452 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1453
1454 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1455 if ((info->MS_Status & MS_Insert) && (info->MS_Status & MS_Ready)) {
1456 return USB_STOR_TRANSPORT_GOOD;
1457 } else {
1458 ene_ms_init(us);
1459 return USB_STOR_TRANSPORT_GOOD;
1460 }
1461
1462 return USB_STOR_TRANSPORT_GOOD;
1463 }
1464
ms_scsi_mode_sense(struct us_data * us,struct scsi_cmnd * srb)1465 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1466 {
1467 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1468 unsigned char mediaNoWP[12] = {
1469 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1470 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1471 unsigned char mediaWP[12] = {
1472 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1473 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1474
1475 if (info->MS_Status & MS_WtP)
1476 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1477 else
1478 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1479
1480 return USB_STOR_TRANSPORT_GOOD;
1481 }
1482
ms_scsi_read_capacity(struct us_data * us,struct scsi_cmnd * srb)1483 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1484 {
1485 u32 bl_num;
1486 u16 bl_len;
1487 unsigned int offset = 0;
1488 unsigned char buf[8];
1489 struct scatterlist *sg = NULL;
1490 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1491
1492 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1493 bl_len = 0x200;
1494 if (info->MS_Status & MS_IsMSPro)
1495 bl_num = info->MSP_TotalBlock - 1;
1496 else
1497 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1498
1499 info->bl_num = bl_num;
1500 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1501 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1502
1503 /*srb->request_bufflen = 8; */
1504 buf[0] = (bl_num >> 24) & 0xff;
1505 buf[1] = (bl_num >> 16) & 0xff;
1506 buf[2] = (bl_num >> 8) & 0xff;
1507 buf[3] = (bl_num >> 0) & 0xff;
1508 buf[4] = (bl_len >> 24) & 0xff;
1509 buf[5] = (bl_len >> 16) & 0xff;
1510 buf[6] = (bl_len >> 8) & 0xff;
1511 buf[7] = (bl_len >> 0) & 0xff;
1512
1513 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1514
1515 return USB_STOR_TRANSPORT_GOOD;
1516 }
1517
ms_lib_phy_to_log_range(u16 PhyBlock,u16 * LogStart,u16 * LogEnde)1518 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1519 {
1520 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1521
1522 if (PhyBlock) {
1523 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1524 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1525 } else {
1526 *LogStart = 0;
1527 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1528 }
1529 }
1530
ms_lib_read_extrablock(struct us_data * us,u32 PhyBlock,u8 PageNum,u8 blen,void * buf)1531 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1532 u8 PageNum, u8 blen, void *buf)
1533 {
1534 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1535 int result;
1536
1537 /* Read Extra Data */
1538 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1539 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1540 bcb->DataTransferLength = 0x4 * blen;
1541 bcb->Flags = US_BULK_FLAG_IN;
1542 bcb->CDB[0] = 0xF1;
1543 bcb->CDB[1] = 0x03;
1544 bcb->CDB[5] = (unsigned char)(PageNum);
1545 bcb->CDB[4] = (unsigned char)(PhyBlock);
1546 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1547 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1548 bcb->CDB[6] = blen;
1549
1550 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1551 if (result != USB_STOR_XFER_GOOD)
1552 return USB_STOR_TRANSPORT_ERROR;
1553
1554 return USB_STOR_TRANSPORT_GOOD;
1555 }
1556
ms_lib_scan_logicalblocknumber(struct us_data * us,u16 btBlk1st)1557 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1558 {
1559 u16 PhyBlock, newblk, i;
1560 u16 LogStart, LogEnde;
1561 struct ms_lib_type_extdat extdat;
1562 u32 count = 0, index = 0;
1563 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1564 u8 *bbuf = info->bbuf;
1565
1566 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1567 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1568
1569 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1570 switch (ms_libconv_to_logical(info, PhyBlock)) {
1571 case MS_STATUS_ERROR:
1572 continue;
1573 default:
1574 break;
1575 }
1576
1577 if (count == PhyBlock) {
1578 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1579 bbuf);
1580 count += 0x80;
1581 }
1582 index = (PhyBlock % 0x80) * 4;
1583
1584 extdat.ovrflg = bbuf[index];
1585 extdat.mngflg = bbuf[index+1];
1586 extdat.logadr = memstick_logaddr(bbuf[index+2],
1587 bbuf[index+3]);
1588
1589 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1590 ms_lib_setacquired_errorblock(us, PhyBlock);
1591 continue;
1592 }
1593
1594 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1595 ms_lib_erase_phyblock(us, PhyBlock);
1596 continue;
1597 }
1598
1599 if (extdat.logadr != MS_LB_NOT_USED) {
1600 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1601 ms_lib_erase_phyblock(us, PhyBlock);
1602 continue;
1603 }
1604
1605 newblk = ms_libconv_to_physical(info, extdat.logadr);
1606
1607 if (newblk != MS_LB_NOT_USED) {
1608 if (extdat.logadr == 0) {
1609 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1610 if (ms_lib_check_disableblock(us, btBlk1st)) {
1611 ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1612 continue;
1613 }
1614 }
1615
1616 ms_lib_read_extra(us, newblk, 0, &extdat);
1617 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1618 ms_lib_erase_phyblock(us, PhyBlock);
1619 continue;
1620 } else {
1621 ms_lib_erase_phyblock(us, newblk);
1622 }
1623 }
1624
1625 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1626 }
1627 }
1628 } /* End for ... */
1629
1630 return MS_STATUS_SUCCESS;
1631 }
1632
1633
ms_scsi_read(struct us_data * us,struct scsi_cmnd * srb)1634 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1635 {
1636 int result;
1637 unsigned char *cdb = srb->cmnd;
1638 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1639 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1640
1641 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1642 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1643 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1644 u32 blenByte = blen * 0x200;
1645
1646 if (bn > info->bl_num)
1647 return USB_STOR_TRANSPORT_ERROR;
1648
1649 if (info->MS_Status & MS_IsMSPro) {
1650 result = ene_load_bincode(us, MSP_RW_PATTERN);
1651 if (result != USB_STOR_XFER_GOOD) {
1652 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1653 return USB_STOR_TRANSPORT_ERROR;
1654 }
1655
1656 /* set up the command wrapper */
1657 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1658 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1659 bcb->DataTransferLength = blenByte;
1660 bcb->Flags = US_BULK_FLAG_IN;
1661 bcb->CDB[0] = 0xF1;
1662 bcb->CDB[1] = 0x02;
1663 bcb->CDB[5] = (unsigned char)(bn);
1664 bcb->CDB[4] = (unsigned char)(bn>>8);
1665 bcb->CDB[3] = (unsigned char)(bn>>16);
1666 bcb->CDB[2] = (unsigned char)(bn>>24);
1667
1668 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1669 } else {
1670 void *buf;
1671 int offset = 0;
1672 u16 phyblk, logblk;
1673 u8 PageNum;
1674 u16 len;
1675 u32 blkno;
1676
1677 buf = kmalloc(blenByte, GFP_KERNEL);
1678 if (buf == NULL)
1679 return USB_STOR_TRANSPORT_ERROR;
1680
1681 result = ene_load_bincode(us, MS_RW_PATTERN);
1682 if (result != USB_STOR_XFER_GOOD) {
1683 pr_info("Load MS RW pattern Fail !!\n");
1684 result = USB_STOR_TRANSPORT_ERROR;
1685 goto exit;
1686 }
1687
1688 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1689 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1690
1691 while (1) {
1692 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1693 len = info->MS_Lib.PagesPerBlock-PageNum;
1694 else
1695 len = blen;
1696
1697 phyblk = ms_libconv_to_physical(info, logblk);
1698 blkno = phyblk * 0x20 + PageNum;
1699
1700 /* set up the command wrapper */
1701 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1702 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1703 bcb->DataTransferLength = 0x200 * len;
1704 bcb->Flags = US_BULK_FLAG_IN;
1705 bcb->CDB[0] = 0xF1;
1706 bcb->CDB[1] = 0x02;
1707 bcb->CDB[5] = (unsigned char)(blkno);
1708 bcb->CDB[4] = (unsigned char)(blkno>>8);
1709 bcb->CDB[3] = (unsigned char)(blkno>>16);
1710 bcb->CDB[2] = (unsigned char)(blkno>>24);
1711
1712 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1713 if (result != USB_STOR_XFER_GOOD) {
1714 pr_info("MS_SCSI_Read --- result = %x\n", result);
1715 result = USB_STOR_TRANSPORT_ERROR;
1716 goto exit;
1717 }
1718
1719 blen -= len;
1720 if (blen <= 0)
1721 break;
1722 logblk++;
1723 PageNum = 0;
1724 offset += MS_BYTES_PER_PAGE*len;
1725 }
1726 usb_stor_set_xfer_buf(buf, blenByte, srb);
1727 exit:
1728 kfree(buf);
1729 }
1730 return result;
1731 }
1732
ms_scsi_write(struct us_data * us,struct scsi_cmnd * srb)1733 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1734 {
1735 int result;
1736 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1737 unsigned char *cdb = srb->cmnd;
1738 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1739
1740 u32 bn = ((cdb[2] << 24) & 0xff000000) |
1741 ((cdb[3] << 16) & 0x00ff0000) |
1742 ((cdb[4] << 8) & 0x0000ff00) |
1743 ((cdb[5] << 0) & 0x000000ff);
1744 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1745 u32 blenByte = blen * 0x200;
1746
1747 if (bn > info->bl_num)
1748 return USB_STOR_TRANSPORT_ERROR;
1749
1750 if (info->MS_Status & MS_IsMSPro) {
1751 result = ene_load_bincode(us, MSP_RW_PATTERN);
1752 if (result != USB_STOR_XFER_GOOD) {
1753 pr_info("Load MSP RW pattern Fail !!\n");
1754 return USB_STOR_TRANSPORT_ERROR;
1755 }
1756
1757 /* set up the command wrapper */
1758 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1759 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1760 bcb->DataTransferLength = blenByte;
1761 bcb->Flags = 0x00;
1762 bcb->CDB[0] = 0xF0;
1763 bcb->CDB[1] = 0x04;
1764 bcb->CDB[5] = (unsigned char)(bn);
1765 bcb->CDB[4] = (unsigned char)(bn>>8);
1766 bcb->CDB[3] = (unsigned char)(bn>>16);
1767 bcb->CDB[2] = (unsigned char)(bn>>24);
1768
1769 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1770 } else {
1771 void *buf;
1772 int offset = 0;
1773 u16 PhyBlockAddr;
1774 u8 PageNum;
1775 u16 len, oldphy, newphy;
1776
1777 buf = kmalloc(blenByte, GFP_KERNEL);
1778 if (buf == NULL)
1779 return USB_STOR_TRANSPORT_ERROR;
1780 usb_stor_set_xfer_buf(buf, blenByte, srb);
1781
1782 result = ene_load_bincode(us, MS_RW_PATTERN);
1783 if (result != USB_STOR_XFER_GOOD) {
1784 pr_info("Load MS RW pattern Fail !!\n");
1785 result = USB_STOR_TRANSPORT_ERROR;
1786 goto exit;
1787 }
1788
1789 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1790 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1791
1792 while (1) {
1793 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1794 len = info->MS_Lib.PagesPerBlock-PageNum;
1795 else
1796 len = blen;
1797
1798 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1799 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1800
1801 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1802
1803 if (result != USB_STOR_XFER_GOOD) {
1804 pr_info("MS_SCSI_Write --- result = %x\n", result);
1805 result = USB_STOR_TRANSPORT_ERROR;
1806 goto exit;
1807 }
1808
1809 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1810 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1811
1812 blen -= len;
1813 if (blen <= 0)
1814 break;
1815 PhyBlockAddr++;
1816 PageNum = 0;
1817 offset += MS_BYTES_PER_PAGE*len;
1818 }
1819 exit:
1820 kfree(buf);
1821 }
1822 return result;
1823 }
1824
1825 /*
1826 * ENE MS Card
1827 */
1828
ene_get_card_type(struct us_data * us,u16 index,void * buf)1829 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1830 {
1831 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1832 int result;
1833
1834 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1835 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1836 bcb->DataTransferLength = 0x01;
1837 bcb->Flags = US_BULK_FLAG_IN;
1838 bcb->CDB[0] = 0xED;
1839 bcb->CDB[2] = (unsigned char)(index>>8);
1840 bcb->CDB[3] = (unsigned char)index;
1841
1842 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1843 return result;
1844 }
1845
ene_get_card_status(struct us_data * us,u8 * buf)1846 static int ene_get_card_status(struct us_data *us, u8 *buf)
1847 {
1848 u16 tmpreg;
1849 u32 reg4b;
1850 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1851
1852 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1853 reg4b = *(u32 *)&buf[0x18];
1854 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1855
1856 tmpreg = (u16) reg4b;
1857 reg4b = *(u32 *)(&buf[0x14]);
1858 if ((info->SD_Status & SD_HiCapacity) && !(info->SD_Status & SD_IsMMC))
1859 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1860
1861 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1862 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1863 if ((info->SD_Status & SD_HiCapacity) && (info->SD_Status & SD_IsMMC))
1864 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1865
1866 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1867 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1868 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1869 } else {
1870 info->SD_Block_Mult = 1;
1871 }
1872
1873 return USB_STOR_TRANSPORT_GOOD;
1874 }
1875
ene_load_bincode(struct us_data * us,unsigned char flag)1876 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1877 {
1878 int err;
1879 char *fw_name = NULL;
1880 unsigned char *buf = NULL;
1881 const struct firmware *sd_fw = NULL;
1882 int result = USB_STOR_TRANSPORT_ERROR;
1883 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1884 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1885
1886 if (info->BIN_FLAG == flag)
1887 return USB_STOR_TRANSPORT_GOOD;
1888
1889 switch (flag) {
1890 /* For SD */
1891 case SD_INIT1_PATTERN:
1892 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1893 fw_name = SD_INIT1_FIRMWARE;
1894 break;
1895 case SD_INIT2_PATTERN:
1896 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1897 fw_name = SD_INIT2_FIRMWARE;
1898 break;
1899 case SD_RW_PATTERN:
1900 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1901 fw_name = SD_RW_FIRMWARE;
1902 break;
1903 /* For MS */
1904 case MS_INIT_PATTERN:
1905 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1906 fw_name = MS_INIT_FIRMWARE;
1907 break;
1908 case MSP_RW_PATTERN:
1909 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1910 fw_name = MSP_RW_FIRMWARE;
1911 break;
1912 case MS_RW_PATTERN:
1913 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1914 fw_name = MS_RW_FIRMWARE;
1915 break;
1916 default:
1917 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1918 goto nofw;
1919 }
1920
1921 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1922 if (err) {
1923 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1924 goto nofw;
1925 }
1926 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1927 if (buf == NULL)
1928 goto nofw;
1929
1930 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1931 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1932 bcb->DataTransferLength = sd_fw->size;
1933 bcb->Flags = 0x00;
1934 bcb->CDB[0] = 0xEF;
1935
1936 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1937 if (us->srb != NULL)
1938 scsi_set_resid(us->srb, 0);
1939 info->BIN_FLAG = flag;
1940 kfree(buf);
1941
1942 nofw:
1943 release_firmware(sd_fw);
1944 return result;
1945 }
1946
ms_card_init(struct us_data * us)1947 static int ms_card_init(struct us_data *us)
1948 {
1949 u32 result;
1950 u16 TmpBlock;
1951 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1952 struct ms_lib_type_extdat extdat;
1953 u16 btBlk1st, btBlk2nd;
1954 u32 btBlk1stErred;
1955 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1956
1957 printk(KERN_INFO "MS_CardInit start\n");
1958
1959 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1960
1961 /* get two PageBuffer */
1962 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1963 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1964 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1965 result = MS_NO_MEMORY_ERROR;
1966 goto exit;
1967 }
1968
1969 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1970 btBlk1stErred = 0;
1971
1972 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1973
1974 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1975 case MS_STATUS_SUCCESS:
1976 break;
1977 case MS_STATUS_INT_ERROR:
1978 break;
1979 case MS_STATUS_ERROR:
1980 default:
1981 continue;
1982 }
1983
1984 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1985 continue;
1986
1987 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1988 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1989 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1990 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1991 continue;
1992
1993 if (btBlk1st != MS_LB_NOT_USED) {
1994 btBlk2nd = TmpBlock;
1995 break;
1996 }
1997
1998 btBlk1st = TmpBlock;
1999 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
2000 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2001 btBlk1stErred = 1;
2002 }
2003
2004 if (btBlk1st == MS_LB_NOT_USED) {
2005 result = MS_STATUS_ERROR;
2006 goto exit;
2007 }
2008
2009 /* write protect */
2010 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2011 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2012
2013 result = MS_STATUS_ERROR;
2014 /* 1st Boot Block */
2015 if (btBlk1stErred == 0)
2016 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2017 /* 1st */
2018 /* 2nd Boot Block */
2019 if (result && (btBlk2nd != MS_LB_NOT_USED))
2020 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2021
2022 if (result) {
2023 result = MS_STATUS_ERROR;
2024 goto exit;
2025 }
2026
2027 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2028 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2029
2030 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2031
2032 if (btBlk2nd != MS_LB_NOT_USED) {
2033 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2034 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2035
2036 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2037 }
2038
2039 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2040 if (result)
2041 goto exit;
2042
2043 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2044 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2045 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2046 if (ms_count_freeblock(us, TmpBlock) == 0) {
2047 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2048 break;
2049 }
2050 }
2051
2052 /* write */
2053 if (ms_lib_alloc_writebuf(us)) {
2054 result = MS_NO_MEMORY_ERROR;
2055 goto exit;
2056 }
2057
2058 result = MS_STATUS_SUCCESS;
2059
2060 exit:
2061 kfree(PageBuffer1);
2062 kfree(PageBuffer0);
2063
2064 printk(KERN_INFO "MS_CardInit end\n");
2065 return result;
2066 }
2067
ene_ms_init(struct us_data * us)2068 static int ene_ms_init(struct us_data *us)
2069 {
2070 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2071 int result;
2072 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2073 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2074 u8 *bbuf = info->bbuf;
2075 unsigned int s;
2076
2077 printk(KERN_INFO "transport --- ENE_MSInit\n");
2078
2079 /* the same part to test ENE */
2080
2081 result = ene_load_bincode(us, MS_INIT_PATTERN);
2082 if (result != USB_STOR_XFER_GOOD) {
2083 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2084 return USB_STOR_TRANSPORT_ERROR;
2085 }
2086
2087 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2088 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2089 bcb->DataTransferLength = 0x200;
2090 bcb->Flags = US_BULK_FLAG_IN;
2091 bcb->CDB[0] = 0xF1;
2092 bcb->CDB[1] = 0x01;
2093
2094 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2095 if (result != USB_STOR_XFER_GOOD) {
2096 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2097 return USB_STOR_TRANSPORT_ERROR;
2098 }
2099 /* the same part to test ENE */
2100 info->MS_Status = bbuf[0];
2101
2102 s = info->MS_Status;
2103 if ((s & MS_Insert) && (s & MS_Ready)) {
2104 printk(KERN_INFO "Insert = %x\n", !!(s & MS_Insert));
2105 printk(KERN_INFO "Ready = %x\n", !!(s & MS_Ready));
2106 printk(KERN_INFO "IsMSPro = %x\n", !!(s & MS_IsMSPro));
2107 printk(KERN_INFO "IsMSPHG = %x\n", !!(s & MS_IsMSPHG));
2108 printk(KERN_INFO "WtP= %x\n", !!(s & MS_WtP));
2109 if (s & MS_IsMSPro) {
2110 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7];
2111 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
2112 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2113 } else {
2114 ms_card_init(us); /* Card is MS (to ms.c)*/
2115 }
2116 usb_stor_dbg(us, "MS Init Code OK !!\n");
2117 } else {
2118 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
2119 return USB_STOR_TRANSPORT_ERROR;
2120 }
2121
2122 return USB_STOR_TRANSPORT_GOOD;
2123 }
2124
ene_sd_init(struct us_data * us)2125 static int ene_sd_init(struct us_data *us)
2126 {
2127 int result;
2128 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2129 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2130 u8 *bbuf = info->bbuf;
2131
2132 usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2133 /* SD Init Part-1 */
2134 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2135 if (result != USB_STOR_XFER_GOOD) {
2136 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2137 return USB_STOR_TRANSPORT_ERROR;
2138 }
2139
2140 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2141 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2142 bcb->Flags = US_BULK_FLAG_IN;
2143 bcb->CDB[0] = 0xF2;
2144
2145 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2146 if (result != USB_STOR_XFER_GOOD) {
2147 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2148 return USB_STOR_TRANSPORT_ERROR;
2149 }
2150
2151 /* SD Init Part-2 */
2152 result = ene_load_bincode(us, SD_INIT2_PATTERN);
2153 if (result != USB_STOR_XFER_GOOD) {
2154 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2155 return USB_STOR_TRANSPORT_ERROR;
2156 }
2157
2158 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2159 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2160 bcb->DataTransferLength = 0x200;
2161 bcb->Flags = US_BULK_FLAG_IN;
2162 bcb->CDB[0] = 0xF1;
2163
2164 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2165 if (result != USB_STOR_XFER_GOOD) {
2166 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2167 return USB_STOR_TRANSPORT_ERROR;
2168 }
2169
2170 info->SD_Status = bbuf[0];
2171 if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready)) {
2172 unsigned int s = info->SD_Status;
2173
2174 ene_get_card_status(us, bbuf);
2175 usb_stor_dbg(us, "Insert = %x\n", !!(s & SD_Insert));
2176 usb_stor_dbg(us, "Ready = %x\n", !!(s & SD_Ready));
2177 usb_stor_dbg(us, "IsMMC = %x\n", !!(s & SD_IsMMC));
2178 usb_stor_dbg(us, "HiCapacity = %x\n", !!(s & SD_HiCapacity));
2179 usb_stor_dbg(us, "HiSpeed = %x\n", !!(s & SD_HiSpeed));
2180 usb_stor_dbg(us, "WtP = %x\n", !!(s & SD_WtP));
2181 } else {
2182 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
2183 return USB_STOR_TRANSPORT_ERROR;
2184 }
2185 return USB_STOR_TRANSPORT_GOOD;
2186 }
2187
2188
ene_init(struct us_data * us)2189 static int ene_init(struct us_data *us)
2190 {
2191 int result;
2192 u8 misc_reg03;
2193 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2194 u8 *bbuf = info->bbuf;
2195
2196 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
2197 if (result != USB_STOR_XFER_GOOD)
2198 return USB_STOR_TRANSPORT_ERROR;
2199
2200 misc_reg03 = bbuf[0];
2201 if (misc_reg03 & 0x01) {
2202 if (!(info->SD_Status & SD_Ready)) {
2203 result = ene_sd_init(us);
2204 if (result != USB_STOR_XFER_GOOD)
2205 return USB_STOR_TRANSPORT_ERROR;
2206 }
2207 }
2208 if (misc_reg03 & 0x02) {
2209 if (!(info->MS_Status & MS_Ready)) {
2210 result = ene_ms_init(us);
2211 if (result != USB_STOR_XFER_GOOD)
2212 return USB_STOR_TRANSPORT_ERROR;
2213 }
2214 }
2215 return result;
2216 }
2217
2218 /*----- sd_scsi_irp() ---------*/
sd_scsi_irp(struct us_data * us,struct scsi_cmnd * srb)2219 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2220 {
2221 int result;
2222 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2223
2224 switch (srb->cmnd[0]) {
2225 case TEST_UNIT_READY:
2226 result = sd_scsi_test_unit_ready(us, srb);
2227 break; /* 0x00 */
2228 case REQUEST_SENSE:
2229 result = do_scsi_request_sense(us, srb);
2230 break; /* 0x03 */
2231 case INQUIRY:
2232 result = do_scsi_inquiry(us, srb);
2233 break; /* 0x12 */
2234 case MODE_SENSE:
2235 result = sd_scsi_mode_sense(us, srb);
2236 break; /* 0x1A */
2237 /*
2238 case START_STOP:
2239 result = SD_SCSI_Start_Stop(us, srb);
2240 break; //0x1B
2241 */
2242 case READ_CAPACITY:
2243 result = sd_scsi_read_capacity(us, srb);
2244 break; /* 0x25 */
2245 case READ_10:
2246 result = sd_scsi_read(us, srb);
2247 break; /* 0x28 */
2248 case WRITE_10:
2249 result = sd_scsi_write(us, srb);
2250 break; /* 0x2A */
2251 default:
2252 info->SrbStatus = SS_ILLEGAL_REQUEST;
2253 result = USB_STOR_TRANSPORT_FAILED;
2254 break;
2255 }
2256 if (result == USB_STOR_TRANSPORT_GOOD)
2257 info->SrbStatus = SS_SUCCESS;
2258 return result;
2259 }
2260
2261 /*
2262 * ms_scsi_irp()
2263 */
ms_scsi_irp(struct us_data * us,struct scsi_cmnd * srb)2264 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2265 {
2266 int result;
2267 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2268
2269 switch (srb->cmnd[0]) {
2270 case TEST_UNIT_READY:
2271 result = ms_scsi_test_unit_ready(us, srb);
2272 break; /* 0x00 */
2273 case REQUEST_SENSE:
2274 result = do_scsi_request_sense(us, srb);
2275 break; /* 0x03 */
2276 case INQUIRY:
2277 result = do_scsi_inquiry(us, srb);
2278 break; /* 0x12 */
2279 case MODE_SENSE:
2280 result = ms_scsi_mode_sense(us, srb);
2281 break; /* 0x1A */
2282 case READ_CAPACITY:
2283 result = ms_scsi_read_capacity(us, srb);
2284 break; /* 0x25 */
2285 case READ_10:
2286 result = ms_scsi_read(us, srb);
2287 break; /* 0x28 */
2288 case WRITE_10:
2289 result = ms_scsi_write(us, srb);
2290 break; /* 0x2A */
2291 default:
2292 info->SrbStatus = SS_ILLEGAL_REQUEST;
2293 result = USB_STOR_TRANSPORT_FAILED;
2294 break;
2295 }
2296 if (result == USB_STOR_TRANSPORT_GOOD)
2297 info->SrbStatus = SS_SUCCESS;
2298 return result;
2299 }
2300
ene_transport(struct scsi_cmnd * srb,struct us_data * us)2301 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2302 {
2303 int result = USB_STOR_XFER_GOOD;
2304 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2305
2306 /*US_DEBUG(usb_stor_show_command(us, srb)); */
2307 scsi_set_resid(srb, 0);
2308 if (unlikely(!(info->SD_Status & SD_Ready) || (info->MS_Status & MS_Ready)))
2309 result = ene_init(us);
2310 if (result == USB_STOR_XFER_GOOD) {
2311 result = USB_STOR_TRANSPORT_ERROR;
2312 if (info->SD_Status & SD_Ready)
2313 result = sd_scsi_irp(us, srb);
2314
2315 if (info->MS_Status & MS_Ready)
2316 result = ms_scsi_irp(us, srb);
2317 }
2318 return result;
2319 }
2320
2321 static struct scsi_host_template ene_ub6250_host_template;
2322
ene_ub6250_probe(struct usb_interface * intf,const struct usb_device_id * id)2323 static int ene_ub6250_probe(struct usb_interface *intf,
2324 const struct usb_device_id *id)
2325 {
2326 int result;
2327 u8 misc_reg03;
2328 struct us_data *us;
2329 struct ene_ub6250_info *info;
2330
2331 result = usb_stor_probe1(&us, intf, id,
2332 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2333 &ene_ub6250_host_template);
2334 if (result)
2335 return result;
2336
2337 /* FIXME: where should the code alloc extra buf ? */
2338 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2339 if (!us->extra)
2340 return -ENOMEM;
2341 us->extra_destructor = ene_ub6250_info_destructor;
2342
2343 info = (struct ene_ub6250_info *)(us->extra);
2344 info->bbuf = kmalloc(512, GFP_KERNEL);
2345 if (!info->bbuf) {
2346 kfree(us->extra);
2347 return -ENOMEM;
2348 }
2349
2350 us->transport_name = "ene_ub6250";
2351 us->transport = ene_transport;
2352 us->max_lun = 0;
2353
2354 result = usb_stor_probe2(us);
2355 if (result)
2356 return result;
2357
2358 /* probe card type */
2359 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2360 if (result != USB_STOR_XFER_GOOD) {
2361 usb_stor_disconnect(intf);
2362 return USB_STOR_TRANSPORT_ERROR;
2363 }
2364
2365 misc_reg03 = info->bbuf[0];
2366 if (!(misc_reg03 & 0x01)) {
2367 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2368 "It does not support SM cards.\n");
2369 }
2370
2371 return result;
2372 }
2373
2374
2375 #ifdef CONFIG_PM
2376
ene_ub6250_resume(struct usb_interface * iface)2377 static int ene_ub6250_resume(struct usb_interface *iface)
2378 {
2379 struct us_data *us = usb_get_intfdata(iface);
2380 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2381
2382 mutex_lock(&us->dev_mutex);
2383
2384 if (us->suspend_resume_hook)
2385 (us->suspend_resume_hook)(us, US_RESUME);
2386
2387 mutex_unlock(&us->dev_mutex);
2388
2389 info->Power_IsResum = true;
2390 /* info->SD_Status &= ~SD_Ready; */
2391 info->SD_Status = 0;
2392 info->MS_Status = 0;
2393 info->SM_Status = 0;
2394
2395 return 0;
2396 }
2397
ene_ub6250_reset_resume(struct usb_interface * iface)2398 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2399 {
2400 struct us_data *us = usb_get_intfdata(iface);
2401 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2402
2403 /* Report the reset to the SCSI core */
2404 usb_stor_reset_resume(iface);
2405
2406 /*
2407 * FIXME: Notify the subdrivers that they need to reinitialize
2408 * the device
2409 */
2410 info->Power_IsResum = true;
2411 /* info->SD_Status &= ~SD_Ready; */
2412 info->SD_Status = 0;
2413 info->MS_Status = 0;
2414 info->SM_Status = 0;
2415
2416 return 0;
2417 }
2418
2419 #else
2420
2421 #define ene_ub6250_resume NULL
2422 #define ene_ub6250_reset_resume NULL
2423
2424 #endif
2425
2426 static struct usb_driver ene_ub6250_driver = {
2427 .name = DRV_NAME,
2428 .probe = ene_ub6250_probe,
2429 .disconnect = usb_stor_disconnect,
2430 .suspend = usb_stor_suspend,
2431 .resume = ene_ub6250_resume,
2432 .reset_resume = ene_ub6250_reset_resume,
2433 .pre_reset = usb_stor_pre_reset,
2434 .post_reset = usb_stor_post_reset,
2435 .id_table = ene_ub6250_usb_ids,
2436 .soft_unbind = 1,
2437 .no_dynamic_id = 1,
2438 };
2439
2440 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);
2441