]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/usb/storage/ene_ub6250.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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