?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[S390] Remove error checking from copy_oldmem_page()
[linux/fpc-iii.git] / drivers / usb / storage / ene_ub6250.c
blob4dca3ef0668c9963448289c3ab1160633865a6b9
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 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 u16 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 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;
1766 u16 PhyBlockAddr;
1767 u8 PageNum;
1768 u32 result;
1769 u16 len, oldphy, newphy;
1770
1771 buf = kmalloc(blenByte, GFP_KERNEL);
1772 if (buf == NULL)
1773 return USB_STOR_TRANSPORT_ERROR;
1774 usb_stor_set_xfer_buf(buf, blenByte, srb);
1775
1776 result = ene_load_bincode(us, MS_RW_PATTERN);
1777 if (result != USB_STOR_XFER_GOOD) {
1778 pr_info("Load MS RW pattern Fail !!\n");
1779 result = USB_STOR_TRANSPORT_ERROR;
1780 goto exit;
1781 }
1782
1783 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1784 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1785
1786 while (1) {
1787 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1788 len = info->MS_Lib.PagesPerBlock-PageNum;
1789 else
1790 len = blen;
1791
1792 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1793 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1794
1795 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1796
1797 if (result != USB_STOR_XFER_GOOD) {
1798 pr_info("MS_SCSI_Write --- result = %x\n", result);
1799 result = USB_STOR_TRANSPORT_ERROR;
1800 goto exit;
1801 }
1802
1803 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1804 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1805
1806 blen -= len;
1807 if (blen <= 0)
1808 break;
1809 PhyBlockAddr++;
1810 PageNum = 0;
1811 offset += MS_BYTES_PER_PAGE*len;
1812 }
1813 exit:
1814 kfree(buf);
1815 }
1816 return result;
1817 }
1818
1819 /*
1820 * ENE MS Card
1821 */
1822
1823 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1824 {
1825 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1826 int result;
1827
1828 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1829 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1830 bcb->DataTransferLength = 0x01;
1831 bcb->Flags = 0x80;
1832 bcb->CDB[0] = 0xED;
1833 bcb->CDB[2] = (unsigned char)(index>>8);
1834 bcb->CDB[3] = (unsigned char)index;
1835
1836 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1837 return result;
1838 }
1839
1840 static int ene_get_card_status(struct us_data *us, u8 *buf)
1841 {
1842 u16 tmpreg;
1843 u32 reg4b;
1844 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1845
1846 /*US_DEBUGP("transport --- ENE_ReadSDReg\n");*/
1847 reg4b = *(u32 *)&buf[0x18];
1848 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1849
1850 tmpreg = (u16) reg4b;
1851 reg4b = *(u32 *)(&buf[0x14]);
1852 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1853 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1854
1855 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1856 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1857 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1858 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1859
1860 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1861 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1862 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1863 } else {
1864 info->SD_Block_Mult = 1;
1865 }
1866
1867 return USB_STOR_TRANSPORT_GOOD;
1868 }
1869
1870 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1871 {
1872 int err;
1873 char *fw_name = NULL;
1874 unsigned char *buf = NULL;
1875 const struct firmware *sd_fw = NULL;
1876 int result = USB_STOR_TRANSPORT_ERROR;
1877 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1878 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1879
1880 if (info->BIN_FLAG == flag)
1881 return USB_STOR_TRANSPORT_GOOD;
1882
1883 switch (flag) {
1884 /* For SD */
1885 case SD_INIT1_PATTERN:
1886 US_DEBUGP("SD_INIT1_PATTERN\n");
1887 fw_name = "ene-ub6250/sd_init1.bin";
1888 break;
1889 case SD_INIT2_PATTERN:
1890 US_DEBUGP("SD_INIT2_PATTERN\n");
1891 fw_name = "ene-ub6250/sd_init2.bin";
1892 break;
1893 case SD_RW_PATTERN:
1894 US_DEBUGP("SD_RDWR_PATTERN\n");
1895 fw_name = "ene-ub6250/sd_rdwr.bin";
1896 break;
1897 /* For MS */
1898 case MS_INIT_PATTERN:
1899 US_DEBUGP("MS_INIT_PATTERN\n");
1900 fw_name = "ene-ub6250/ms_init.bin";
1901 break;
1902 case MSP_RW_PATTERN:
1903 US_DEBUGP("MSP_RW_PATTERN\n");
1904 fw_name = "ene-ub6250/msp_rdwr.bin";
1905 break;
1906 case MS_RW_PATTERN:
1907 US_DEBUGP("MS_RW_PATTERN\n");
1908 fw_name = "ene-ub6250/ms_rdwr.bin";
1909 break;
1910 default:
1911 US_DEBUGP("----------- Unknown PATTERN ----------\n");
1912 goto nofw;
1913 }
1914
1915 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1916 if (err) {
1917 US_DEBUGP("load firmware %s failed\n", fw_name);
1918 goto nofw;
1919 }
1920 buf = kmalloc(sd_fw->size, GFP_KERNEL);
1921 if (buf == NULL) {
1922 US_DEBUGP("Malloc memory for fireware failed!\n");
1923 goto nofw;
1924 }
1925 memcpy(buf, sd_fw->data, sd_fw->size);
1926 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1927 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1928 bcb->DataTransferLength = sd_fw->size;
1929 bcb->Flags = 0x00;
1930 bcb->CDB[0] = 0xEF;
1931
1932 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1933 info->BIN_FLAG = flag;
1934 kfree(buf);
1935
1936 nofw:
1937 if (sd_fw != NULL) {
1938 release_firmware(sd_fw);
1939 sd_fw = NULL;
1940 }
1941
1942 return result;
1943 }
1944
1945 static int ms_card_init(struct us_data *us)
1946 {
1947 u32 result;
1948 u16 TmpBlock;
1949 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1950 struct ms_lib_type_extdat extdat;
1951 u16 btBlk1st, btBlk2nd;
1952 u32 btBlk1stErred;
1953 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1954
1955 printk(KERN_INFO "MS_CardInit start\n");
1956
1957 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1958
1959 /* get two PageBuffer */
1960 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1961 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1962 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1963 result = MS_NO_MEMORY_ERROR;
1964 goto exit;
1965 }
1966
1967 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1968 btBlk1stErred = 0;
1969
1970 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1971
1972 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1973 case MS_STATUS_SUCCESS:
1974 break;
1975 case MS_STATUS_INT_ERROR:
1976 break;
1977 case MS_STATUS_ERROR:
1978 default:
1979 continue;
1980 }
1981
1982 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1983 continue;
1984
1985 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1986 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1987 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1988 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1989 continue;
1990
1991 if (btBlk1st != MS_LB_NOT_USED) {
1992 btBlk2nd = TmpBlock;
1993 break;
1994 }
1995
1996 btBlk1st = TmpBlock;
1997 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
1998 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
1999 btBlk1stErred = 1;
2000 }
2001
2002 if (btBlk1st == MS_LB_NOT_USED) {
2003 result = MS_STATUS_ERROR;
2004 goto exit;
2005 }
2006
2007 /* write protect */
2008 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2009 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2010
2011 result = MS_STATUS_ERROR;
2012 /* 1st Boot Block */
2013 if (btBlk1stErred == 0)
2014 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2015 /* 1st */
2016 /* 2nd Boot Block */
2017 if (result && (btBlk2nd != MS_LB_NOT_USED))
2018 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2019
2020 if (result) {
2021 result = MS_STATUS_ERROR;
2022 goto exit;
2023 }
2024
2025 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2026 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2027
2028 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2029
2030 if (btBlk2nd != MS_LB_NOT_USED) {
2031 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2032 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2033
2034 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2035 }
2036
2037 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2038 if (result)
2039 goto exit;
2040
2041 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2042 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2043 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2044 if (ms_count_freeblock(us, TmpBlock) == 0) {
2045 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2046 break;
2047 }
2048 }
2049
2050 /* write */
2051 if (ms_lib_alloc_writebuf(us)) {
2052 result = MS_NO_MEMORY_ERROR;
2053 goto exit;
2054 }
2055
2056 result = MS_STATUS_SUCCESS;
2057
2058 exit:
2059 kfree(PageBuffer1);
2060 kfree(PageBuffer0);
2061
2062 printk(KERN_INFO "MS_CardInit end\n");
2063 return result;
2064 }
2065
2066 static int ene_ms_init(struct us_data *us)
2067 {
2068 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2069 int result;
2070 u8 buf[0x200];
2071 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2072 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2073
2074 printk(KERN_INFO "transport --- ENE_MSInit\n");
2075
2076 /* the same part to test ENE */
2077
2078 result = ene_load_bincode(us, MS_INIT_PATTERN);
2079 if (result != USB_STOR_XFER_GOOD) {
2080 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2081 return USB_STOR_TRANSPORT_ERROR;
2082 }
2083
2084 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2085 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2086 bcb->DataTransferLength = 0x200;
2087 bcb->Flags = 0x80;
2088 bcb->CDB[0] = 0xF1;
2089 bcb->CDB[1] = 0x01;
2090
2091 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2092 if (result != USB_STOR_XFER_GOOD) {
2093 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2094 return USB_STOR_TRANSPORT_ERROR;
2095 }
2096 /* the same part to test ENE */
2097 info->MS_Status = *(struct MS_STATUS *)&buf[0];
2098
2099 if (info->MS_Status.Insert && info->MS_Status.Ready) {
2100 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert);
2101 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready);
2102 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro);
2103 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG);
2104 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2105 if (info->MS_Status.IsMSPro) {
2106 MSP_BlockSize = (buf[6] << 8) | buf[7];
2107 MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
2108 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2109 } else {
2110 ms_card_init(us); /* Card is MS (to ms.c)*/
2111 }
2112 US_DEBUGP("MS Init Code OK !!\n");
2113 } else {
2114 US_DEBUGP("MS Card Not Ready --- %x\n", buf[0]);
2115 return USB_STOR_TRANSPORT_ERROR;
2116 }
2117
2118 return USB_STOR_TRANSPORT_GOOD;
2119 }
2120
2121 static int ene_sd_init(struct us_data *us)
2122 {
2123 int result;
2124 u8 buf[0x200];
2125 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2126 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2127
2128 US_DEBUGP("transport --- ENE_SDInit\n");
2129 /* SD Init Part-1 */
2130 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2131 if (result != USB_STOR_XFER_GOOD) {
2132 US_DEBUGP("Load SD Init Code Part-1 Fail !!\n");
2133 return USB_STOR_TRANSPORT_ERROR;
2134 }
2135
2136 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2137 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2138 bcb->Flags = 0x80;
2139 bcb->CDB[0] = 0xF2;
2140
2141 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2142 if (result != USB_STOR_XFER_GOOD) {
2143 US_DEBUGP("Execution SD Init Code Fail !!\n");
2144 return USB_STOR_TRANSPORT_ERROR;
2145 }
2146
2147 /* SD Init Part-2 */
2148 result = ene_load_bincode(us, SD_INIT2_PATTERN);
2149 if (result != USB_STOR_XFER_GOOD) {
2150 US_DEBUGP("Load SD Init Code Part-2 Fail !!\n");
2151 return USB_STOR_TRANSPORT_ERROR;
2152 }
2153
2154 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2155 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2156 bcb->DataTransferLength = 0x200;
2157 bcb->Flags = 0x80;
2158 bcb->CDB[0] = 0xF1;
2159
2160 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2161 if (result != USB_STOR_XFER_GOOD) {
2162 US_DEBUGP("Execution SD Init Code Fail !!\n");
2163 return USB_STOR_TRANSPORT_ERROR;
2164 }
2165
2166 info->SD_Status = *(struct SD_STATUS *)&buf[0];
2167 if (info->SD_Status.Insert && info->SD_Status.Ready) {
2168 ene_get_card_status(us, (unsigned char *)&buf);
2169 US_DEBUGP("Insert = %x\n", info->SD_Status.Insert);
2170 US_DEBUGP("Ready = %x\n", info->SD_Status.Ready);
2171 US_DEBUGP("IsMMC = %x\n", info->SD_Status.IsMMC);
2172 US_DEBUGP("HiCapacity = %x\n", info->SD_Status.HiCapacity);
2173 US_DEBUGP("HiSpeed = %x\n", info->SD_Status.HiSpeed);
2174 US_DEBUGP("WtP = %x\n", info->SD_Status.WtP);
2175 } else {
2176 US_DEBUGP("SD Card Not Ready --- %x\n", buf[0]);
2177 return USB_STOR_TRANSPORT_ERROR;
2178 }
2179 return USB_STOR_TRANSPORT_GOOD;
2180 }
2181
2182
2183 static int ene_init(struct us_data *us)
2184 {
2185 int result;
2186 u8 misc_reg03 = 0;
2187 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2188
2189 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2190 if (result != USB_STOR_XFER_GOOD)
2191 return USB_STOR_TRANSPORT_ERROR;
2192
2193 if (misc_reg03 & 0x01) {
2194 if (!info->SD_Status.Ready) {
2195 result = ene_sd_init(us);
2196 if (result != USB_STOR_XFER_GOOD)
2197 return USB_STOR_TRANSPORT_ERROR;
2198 }
2199 }
2200 if (misc_reg03 & 0x02) {
2201 if (!info->MS_Status.Ready) {
2202 result = ene_ms_init(us);
2203 if (result != USB_STOR_XFER_GOOD)
2204 return USB_STOR_TRANSPORT_ERROR;
2205 }
2206 }
2207 return result;
2208 }
2209
2210 /*----- sd_scsi_irp() ---------*/
2211 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2212 {
2213 int result;
2214 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2215
2216 info->SrbStatus = SS_SUCCESS;
2217 switch (srb->cmnd[0]) {
2218 case TEST_UNIT_READY:
2219 result = sd_scsi_test_unit_ready(us, srb);
2220 break; /* 0x00 */
2221 case INQUIRY:
2222 result = sd_scsi_inquiry(us, srb);
2223 break; /* 0x12 */
2224 case MODE_SENSE:
2225 result = sd_scsi_mode_sense(us, srb);
2226 break; /* 0x1A */
2227 /*
2228 case START_STOP:
2229 result = SD_SCSI_Start_Stop(us, srb);
2230 break; //0x1B
2231 */
2232 case READ_CAPACITY:
2233 result = sd_scsi_read_capacity(us, srb);
2234 break; /* 0x25 */
2235 case READ_10:
2236 result = sd_scsi_read(us, srb);
2237 break; /* 0x28 */
2238 case WRITE_10:
2239 result = sd_scsi_write(us, srb);
2240 break; /* 0x2A */
2241 default:
2242 info->SrbStatus = SS_ILLEGAL_REQUEST;
2243 result = USB_STOR_TRANSPORT_FAILED;
2244 break;
2245 }
2246 return result;
2247 }
2248
2249 /*
2250 * ms_scsi_irp()
2251 */
2252 int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2253 {
2254 int result;
2255 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2256 info->SrbStatus = SS_SUCCESS;
2257 switch (srb->cmnd[0]) {
2258 case TEST_UNIT_READY:
2259 result = ms_scsi_test_unit_ready(us, srb);
2260 break; /* 0x00 */
2261 case INQUIRY:
2262 result = ms_scsi_inquiry(us, srb);
2263 break; /* 0x12 */
2264 case MODE_SENSE:
2265 result = ms_scsi_mode_sense(us, srb);
2266 break; /* 0x1A */
2267 case READ_CAPACITY:
2268 result = ms_scsi_read_capacity(us, srb);
2269 break; /* 0x25 */
2270 case READ_10:
2271 result = ms_scsi_read(us, srb);
2272 break; /* 0x28 */
2273 case WRITE_10:
2274 result = ms_scsi_write(us, srb);
2275 break; /* 0x2A */
2276 default:
2277 info->SrbStatus = SS_ILLEGAL_REQUEST;
2278 result = USB_STOR_TRANSPORT_FAILED;
2279 break;
2280 }
2281 return result;
2282 }
2283
2284 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2285 {
2286 int result = 0;
2287 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2288
2289 /*US_DEBUG(usb_stor_show_command(srb)); */
2290 scsi_set_resid(srb, 0);
2291 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) {
2292 result = ene_init(us);
2293 } else {
2294 if (info->SD_Status.Ready)
2295 result = sd_scsi_irp(us, srb);
2296
2297 if (info->MS_Status.Ready)
2298 result = ms_scsi_irp(us, srb);
2299 }
2300 return 0;
2301 }
2302
2303
2304 static int ene_ub6250_probe(struct usb_interface *intf,
2305 const struct usb_device_id *id)
2306 {
2307 int result;
2308 u8 misc_reg03 = 0;
2309 struct us_data *us;
2310
2311 result = usb_stor_probe1(&us, intf, id,
2312 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list);
2313 if (result)
2314 return result;
2315
2316 /* FIXME: where should the code alloc extra buf ? */
2317 if (!us->extra) {
2318 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2319 if (!us->extra)
2320 return -ENOMEM;
2321 us->extra_destructor = ene_ub6250_info_destructor;
2322 }
2323
2324 us->transport_name = "ene_ub6250";
2325 us->transport = ene_transport;
2326 us->max_lun = 0;
2327
2328 result = usb_stor_probe2(us);
2329 if (result)
2330 return result;
2331
2332 /* probe card type */
2333 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2334 if (result != USB_STOR_XFER_GOOD) {
2335 usb_stor_disconnect(intf);
2336 return USB_STOR_TRANSPORT_ERROR;
2337 }
2338
2339 if (!(misc_reg03 & 0x01)) {
2340 pr_info("ums_eneub6250: The driver only supports SD/MS card. "
2341 "To use SM card, please build driver/staging/keucr\n");
2342 }
2343
2344 return result;
2345 }
2346
2347
2348 #ifdef CONFIG_PM
2349
2350 static int ene_ub6250_resume(struct usb_interface *iface)
2351 {
2352 u8 tmp = 0;
2353 struct us_data *us = usb_get_intfdata(iface);
2354 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2355
2356 mutex_lock(&us->dev_mutex);
2357
2358 US_DEBUGP("%s\n", __func__);
2359 if (us->suspend_resume_hook)
2360 (us->suspend_resume_hook)(us, US_RESUME);
2361
2362 mutex_unlock(&us->dev_mutex);
2363
2364 info->Power_IsResum = true;
2365 /*info->SD_Status.Ready = 0; */
2366 info->SD_Status = *(struct SD_STATUS *)&tmp;
2367 info->MS_Status = *(struct MS_STATUS *)&tmp;
2368 info->SM_Status = *(struct SM_STATUS *)&tmp;
2369
2370 return 0;
2371 }
2372
2373 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2374 {
2375 u8 tmp = 0;
2376 struct us_data *us = usb_get_intfdata(iface);
2377 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2378 US_DEBUGP("%s\n", __func__);
2379 /* Report the reset to the SCSI core */
2380 usb_stor_reset_resume(iface);
2381
2382 /* FIXME: Notify the subdrivers that they need to reinitialize
2383 * the device */
2384 info->Power_IsResum = true;
2385 /*info->SD_Status.Ready = 0; */
2386 info->SD_Status = *(struct SD_STATUS *)&tmp;
2387 info->MS_Status = *(struct MS_STATUS *)&tmp;
2388 info->SM_Status = *(struct SM_STATUS *)&tmp;
2389
2390 return 0;
2391 }
2392
2393 #else
2394
2395 #define ene_ub6250_resume NULL
2396 #define ene_ub6250_reset_resume NULL
2397
2398 #endif
2399
2400 static struct usb_driver ene_ub6250_driver = {
2401 .name = "ums_eneub6250",
2402 .probe = ene_ub6250_probe,
2403 .disconnect = usb_stor_disconnect,
2404 .suspend = usb_stor_suspend,
2405 .resume = ene_ub6250_resume,
2406 .reset_resume = ene_ub6250_reset_resume,
2407 .pre_reset = usb_stor_pre_reset,
2408 .post_reset = usb_stor_post_reset,
2409 .id_table = ene_ub6250_usb_ids,
2410 .soft_unbind = 1,
2411 };
2412
2413 static int __init ene_ub6250_init(void)
2414 {
2415 return usb_register(&ene_ub6250_driver);
2416 }
2417
2418 static void __exit ene_ub6250_exit(void)
2419 {
2420 usb_deregister(&ene_ub6250_driver);
2421 }
2422
2423 module_init(ene_ub6250_init);
2424 module_exit(ene_ub6250_exit);
Linux with added FPC-III support