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