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