Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[linux/fpc-iii.git] / drivers / usb / storage / ene_ub6250.c
blob1bfc9a6cab5f7fad815b8f92feb5b50e7adceba8
1 /*
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.
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.
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.
17 #include <linux/jiffies.h>
18 #include <linux/errno.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
22 #include <scsi/scsi.h>
23 #include <scsi/scsi_cmnd.h>
25 #include <linux/firmware.h>
27 #include "usb.h"
28 #include "transport.h"
29 #include "protocol.h"
30 #include "debug.h"
32 #define SD_INIT1_FIRMWARE "ene-ub6250/sd_init1.bin"
33 #define SD_INIT2_FIRMWARE "ene-ub6250/sd_init2.bin"
34 #define SD_RW_FIRMWARE "ene-ub6250/sd_rdwr.bin"
35 #define MS_INIT_FIRMWARE "ene-ub6250/ms_init.bin"
36 #define MSP_RW_FIRMWARE "ene-ub6250/msp_rdwr.bin"
37 #define MS_RW_FIRMWARE "ene-ub6250/ms_rdwr.bin"
39 MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
40 MODULE_LICENSE("GPL");
41 MODULE_FIRMWARE(SD_INIT1_FIRMWARE);
42 MODULE_FIRMWARE(SD_INIT2_FIRMWARE);
43 MODULE_FIRMWARE(SD_RW_FIRMWARE);
44 MODULE_FIRMWARE(MS_INIT_FIRMWARE);
45 MODULE_FIRMWARE(MSP_RW_FIRMWARE);
46 MODULE_FIRMWARE(MS_RW_FIRMWARE);
49 * The table of devices
51 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
52 vendorName, productName, useProtocol, useTransport, \
53 initFunction, flags) \
54 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
55 .driver_info = (flags)}
57 static struct usb_device_id ene_ub6250_usb_ids[] = {
58 # include "unusual_ene_ub6250.h"
59 { } /* Terminating entry */
61 MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
63 #undef UNUSUAL_DEV
66 * The flags table
68 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
69 vendor_name, product_name, use_protocol, use_transport, \
70 init_function, Flags) \
71 { \
72 .vendorName = vendor_name, \
73 .productName = product_name, \
74 .useProtocol = use_protocol, \
75 .useTransport = use_transport, \
76 .initFunction = init_function, \
79 static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
80 # include "unusual_ene_ub6250.h"
81 { } /* Terminating entry */
84 #undef UNUSUAL_DEV
88 /* ENE bin code len */
89 #define ENE_BIN_CODE_LEN 0x800
90 /* EnE HW Register */
91 #define REG_CARD_STATUS 0xFF83
92 #define REG_HW_TRAP1 0xFF89
94 /* SRB Status */
95 #define SS_SUCCESS 0x00 /* No Sense */
96 #define SS_NOT_READY 0x02
97 #define SS_MEDIUM_ERR 0x03
98 #define SS_HW_ERR 0x04
99 #define SS_ILLEGAL_REQUEST 0x05
100 #define SS_UNIT_ATTENTION 0x06
102 /* ENE Load FW Pattern */
103 #define SD_INIT1_PATTERN 1
104 #define SD_INIT2_PATTERN 2
105 #define SD_RW_PATTERN 3
106 #define MS_INIT_PATTERN 4
107 #define MSP_RW_PATTERN 5
108 #define MS_RW_PATTERN 6
109 #define SM_INIT_PATTERN 7
110 #define SM_RW_PATTERN 8
112 #define FDIR_WRITE 0
113 #define FDIR_READ 1
115 /* For MS Card */
117 /* Status Register 1 */
118 #define MS_REG_ST1_MB 0x80 /* media busy */
119 #define MS_REG_ST1_FB1 0x40 /* flush busy 1 */
120 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
121 #define MS_REG_ST1_UCDT 0x10 /* unable to correct data */
122 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
123 #define MS_REG_ST1_UCEX 0x04 /* unable to correct extra */
124 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
125 #define MS_REG_ST1_UCFG 0x01 /* unable to correct overwrite flag */
126 #define MS_REG_ST1_DEFAULT (MS_REG_ST1_MB | MS_REG_ST1_FB1 | MS_REG_ST1_DTER | MS_REG_ST1_UCDT | MS_REG_ST1_EXER | MS_REG_ST1_UCEX | MS_REG_ST1_FGER | MS_REG_ST1_UCFG)
128 /* Overwrite Area */
129 #define MS_REG_OVR_BKST 0x80 /* block status */
130 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
131 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
132 #define MS_REG_OVR_PGST0 0x40 /* page status */
133 #define MS_REG_OVR_PGST1 0x20
134 #define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
135 #define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
136 #define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 /* NG */
137 #define MS_REG_OVR_PGST_DATA_ERROR 0x00 /* data error */
138 #define MS_REG_OVR_UDST 0x10 /* update status */
139 #define MS_REG_OVR_UDST_UPDATING 0x00 /* updating */
140 #define MS_REG_OVR_UDST_NO_UPDATE MS_REG_OVR_UDST
141 #define MS_REG_OVR_RESERVED 0x08
142 #define MS_REG_OVR_DEFAULT (MS_REG_OVR_BKST_OK | MS_REG_OVR_PGST_OK | MS_REG_OVR_UDST_NO_UPDATE | MS_REG_OVR_RESERVED)
144 /* Management Flag */
145 #define MS_REG_MNG_SCMS0 0x20 /* serial copy management system */
146 #define MS_REG_MNG_SCMS1 0x10
147 #define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
148 #define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
149 #define MS_REG_MNG_SCMS_ONE_COPY MS_REG_MNG_SCMS1
150 #define MS_REG_MNG_SCMS_NO_COPY 0x00
151 #define MS_REG_MNG_ATFLG 0x08 /* address transfer table flag */
152 #define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG /* other */
153 #define MS_REG_MNG_ATFLG_ATTBL 0x00 /* address transfer table */
154 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
155 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
156 #define MS_REG_MNG_SYSFLG_BOOT 0x00 /* system block */
157 #define MS_REG_MNG_RESERVED 0xc3
158 #define MS_REG_MNG_DEFAULT (MS_REG_MNG_SCMS_COPY_OK | MS_REG_MNG_ATFLG_OTHER | MS_REG_MNG_SYSFLG_USER | MS_REG_MNG_RESERVED)
161 #define MS_MAX_PAGES_PER_BLOCK 32
162 #define MS_MAX_INITIAL_ERROR_BLOCKS 10
163 #define MS_LIB_BITS_PER_BYTE 8
165 #define MS_SYSINF_FORMAT_FAT 1
166 #define MS_SYSINF_USAGE_GENERAL 0
168 #define MS_SYSINF_MSCLASS_TYPE_1 1
169 #define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */
171 #define MS_SYSINF_CARDTYPE_RDONLY 1
172 #define MS_SYSINF_CARDTYPE_RDWR 2
173 #define MS_SYSINF_CARDTYPE_HYBRID 3
174 #define MS_SYSINF_SECURITY 0x01
175 #define MS_SYSINF_SECURITY_NO_SUPPORT MS_SYSINF_SECURITY
176 #define MS_SYSINF_SECURITY_SUPPORT 0
178 #define MS_SYSINF_RESERVED1 1
179 #define MS_SYSINF_RESERVED2 1
181 #define MS_SYSENT_TYPE_INVALID_BLOCK 0x01
182 #define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */
184 #define SIZE_OF_KIRO 1024
185 #define BYTE_MASK 0xff
187 /* ms error code */
188 #define MS_STATUS_WRITE_PROTECT 0x0106
189 #define MS_STATUS_SUCCESS 0x0000
190 #define MS_ERROR_FLASH_READ 0x8003
191 #define MS_ERROR_FLASH_ERASE 0x8005
192 #define MS_LB_ERROR 0xfff0
193 #define MS_LB_BOOT_BLOCK 0xfff1
194 #define MS_LB_INITIAL_ERROR 0xfff2
195 #define MS_STATUS_SUCCESS_WITH_ECC 0xfff3
196 #define MS_LB_ACQUIRED_ERROR 0xfff4
197 #define MS_LB_NOT_USED_ERASED 0xfff5
198 #define MS_NOCARD_ERROR 0xfff8
199 #define MS_NO_MEMORY_ERROR 0xfff9
200 #define MS_STATUS_INT_ERROR 0xfffa
201 #define MS_STATUS_ERROR 0xfffe
202 #define MS_LB_NOT_USED 0xffff
204 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
205 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
207 #define MS_BOOT_BLOCK_ID 0x0001
208 #define MS_BOOT_BLOCK_FORMAT_VERSION 0x0100
209 #define MS_BOOT_BLOCK_DATA_ENTRIES 2
211 #define MS_NUMBER_OF_SYSTEM_ENTRY 4
212 #define MS_NUMBER_OF_BOOT_BLOCK 2
213 #define MS_BYTES_PER_PAGE 512
214 #define MS_LOGICAL_BLOCKS_PER_SEGMENT 496
215 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT 494
217 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */
218 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff
220 /* overwrite area */
221 #define MS_REG_OVR_BKST 0x80 /* block status */
222 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
223 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
225 /* Status Register 1 */
226 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
227 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
228 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
230 /* MemoryStick Register */
231 /* Status Register 0 */
232 #define MS_REG_ST0_WP 0x01 /* write protected */
233 #define MS_REG_ST0_WP_ON MS_REG_ST0_WP
235 #define MS_LIB_CTRL_RDONLY 0
236 #define MS_LIB_CTRL_WRPROTECT 1
238 /*dphy->log table */
239 #define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
240 #define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
242 #define ms_lib_ctrl_set(pdx, Flag) ((pdx)->MS_Lib.flags |= (1 << (Flag)))
243 #define ms_lib_ctrl_reset(pdx, Flag) ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
244 #define ms_lib_ctrl_check(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag)))
246 #define ms_lib_iswritable(pdx) ((ms_lib_ctrl_check((pdx), MS_LIB_CTRL_RDONLY) == 0) && (ms_lib_ctrl_check(pdx, MS_LIB_CTRL_WRPROTECT) == 0))
247 #define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
248 #define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0))
251 struct SD_STATUS {
252 u8 Insert:1;
253 u8 Ready:1;
254 u8 MediaChange:1;
255 u8 IsMMC:1;
256 u8 HiCapacity:1;
257 u8 HiSpeed:1;
258 u8 WtP:1;
259 u8 Reserved:1;
262 struct MS_STATUS {
263 u8 Insert:1;
264 u8 Ready:1;
265 u8 MediaChange:1;
266 u8 IsMSPro:1;
267 u8 IsMSPHG:1;
268 u8 Reserved1:1;
269 u8 WtP:1;
270 u8 Reserved2:1;
273 struct SM_STATUS {
274 u8 Insert:1;
275 u8 Ready:1;
276 u8 MediaChange:1;
277 u8 Reserved:3;
278 u8 WtP:1;
279 u8 IsMS:1;
282 struct ms_bootblock_cis {
283 u8 bCistplDEVICE[6]; /* 0 */
284 u8 bCistplDEVICE0C[6]; /* 6 */
285 u8 bCistplJEDECC[4]; /* 12 */
286 u8 bCistplMANFID[6]; /* 16 */
287 u8 bCistplVER1[32]; /* 22 */
288 u8 bCistplFUNCID[4]; /* 54 */
289 u8 bCistplFUNCE0[4]; /* 58 */
290 u8 bCistplFUNCE1[5]; /* 62 */
291 u8 bCistplCONF[7]; /* 67 */
292 u8 bCistplCFTBLENT0[10];/* 74 */
293 u8 bCistplCFTBLENT1[8]; /* 84 */
294 u8 bCistplCFTBLENT2[12];/* 92 */
295 u8 bCistplCFTBLENT3[8]; /* 104 */
296 u8 bCistplCFTBLENT4[17];/* 112 */
297 u8 bCistplCFTBLENT5[8]; /* 129 */
298 u8 bCistplCFTBLENT6[17];/* 137 */
299 u8 bCistplCFTBLENT7[8]; /* 154 */
300 u8 bCistplNOLINK[3]; /* 162 */
303 struct ms_bootblock_idi {
304 #define MS_IDI_GENERAL_CONF 0x848A
305 u16 wIDIgeneralConfiguration; /* 0 */
306 u16 wIDInumberOfCylinder; /* 1 */
307 u16 wIDIreserved0; /* 2 */
308 u16 wIDInumberOfHead; /* 3 */
309 u16 wIDIbytesPerTrack; /* 4 */
310 u16 wIDIbytesPerSector; /* 5 */
311 u16 wIDIsectorsPerTrack; /* 6 */
312 u16 wIDItotalSectors[2]; /* 7-8 high,low */
313 u16 wIDIreserved1[11]; /* 9-19 */
314 u16 wIDIbufferType; /* 20 */
315 u16 wIDIbufferSize; /* 21 */
316 u16 wIDIlongCmdECC; /* 22 */
317 u16 wIDIfirmVersion[4]; /* 23-26 */
318 u16 wIDImodelName[20]; /* 27-46 */
319 u16 wIDIreserved2; /* 47 */
320 u16 wIDIlongWordSupported; /* 48 */
321 u16 wIDIdmaSupported; /* 49 */
322 u16 wIDIreserved3; /* 50 */
323 u16 wIDIpioTiming; /* 51 */
324 u16 wIDIdmaTiming; /* 52 */
325 u16 wIDItransferParameter; /* 53 */
326 u16 wIDIformattedCylinder; /* 54 */
327 u16 wIDIformattedHead; /* 55 */
328 u16 wIDIformattedSectorsPerTrack;/* 56 */
329 u16 wIDIformattedTotalSectors[2];/* 57-58 */
330 u16 wIDImultiSector; /* 59 */
331 u16 wIDIlbaSectors[2]; /* 60-61 */
332 u16 wIDIsingleWordDMA; /* 62 */
333 u16 wIDImultiWordDMA; /* 63 */
334 u16 wIDIreserved4[192]; /* 64-255 */
337 struct ms_bootblock_sysent_rec {
338 u32 dwStart;
339 u32 dwSize;
340 u8 bType;
341 u8 bReserved[3];
344 struct ms_bootblock_sysent {
345 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
348 struct ms_bootblock_sysinf {
349 u8 bMsClass; /* must be 1 */
350 u8 bCardType; /* see below */
351 u16 wBlockSize; /* n KB */
352 u16 wBlockNumber; /* number of physical block */
353 u16 wTotalBlockNumber; /* number of logical block */
354 u16 wPageSize; /* must be 0x200 */
355 u8 bExtraSize; /* 0x10 */
356 u8 bSecuritySupport;
357 u8 bAssemblyDate[8];
358 u8 bFactoryArea[4];
359 u8 bAssemblyMakerCode;
360 u8 bAssemblyMachineCode[3];
361 u16 wMemoryMakerCode;
362 u16 wMemoryDeviceCode;
363 u16 wMemorySize;
364 u8 bReserved1;
365 u8 bReserved2;
366 u8 bVCC;
367 u8 bVPP;
368 u16 wControllerChipNumber;
369 u16 wControllerFunction; /* New MS */
370 u8 bReserved3[9]; /* New MS */
371 u8 bParallelSupport; /* New MS */
372 u16 wFormatValue; /* New MS */
373 u8 bFormatType;
374 u8 bUsage;
375 u8 bDeviceType;
376 u8 bReserved4[22];
377 u8 bFUValue3;
378 u8 bFUValue4;
379 u8 bReserved5[15];
382 struct ms_bootblock_header {
383 u16 wBlockID;
384 u16 wFormatVersion;
385 u8 bReserved1[184];
386 u8 bNumberOfDataEntry;
387 u8 bReserved2[179];
390 struct ms_bootblock_page0 {
391 struct ms_bootblock_header header;
392 struct ms_bootblock_sysent sysent;
393 struct ms_bootblock_sysinf sysinf;
396 struct ms_bootblock_cis_idi {
397 union {
398 struct ms_bootblock_cis cis;
399 u8 dmy[256];
400 } cis;
402 union {
403 struct ms_bootblock_idi idi;
404 u8 dmy[256];
405 } idi;
409 /* ENE MS Lib struct */
410 struct ms_lib_type_extdat {
411 u8 reserved;
412 u8 intr;
413 u8 status0;
414 u8 status1;
415 u8 ovrflg;
416 u8 mngflg;
417 u16 logadr;
420 struct ms_lib_ctrl {
421 u32 flags;
422 u32 BytesPerSector;
423 u32 NumberOfCylinder;
424 u32 SectorsPerCylinder;
425 u16 cardType; /* R/W, RO, Hybrid */
426 u16 blockSize;
427 u16 PagesPerBlock;
428 u16 NumberOfPhyBlock;
429 u16 NumberOfLogBlock;
430 u16 NumberOfSegment;
431 u16 *Phy2LogMap; /* phy2log table */
432 u16 *Log2PhyMap; /* log2phy table */
433 u16 wrtblk;
434 unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
435 unsigned char *blkpag;
436 struct ms_lib_type_extdat *blkext;
437 unsigned char copybuf[512];
441 /* SD Block Length */
442 /* 2^9 = 512 Bytes, The HW maximum read/write data length */
443 #define SD_BLOCK_LEN 9
445 struct ene_ub6250_info {
446 /* for 6250 code */
447 struct SD_STATUS SD_Status;
448 struct MS_STATUS MS_Status;
449 struct SM_STATUS SM_Status;
451 /* ----- SD Control Data ---------------- */
452 /*SD_REGISTER SD_Regs; */
453 u16 SD_Block_Mult;
454 u8 SD_READ_BL_LEN;
455 u16 SD_C_SIZE;
456 u8 SD_C_SIZE_MULT;
458 /* SD/MMC New spec. */
459 u8 SD_SPEC_VER;
460 u8 SD_CSD_VER;
461 u8 SD20_HIGH_CAPACITY;
462 u32 HC_C_SIZE;
463 u8 MMC_SPEC_VER;
464 u8 MMC_BusWidth;
465 u8 MMC_HIGH_CAPACITY;
467 /*----- MS Control Data ---------------- */
468 bool MS_SWWP;
469 u32 MSP_TotalBlock;
470 struct ms_lib_ctrl MS_Lib;
471 bool MS_IsRWPage;
472 u16 MS_Model;
474 /*----- SM Control Data ---------------- */
475 u8 SM_DeviceID;
476 u8 SM_CardID;
478 unsigned char *testbuf;
479 u8 BIN_FLAG;
480 u32 bl_num;
481 int SrbStatus;
483 /*------Power Managerment ---------------*/
484 bool Power_IsResum;
487 static int ene_sd_init(struct us_data *us);
488 static int ene_ms_init(struct us_data *us);
489 static int ene_load_bincode(struct us_data *us, unsigned char flag);
491 static void ene_ub6250_info_destructor(void *extra)
493 if (!extra)
494 return;
497 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
499 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
500 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
502 int result;
503 unsigned int residue;
504 unsigned int cswlen = 0, partial = 0;
505 unsigned int transfer_length = bcb->DataTransferLength;
507 /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
508 /* send cmd to out endpoint */
509 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
510 bcb, US_BULK_CB_WRAP_LEN, NULL);
511 if (result != USB_STOR_XFER_GOOD) {
512 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
513 return USB_STOR_TRANSPORT_ERROR;
516 if (buf) {
517 unsigned int pipe = fDir;
519 if (fDir == FDIR_READ)
520 pipe = us->recv_bulk_pipe;
521 else
522 pipe = us->send_bulk_pipe;
524 /* Bulk */
525 if (use_sg) {
526 result = usb_stor_bulk_srb(us, pipe, us->srb);
527 } else {
528 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
529 transfer_length, 0, &partial);
531 if (result != USB_STOR_XFER_GOOD) {
532 usb_stor_dbg(us, "data transfer fail ---\n");
533 return USB_STOR_TRANSPORT_ERROR;
537 /* Get CSW for device status */
538 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
539 US_BULK_CS_WRAP_LEN, &cswlen);
541 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
542 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
543 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
544 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
547 if (result == USB_STOR_XFER_STALLED) {
548 /* get the status again */
549 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
550 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
551 bcs, US_BULK_CS_WRAP_LEN, NULL);
554 if (result != USB_STOR_XFER_GOOD)
555 return USB_STOR_TRANSPORT_ERROR;
557 /* check bulk status */
558 residue = le32_to_cpu(bcs->Residue);
560 /* try to compute the actual residue, based on how much data
561 * was really transferred and what the device tells us */
562 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
563 residue = min(residue, transfer_length);
564 if (us->srb != NULL)
565 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
566 (int)residue));
569 if (bcs->Status != US_BULK_STAT_OK)
570 return USB_STOR_TRANSPORT_ERROR;
572 return USB_STOR_TRANSPORT_GOOD;
575 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
577 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
579 if (info->SD_Status.Insert && info->SD_Status.Ready)
580 return USB_STOR_TRANSPORT_GOOD;
581 else {
582 ene_sd_init(us);
583 return USB_STOR_TRANSPORT_GOOD;
586 return USB_STOR_TRANSPORT_GOOD;
589 static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
591 unsigned char data_ptr[36] = {
592 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
593 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
594 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
595 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
597 usb_stor_set_xfer_buf(data_ptr, 36, srb);
598 return USB_STOR_TRANSPORT_GOOD;
601 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
603 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
604 unsigned char mediaNoWP[12] = {
605 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
606 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
607 unsigned char mediaWP[12] = {
608 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
609 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
611 if (info->SD_Status.WtP)
612 usb_stor_set_xfer_buf(mediaWP, 12, srb);
613 else
614 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
617 return USB_STOR_TRANSPORT_GOOD;
620 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
622 u32 bl_num;
623 u32 bl_len;
624 unsigned int offset = 0;
625 unsigned char buf[8];
626 struct scatterlist *sg = NULL;
627 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
629 usb_stor_dbg(us, "sd_scsi_read_capacity\n");
630 if (info->SD_Status.HiCapacity) {
631 bl_len = 0x200;
632 if (info->SD_Status.IsMMC)
633 bl_num = info->HC_C_SIZE-1;
634 else
635 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
636 } else {
637 bl_len = 1 << (info->SD_READ_BL_LEN);
638 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
639 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
641 info->bl_num = bl_num;
642 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
643 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
645 /*srb->request_bufflen = 8; */
646 buf[0] = (bl_num >> 24) & 0xff;
647 buf[1] = (bl_num >> 16) & 0xff;
648 buf[2] = (bl_num >> 8) & 0xff;
649 buf[3] = (bl_num >> 0) & 0xff;
650 buf[4] = (bl_len >> 24) & 0xff;
651 buf[5] = (bl_len >> 16) & 0xff;
652 buf[6] = (bl_len >> 8) & 0xff;
653 buf[7] = (bl_len >> 0) & 0xff;
655 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
657 return USB_STOR_TRANSPORT_GOOD;
660 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
662 int result;
663 unsigned char *cdb = srb->cmnd;
664 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
665 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
667 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
668 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
669 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
670 u32 bnByte = bn * 0x200;
671 u32 blenByte = blen * 0x200;
673 if (bn > info->bl_num)
674 return USB_STOR_TRANSPORT_ERROR;
676 result = ene_load_bincode(us, SD_RW_PATTERN);
677 if (result != USB_STOR_XFER_GOOD) {
678 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
679 return USB_STOR_TRANSPORT_ERROR;
682 if (info->SD_Status.HiCapacity)
683 bnByte = bn;
685 /* set up the command wrapper */
686 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
687 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
688 bcb->DataTransferLength = blenByte;
689 bcb->Flags = US_BULK_FLAG_IN;
690 bcb->CDB[0] = 0xF1;
691 bcb->CDB[5] = (unsigned char)(bnByte);
692 bcb->CDB[4] = (unsigned char)(bnByte>>8);
693 bcb->CDB[3] = (unsigned char)(bnByte>>16);
694 bcb->CDB[2] = (unsigned char)(bnByte>>24);
696 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
697 return result;
700 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
702 int result;
703 unsigned char *cdb = srb->cmnd;
704 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
705 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
707 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
708 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
709 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
710 u32 bnByte = bn * 0x200;
711 u32 blenByte = blen * 0x200;
713 if (bn > info->bl_num)
714 return USB_STOR_TRANSPORT_ERROR;
716 result = ene_load_bincode(us, SD_RW_PATTERN);
717 if (result != USB_STOR_XFER_GOOD) {
718 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
719 return USB_STOR_TRANSPORT_ERROR;
722 if (info->SD_Status.HiCapacity)
723 bnByte = bn;
725 /* set up the command wrapper */
726 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
727 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
728 bcb->DataTransferLength = blenByte;
729 bcb->Flags = 0x00;
730 bcb->CDB[0] = 0xF0;
731 bcb->CDB[5] = (unsigned char)(bnByte);
732 bcb->CDB[4] = (unsigned char)(bnByte>>8);
733 bcb->CDB[3] = (unsigned char)(bnByte>>16);
734 bcb->CDB[2] = (unsigned char)(bnByte>>24);
736 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
737 return result;
741 * ENE MS Card
744 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
746 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
748 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
749 return (u32)-1;
751 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
752 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
754 return 0;
757 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
759 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
761 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
762 return (u32)-1;
764 info->MS_Lib.Phy2LogMap[phyblk] = mark;
766 return 0;
769 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
771 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
774 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
776 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
779 static int ms_lib_free_logicalmap(struct us_data *us)
781 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
783 kfree(info->MS_Lib.Phy2LogMap);
784 info->MS_Lib.Phy2LogMap = NULL;
786 kfree(info->MS_Lib.Log2PhyMap);
787 info->MS_Lib.Log2PhyMap = NULL;
789 return 0;
792 static int ms_lib_alloc_logicalmap(struct us_data *us)
794 u32 i;
795 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
797 info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL);
798 info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL);
800 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
801 ms_lib_free_logicalmap(us);
802 return (u32)-1;
805 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
806 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
808 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
809 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
811 return 0;
814 static void ms_lib_clear_writebuf(struct us_data *us)
816 int i;
817 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
819 info->MS_Lib.wrtblk = (u16)-1;
820 ms_lib_clear_pagemap(info);
822 if (info->MS_Lib.blkpag)
823 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
825 if (info->MS_Lib.blkext) {
826 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
827 info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
828 info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
829 info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
830 info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
835 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
837 u32 Ende, Count;
838 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
840 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
841 for (Count = 0; PhyBlock < Ende; PhyBlock++) {
842 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
843 case MS_LB_NOT_USED:
844 case MS_LB_NOT_USED_ERASED:
845 Count++;
846 default:
847 break;
851 return Count;
854 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
855 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
857 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
858 int result;
859 u8 ExtBuf[4];
860 u32 bn = PhyBlockAddr * 0x20 + PageNum;
862 /* printk(KERN_INFO "MS --- MS_ReaderReadPage,
863 PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
865 result = ene_load_bincode(us, MS_RW_PATTERN);
866 if (result != USB_STOR_XFER_GOOD)
867 return USB_STOR_TRANSPORT_ERROR;
869 /* Read Page Data */
870 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
871 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
872 bcb->DataTransferLength = 0x200;
873 bcb->Flags = US_BULK_FLAG_IN;
874 bcb->CDB[0] = 0xF1;
876 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
878 bcb->CDB[5] = (unsigned char)(bn);
879 bcb->CDB[4] = (unsigned char)(bn>>8);
880 bcb->CDB[3] = (unsigned char)(bn>>16);
881 bcb->CDB[2] = (unsigned char)(bn>>24);
883 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
884 if (result != USB_STOR_XFER_GOOD)
885 return USB_STOR_TRANSPORT_ERROR;
888 /* Read Extra Data */
889 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
890 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
891 bcb->DataTransferLength = 0x4;
892 bcb->Flags = US_BULK_FLAG_IN;
893 bcb->CDB[0] = 0xF1;
894 bcb->CDB[1] = 0x03;
896 bcb->CDB[5] = (unsigned char)(PageNum);
897 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
898 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
899 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
900 bcb->CDB[6] = 0x01;
902 result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
903 if (result != USB_STOR_XFER_GOOD)
904 return USB_STOR_TRANSPORT_ERROR;
906 ExtraDat->reserved = 0;
907 ExtraDat->intr = 0x80; /* Not yet,fireware support */
908 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
910 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
911 ExtraDat->ovrflg = ExtBuf[0];
912 ExtraDat->mngflg = ExtBuf[1];
913 ExtraDat->logadr = memstick_logaddr(ExtBuf[2], ExtBuf[3]);
915 return USB_STOR_TRANSPORT_GOOD;
918 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
920 struct ms_bootblock_sysent *SysEntry;
921 struct ms_bootblock_sysinf *SysInfo;
922 u32 i, result;
923 u8 PageNumber;
924 u8 *PageBuffer;
925 struct ms_lib_type_extdat ExtraData;
926 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
928 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
929 if (PageBuffer == NULL)
930 return (u32)-1;
932 result = (u32)-1;
934 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
936 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
937 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
938 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
939 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
940 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
941 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
942 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
943 goto exit;
944 /* */
945 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
946 case MS_SYSINF_CARDTYPE_RDONLY:
947 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
948 break;
949 case MS_SYSINF_CARDTYPE_RDWR:
950 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
951 break;
952 case MS_SYSINF_CARDTYPE_HYBRID:
953 default:
954 goto exit;
957 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
958 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
959 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
960 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
961 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
962 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
964 /*Allocate to all number of logicalblock and physicalblock */
965 if (ms_lib_alloc_logicalmap(us))
966 goto exit;
968 /* Mark the book block */
969 ms_lib_set_bootblockmark(us, PhyBlock);
971 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
973 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
974 u32 EntryOffset, EntrySize;
976 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
978 if (EntryOffset == 0xffffff)
979 continue;
980 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
982 if (EntrySize == 0)
983 continue;
985 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
986 continue;
988 if (i == 0) {
989 u8 PrevPageNumber = 0;
990 u16 phyblk;
992 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
993 goto exit;
995 while (EntrySize > 0) {
997 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
998 if (PageNumber != PrevPageNumber) {
999 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1000 case MS_STATUS_SUCCESS:
1001 break;
1002 case MS_STATUS_WRITE_PROTECT:
1003 case MS_ERROR_FLASH_READ:
1004 case MS_STATUS_ERROR:
1005 default:
1006 goto exit;
1009 PrevPageNumber = PageNumber;
1012 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1013 if (phyblk < 0x0fff)
1014 ms_lib_set_initialerrorblock(us, phyblk);
1016 EntryOffset += 2;
1017 EntrySize -= 2;
1019 } else if (i == 1) { /* CIS/IDI */
1020 struct ms_bootblock_idi *idi;
1022 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1023 goto exit;
1025 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1026 case MS_STATUS_SUCCESS:
1027 break;
1028 case MS_STATUS_WRITE_PROTECT:
1029 case MS_ERROR_FLASH_READ:
1030 case MS_STATUS_ERROR:
1031 default:
1032 goto exit;
1035 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1036 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1037 goto exit;
1039 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1040 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1041 goto exit;
1043 } /* End for .. */
1045 result = 0;
1047 exit:
1048 if (result)
1049 ms_lib_free_logicalmap(us);
1051 kfree(PageBuffer);
1053 result = 0;
1054 return result;
1057 static void ms_lib_free_writebuf(struct us_data *us)
1059 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1060 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1062 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1064 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1066 if (info->MS_Lib.blkpag) {
1067 kfree((u8 *)(info->MS_Lib.blkpag)); /* Arnold test ... */
1068 info->MS_Lib.blkpag = NULL;
1071 if (info->MS_Lib.blkext) {
1072 kfree((u8 *)(info->MS_Lib.blkext)); /* Arnold test ... */
1073 info->MS_Lib.blkext = NULL;
1078 static void ms_lib_free_allocatedarea(struct us_data *us)
1080 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1082 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1083 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1085 /* set struct us point flag to 0 */
1086 info->MS_Lib.flags = 0;
1087 info->MS_Lib.BytesPerSector = 0;
1088 info->MS_Lib.SectorsPerCylinder = 0;
1090 info->MS_Lib.cardType = 0;
1091 info->MS_Lib.blockSize = 0;
1092 info->MS_Lib.PagesPerBlock = 0;
1094 info->MS_Lib.NumberOfPhyBlock = 0;
1095 info->MS_Lib.NumberOfLogBlock = 0;
1099 static int ms_lib_alloc_writebuf(struct us_data *us)
1101 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1103 info->MS_Lib.wrtblk = (u16)-1;
1105 info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL);
1106 info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL);
1108 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1109 ms_lib_free_writebuf(us);
1110 return (u32)-1;
1113 ms_lib_clear_writebuf(us);
1115 return 0;
1118 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1120 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1122 if (logblk == MS_LB_NOT_USED)
1123 return 0;
1125 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1126 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1127 return (u32)-1;
1129 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1130 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1132 return 0;
1135 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1136 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1138 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1139 int result;
1141 /* printk(KERN_INFO "MS_ReaderCopyBlock --- PhyBlockAddr = %x,
1142 PageNum = %x\n", PhyBlockAddr, PageNum); */
1143 result = ene_load_bincode(us, MS_RW_PATTERN);
1144 if (result != USB_STOR_XFER_GOOD)
1145 return USB_STOR_TRANSPORT_ERROR;
1147 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1148 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1149 bcb->DataTransferLength = 0x200*len;
1150 bcb->Flags = 0x00;
1151 bcb->CDB[0] = 0xF0;
1152 bcb->CDB[1] = 0x08;
1153 bcb->CDB[4] = (unsigned char)(oldphy);
1154 bcb->CDB[3] = (unsigned char)(oldphy>>8);
1155 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1156 bcb->CDB[7] = (unsigned char)(newphy);
1157 bcb->CDB[6] = (unsigned char)(newphy>>8);
1158 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1159 bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1160 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1161 bcb->CDB[10] = PageNum;
1163 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1164 if (result != USB_STOR_XFER_GOOD)
1165 return USB_STOR_TRANSPORT_ERROR;
1167 return USB_STOR_TRANSPORT_GOOD;
1170 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1172 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1173 int result;
1174 u32 bn = PhyBlockAddr;
1176 /* printk(KERN_INFO "MS --- ms_read_eraseblock,
1177 PhyBlockAddr = %x\n", PhyBlockAddr); */
1178 result = ene_load_bincode(us, MS_RW_PATTERN);
1179 if (result != USB_STOR_XFER_GOOD)
1180 return USB_STOR_TRANSPORT_ERROR;
1182 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1183 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1184 bcb->DataTransferLength = 0x200;
1185 bcb->Flags = US_BULK_FLAG_IN;
1186 bcb->CDB[0] = 0xF2;
1187 bcb->CDB[1] = 0x06;
1188 bcb->CDB[4] = (unsigned char)(bn);
1189 bcb->CDB[3] = (unsigned char)(bn>>8);
1190 bcb->CDB[2] = (unsigned char)(bn>>16);
1192 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1193 if (result != USB_STOR_XFER_GOOD)
1194 return USB_STOR_TRANSPORT_ERROR;
1196 return USB_STOR_TRANSPORT_GOOD;
1199 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1201 unsigned char *PageBuf = NULL;
1202 u16 result = MS_STATUS_SUCCESS;
1203 u16 blk, index = 0;
1204 struct ms_lib_type_extdat extdat;
1205 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1207 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1208 if (PageBuf == NULL) {
1209 result = MS_NO_MEMORY_ERROR;
1210 goto exit;
1213 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1214 do {
1215 blk = be16_to_cpu(PageBuf[index]);
1216 if (blk == MS_LB_NOT_USED)
1217 break;
1218 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1219 result = MS_ERROR_FLASH_READ;
1220 break;
1222 index++;
1223 } while (1);
1225 exit:
1226 kfree(PageBuf);
1227 return result;
1230 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1232 u16 log;
1233 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1235 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1236 return (u32)-1;
1238 log = info->MS_Lib.Phy2LogMap[phyblk];
1240 if (log < info->MS_Lib.NumberOfLogBlock)
1241 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1243 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1244 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1246 return 0;
1249 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1250 u8 PageNum, u8 OverwriteFlag)
1252 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1253 int result;
1255 /* printk("MS --- MS_LibOverwriteExtra,
1256 PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
1257 result = ene_load_bincode(us, MS_RW_PATTERN);
1258 if (result != USB_STOR_XFER_GOOD)
1259 return USB_STOR_TRANSPORT_ERROR;
1261 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1262 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1263 bcb->DataTransferLength = 0x4;
1264 bcb->Flags = US_BULK_FLAG_IN;
1265 bcb->CDB[0] = 0xF2;
1266 bcb->CDB[1] = 0x05;
1267 bcb->CDB[5] = (unsigned char)(PageNum);
1268 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1269 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1270 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1271 bcb->CDB[6] = OverwriteFlag;
1272 bcb->CDB[7] = 0xFF;
1273 bcb->CDB[8] = 0xFF;
1274 bcb->CDB[9] = 0xFF;
1276 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1277 if (result != USB_STOR_XFER_GOOD)
1278 return USB_STOR_TRANSPORT_ERROR;
1280 return USB_STOR_TRANSPORT_GOOD;
1283 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1285 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1287 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1288 return MS_STATUS_ERROR;
1290 ms_lib_setacquired_errorblock(us, phyblk);
1292 if (ms_lib_iswritable(info))
1293 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1295 return MS_STATUS_SUCCESS;
1298 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1300 u16 log;
1301 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1303 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1304 return MS_STATUS_ERROR;
1306 log = info->MS_Lib.Phy2LogMap[phyblk];
1308 if (log < info->MS_Lib.NumberOfLogBlock)
1309 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1311 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1313 if (ms_lib_iswritable(info)) {
1314 switch (ms_read_eraseblock(us, phyblk)) {
1315 case MS_STATUS_SUCCESS:
1316 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1317 return MS_STATUS_SUCCESS;
1318 case MS_ERROR_FLASH_ERASE:
1319 case MS_STATUS_INT_ERROR:
1320 ms_lib_error_phyblock(us, phyblk);
1321 return MS_ERROR_FLASH_ERASE;
1322 case MS_STATUS_ERROR:
1323 default:
1324 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1325 ms_lib_setacquired_errorblock(us, phyblk);
1326 return MS_STATUS_ERROR;
1330 ms_lib_setacquired_errorblock(us, phyblk);
1332 return MS_STATUS_SUCCESS;
1335 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1336 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1338 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1339 int result;
1340 u8 ExtBuf[4];
1342 /* printk("MS_LibReadExtra --- PhyBlock = %x, PageNum = %x\n", PhyBlock, PageNum); */
1343 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1344 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1345 bcb->DataTransferLength = 0x4;
1346 bcb->Flags = US_BULK_FLAG_IN;
1347 bcb->CDB[0] = 0xF1;
1348 bcb->CDB[1] = 0x03;
1349 bcb->CDB[5] = (unsigned char)(PageNum);
1350 bcb->CDB[4] = (unsigned char)(PhyBlock);
1351 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1352 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1353 bcb->CDB[6] = 0x01;
1355 result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
1356 if (result != USB_STOR_XFER_GOOD)
1357 return USB_STOR_TRANSPORT_ERROR;
1359 ExtraDat->reserved = 0;
1360 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
1361 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
1362 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
1363 ExtraDat->ovrflg = ExtBuf[0];
1364 ExtraDat->mngflg = ExtBuf[1];
1365 ExtraDat->logadr = memstick_logaddr(ExtBuf[2], ExtBuf[3]);
1367 return USB_STOR_TRANSPORT_GOOD;
1370 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1372 u16 Newblk;
1373 u16 blk;
1374 struct ms_lib_type_extdat extdat; /* need check */
1375 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1378 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1379 return MS_LB_ERROR;
1381 for (blk = phyblk + 1; blk != phyblk; blk++) {
1382 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1383 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1385 Newblk = info->MS_Lib.Phy2LogMap[blk];
1386 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1387 return blk;
1388 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1389 switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1390 case MS_STATUS_SUCCESS:
1391 case MS_STATUS_SUCCESS_WITH_ECC:
1392 break;
1393 case MS_NOCARD_ERROR:
1394 return MS_NOCARD_ERROR;
1395 case MS_STATUS_INT_ERROR:
1396 return MS_LB_ERROR;
1397 case MS_ERROR_FLASH_READ:
1398 default:
1399 ms_lib_setacquired_errorblock(us, blk);
1400 continue;
1401 } /* End switch */
1403 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1404 ms_lib_setacquired_errorblock(us, blk);
1405 continue;
1408 switch (ms_lib_erase_phyblock(us, blk)) {
1409 case MS_STATUS_SUCCESS:
1410 return blk;
1411 case MS_STATUS_ERROR:
1412 return MS_LB_ERROR;
1413 case MS_ERROR_FLASH_ERASE:
1414 default:
1415 ms_lib_error_phyblock(us, blk);
1416 break;
1419 } /* End for */
1421 return MS_LB_ERROR;
1423 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1425 u16 phyblk;
1426 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1428 phyblk = ms_libconv_to_physical(info, logblk);
1429 if (phyblk >= MS_LB_ERROR) {
1430 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1431 return MS_LB_ERROR;
1433 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1434 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1435 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1438 return ms_libsearch_block_from_physical(us, phyblk);
1441 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1443 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1445 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1446 if (info->MS_Status.Insert && info->MS_Status.Ready) {
1447 return USB_STOR_TRANSPORT_GOOD;
1448 } else {
1449 ene_ms_init(us);
1450 return USB_STOR_TRANSPORT_GOOD;
1453 return USB_STOR_TRANSPORT_GOOD;
1456 static int ms_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
1458 /* pr_info("MS_SCSI_Inquiry\n"); */
1459 unsigned char data_ptr[36] = {
1460 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
1461 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
1462 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
1463 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
1465 usb_stor_set_xfer_buf(data_ptr, 36, srb);
1466 return USB_STOR_TRANSPORT_GOOD;
1469 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1471 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1472 unsigned char mediaNoWP[12] = {
1473 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1474 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1475 unsigned char mediaWP[12] = {
1476 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1477 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1479 if (info->MS_Status.WtP)
1480 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1481 else
1482 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1484 return USB_STOR_TRANSPORT_GOOD;
1487 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1489 u32 bl_num;
1490 u16 bl_len;
1491 unsigned int offset = 0;
1492 unsigned char buf[8];
1493 struct scatterlist *sg = NULL;
1494 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1496 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1497 bl_len = 0x200;
1498 if (info->MS_Status.IsMSPro)
1499 bl_num = info->MSP_TotalBlock - 1;
1500 else
1501 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1503 info->bl_num = bl_num;
1504 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1505 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1507 /*srb->request_bufflen = 8; */
1508 buf[0] = (bl_num >> 24) & 0xff;
1509 buf[1] = (bl_num >> 16) & 0xff;
1510 buf[2] = (bl_num >> 8) & 0xff;
1511 buf[3] = (bl_num >> 0) & 0xff;
1512 buf[4] = (bl_len >> 24) & 0xff;
1513 buf[5] = (bl_len >> 16) & 0xff;
1514 buf[6] = (bl_len >> 8) & 0xff;
1515 buf[7] = (bl_len >> 0) & 0xff;
1517 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1519 return USB_STOR_TRANSPORT_GOOD;
1522 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1524 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1526 if (PhyBlock) {
1527 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1528 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1529 } else {
1530 *LogStart = 0;
1531 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1535 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1536 u8 PageNum, u8 blen, void *buf)
1538 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1539 int result;
1541 /* printk("MS_LibReadExtraBlock --- PhyBlock = %x,
1542 PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen); */
1544 /* Read Extra Data */
1545 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1546 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1547 bcb->DataTransferLength = 0x4 * blen;
1548 bcb->Flags = US_BULK_FLAG_IN;
1549 bcb->CDB[0] = 0xF1;
1550 bcb->CDB[1] = 0x03;
1551 bcb->CDB[5] = (unsigned char)(PageNum);
1552 bcb->CDB[4] = (unsigned char)(PhyBlock);
1553 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1554 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1555 bcb->CDB[6] = blen;
1557 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1558 if (result != USB_STOR_XFER_GOOD)
1559 return USB_STOR_TRANSPORT_ERROR;
1561 return USB_STOR_TRANSPORT_GOOD;
1564 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1566 u16 PhyBlock, newblk, i;
1567 u16 LogStart, LogEnde;
1568 struct ms_lib_type_extdat extdat;
1569 u8 buf[0x200];
1570 u32 count = 0, index = 0;
1571 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1573 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1574 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1576 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1577 switch (ms_libconv_to_logical(info, PhyBlock)) {
1578 case MS_STATUS_ERROR:
1579 continue;
1580 default:
1581 break;
1584 if (count == PhyBlock) {
1585 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, &buf);
1586 count += 0x80;
1588 index = (PhyBlock % 0x80) * 4;
1590 extdat.ovrflg = buf[index];
1591 extdat.mngflg = buf[index+1];
1592 extdat.logadr = memstick_logaddr(buf[index+2], buf[index+3]);
1594 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1595 ms_lib_setacquired_errorblock(us, PhyBlock);
1596 continue;
1599 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1600 ms_lib_erase_phyblock(us, PhyBlock);
1601 continue;
1604 if (extdat.logadr != MS_LB_NOT_USED) {
1605 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1606 ms_lib_erase_phyblock(us, PhyBlock);
1607 continue;
1610 newblk = ms_libconv_to_physical(info, extdat.logadr);
1612 if (newblk != MS_LB_NOT_USED) {
1613 if (extdat.logadr == 0) {
1614 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1615 if (ms_lib_check_disableblock(us, btBlk1st)) {
1616 ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1617 continue;
1621 ms_lib_read_extra(us, newblk, 0, &extdat);
1622 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1623 ms_lib_erase_phyblock(us, PhyBlock);
1624 continue;
1625 } else {
1626 ms_lib_erase_phyblock(us, newblk);
1630 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1633 } /* End for ... */
1635 return MS_STATUS_SUCCESS;
1639 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1641 int result;
1642 unsigned char *cdb = srb->cmnd;
1643 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1644 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1646 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1647 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1648 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1649 u32 blenByte = blen * 0x200;
1651 if (bn > info->bl_num)
1652 return USB_STOR_TRANSPORT_ERROR;
1654 if (info->MS_Status.IsMSPro) {
1655 result = ene_load_bincode(us, MSP_RW_PATTERN);
1656 if (result != USB_STOR_XFER_GOOD) {
1657 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1658 return USB_STOR_TRANSPORT_ERROR;
1661 /* set up the command wrapper */
1662 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1663 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1664 bcb->DataTransferLength = blenByte;
1665 bcb->Flags = US_BULK_FLAG_IN;
1666 bcb->CDB[0] = 0xF1;
1667 bcb->CDB[1] = 0x02;
1668 bcb->CDB[5] = (unsigned char)(bn);
1669 bcb->CDB[4] = (unsigned char)(bn>>8);
1670 bcb->CDB[3] = (unsigned char)(bn>>16);
1671 bcb->CDB[2] = (unsigned char)(bn>>24);
1673 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1674 } else {
1675 void *buf;
1676 int offset = 0;
1677 u16 phyblk, logblk;
1678 u8 PageNum;
1679 u16 len;
1680 u32 blkno;
1682 buf = kmalloc(blenByte, GFP_KERNEL);
1683 if (buf == NULL)
1684 return USB_STOR_TRANSPORT_ERROR;
1686 result = ene_load_bincode(us, MS_RW_PATTERN);
1687 if (result != USB_STOR_XFER_GOOD) {
1688 pr_info("Load MS RW pattern Fail !!\n");
1689 result = USB_STOR_TRANSPORT_ERROR;
1690 goto exit;
1693 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1694 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1696 while (1) {
1697 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1698 len = info->MS_Lib.PagesPerBlock-PageNum;
1699 else
1700 len = blen;
1702 phyblk = ms_libconv_to_physical(info, logblk);
1703 blkno = phyblk * 0x20 + PageNum;
1705 /* set up the command wrapper */
1706 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1707 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1708 bcb->DataTransferLength = 0x200 * len;
1709 bcb->Flags = US_BULK_FLAG_IN;
1710 bcb->CDB[0] = 0xF1;
1711 bcb->CDB[1] = 0x02;
1712 bcb->CDB[5] = (unsigned char)(blkno);
1713 bcb->CDB[4] = (unsigned char)(blkno>>8);
1714 bcb->CDB[3] = (unsigned char)(blkno>>16);
1715 bcb->CDB[2] = (unsigned char)(blkno>>24);
1717 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1718 if (result != USB_STOR_XFER_GOOD) {
1719 pr_info("MS_SCSI_Read --- result = %x\n", result);
1720 result = USB_STOR_TRANSPORT_ERROR;
1721 goto exit;
1724 blen -= len;
1725 if (blen <= 0)
1726 break;
1727 logblk++;
1728 PageNum = 0;
1729 offset += MS_BYTES_PER_PAGE*len;
1731 usb_stor_set_xfer_buf(buf, blenByte, srb);
1732 exit:
1733 kfree(buf);
1735 return result;
1738 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1740 int result;
1741 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1742 unsigned char *cdb = srb->cmnd;
1743 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1745 u32 bn = ((cdb[2] << 24) & 0xff000000) |
1746 ((cdb[3] << 16) & 0x00ff0000) |
1747 ((cdb[4] << 8) & 0x0000ff00) |
1748 ((cdb[5] << 0) & 0x000000ff);
1749 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1750 u32 blenByte = blen * 0x200;
1752 if (bn > info->bl_num)
1753 return USB_STOR_TRANSPORT_ERROR;
1755 if (info->MS_Status.IsMSPro) {
1756 result = ene_load_bincode(us, MSP_RW_PATTERN);
1757 if (result != USB_STOR_XFER_GOOD) {
1758 pr_info("Load MSP RW pattern Fail !!\n");
1759 return USB_STOR_TRANSPORT_ERROR;
1762 /* set up the command wrapper */
1763 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1764 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1765 bcb->DataTransferLength = blenByte;
1766 bcb->Flags = 0x00;
1767 bcb->CDB[0] = 0xF0;
1768 bcb->CDB[1] = 0x04;
1769 bcb->CDB[5] = (unsigned char)(bn);
1770 bcb->CDB[4] = (unsigned char)(bn>>8);
1771 bcb->CDB[3] = (unsigned char)(bn>>16);
1772 bcb->CDB[2] = (unsigned char)(bn>>24);
1774 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1775 } else {
1776 void *buf;
1777 int offset = 0;
1778 u16 PhyBlockAddr;
1779 u8 PageNum;
1780 u16 len, oldphy, newphy;
1782 buf = kmalloc(blenByte, GFP_KERNEL);
1783 if (buf == NULL)
1784 return USB_STOR_TRANSPORT_ERROR;
1785 usb_stor_set_xfer_buf(buf, blenByte, srb);
1787 result = ene_load_bincode(us, MS_RW_PATTERN);
1788 if (result != USB_STOR_XFER_GOOD) {
1789 pr_info("Load MS RW pattern Fail !!\n");
1790 result = USB_STOR_TRANSPORT_ERROR;
1791 goto exit;
1794 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1795 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1797 while (1) {
1798 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1799 len = info->MS_Lib.PagesPerBlock-PageNum;
1800 else
1801 len = blen;
1803 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1804 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1806 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1808 if (result != USB_STOR_XFER_GOOD) {
1809 pr_info("MS_SCSI_Write --- result = %x\n", result);
1810 result = USB_STOR_TRANSPORT_ERROR;
1811 goto exit;
1814 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1815 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1817 blen -= len;
1818 if (blen <= 0)
1819 break;
1820 PhyBlockAddr++;
1821 PageNum = 0;
1822 offset += MS_BYTES_PER_PAGE*len;
1824 exit:
1825 kfree(buf);
1827 return result;
1831 * ENE MS Card
1834 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1836 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1837 int result;
1839 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1840 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1841 bcb->DataTransferLength = 0x01;
1842 bcb->Flags = US_BULK_FLAG_IN;
1843 bcb->CDB[0] = 0xED;
1844 bcb->CDB[2] = (unsigned char)(index>>8);
1845 bcb->CDB[3] = (unsigned char)index;
1847 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1848 return result;
1851 static int ene_get_card_status(struct us_data *us, u8 *buf)
1853 u16 tmpreg;
1854 u32 reg4b;
1855 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1857 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1858 reg4b = *(u32 *)&buf[0x18];
1859 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1861 tmpreg = (u16) reg4b;
1862 reg4b = *(u32 *)(&buf[0x14]);
1863 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1864 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1866 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1867 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1868 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1869 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1871 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1872 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1873 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1874 } else {
1875 info->SD_Block_Mult = 1;
1878 return USB_STOR_TRANSPORT_GOOD;
1881 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1883 int err;
1884 char *fw_name = NULL;
1885 unsigned char *buf = NULL;
1886 const struct firmware *sd_fw = NULL;
1887 int result = USB_STOR_TRANSPORT_ERROR;
1888 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1889 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1891 if (info->BIN_FLAG == flag)
1892 return USB_STOR_TRANSPORT_GOOD;
1894 switch (flag) {
1895 /* For SD */
1896 case SD_INIT1_PATTERN:
1897 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1898 fw_name = SD_INIT1_FIRMWARE;
1899 break;
1900 case SD_INIT2_PATTERN:
1901 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1902 fw_name = SD_INIT2_FIRMWARE;
1903 break;
1904 case SD_RW_PATTERN:
1905 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1906 fw_name = SD_RW_FIRMWARE;
1907 break;
1908 /* For MS */
1909 case MS_INIT_PATTERN:
1910 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1911 fw_name = MS_INIT_FIRMWARE;
1912 break;
1913 case MSP_RW_PATTERN:
1914 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1915 fw_name = MSP_RW_FIRMWARE;
1916 break;
1917 case MS_RW_PATTERN:
1918 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1919 fw_name = MS_RW_FIRMWARE;
1920 break;
1921 default:
1922 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1923 goto nofw;
1926 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1927 if (err) {
1928 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1929 goto nofw;
1931 buf = kmalloc(sd_fw->size, GFP_KERNEL);
1932 if (buf == NULL)
1933 goto nofw;
1935 memcpy(buf, sd_fw->data, sd_fw->size);
1936 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1937 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1938 bcb->DataTransferLength = sd_fw->size;
1939 bcb->Flags = 0x00;
1940 bcb->CDB[0] = 0xEF;
1942 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1943 info->BIN_FLAG = flag;
1944 kfree(buf);
1946 nofw:
1947 release_firmware(sd_fw);
1948 return result;
1951 static int ms_card_init(struct us_data *us)
1953 u32 result;
1954 u16 TmpBlock;
1955 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1956 struct ms_lib_type_extdat extdat;
1957 u16 btBlk1st, btBlk2nd;
1958 u32 btBlk1stErred;
1959 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1961 printk(KERN_INFO "MS_CardInit start\n");
1963 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1965 /* get two PageBuffer */
1966 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1967 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1968 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1969 result = MS_NO_MEMORY_ERROR;
1970 goto exit;
1973 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1974 btBlk1stErred = 0;
1976 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1978 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1979 case MS_STATUS_SUCCESS:
1980 break;
1981 case MS_STATUS_INT_ERROR:
1982 break;
1983 case MS_STATUS_ERROR:
1984 default:
1985 continue;
1988 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1989 continue;
1991 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1992 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1993 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1994 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1995 continue;
1997 if (btBlk1st != MS_LB_NOT_USED) {
1998 btBlk2nd = TmpBlock;
1999 break;
2002 btBlk1st = TmpBlock;
2003 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
2004 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2005 btBlk1stErred = 1;
2008 if (btBlk1st == MS_LB_NOT_USED) {
2009 result = MS_STATUS_ERROR;
2010 goto exit;
2013 /* write protect */
2014 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2015 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2017 result = MS_STATUS_ERROR;
2018 /* 1st Boot Block */
2019 if (btBlk1stErred == 0)
2020 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2021 /* 1st */
2022 /* 2nd Boot Block */
2023 if (result && (btBlk2nd != MS_LB_NOT_USED))
2024 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2026 if (result) {
2027 result = MS_STATUS_ERROR;
2028 goto exit;
2031 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2032 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2034 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2036 if (btBlk2nd != MS_LB_NOT_USED) {
2037 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2038 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2040 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2043 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2044 if (result)
2045 goto exit;
2047 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2048 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2049 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2050 if (ms_count_freeblock(us, TmpBlock) == 0) {
2051 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2052 break;
2056 /* write */
2057 if (ms_lib_alloc_writebuf(us)) {
2058 result = MS_NO_MEMORY_ERROR;
2059 goto exit;
2062 result = MS_STATUS_SUCCESS;
2064 exit:
2065 kfree(PageBuffer1);
2066 kfree(PageBuffer0);
2068 printk(KERN_INFO "MS_CardInit end\n");
2069 return result;
2072 static int ene_ms_init(struct us_data *us)
2074 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2075 int result;
2076 u8 buf[0x200];
2077 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2078 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2080 printk(KERN_INFO "transport --- ENE_MSInit\n");
2082 /* the same part to test ENE */
2084 result = ene_load_bincode(us, MS_INIT_PATTERN);
2085 if (result != USB_STOR_XFER_GOOD) {
2086 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2087 return USB_STOR_TRANSPORT_ERROR;
2090 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2091 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2092 bcb->DataTransferLength = 0x200;
2093 bcb->Flags = US_BULK_FLAG_IN;
2094 bcb->CDB[0] = 0xF1;
2095 bcb->CDB[1] = 0x01;
2097 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2098 if (result != USB_STOR_XFER_GOOD) {
2099 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2100 return USB_STOR_TRANSPORT_ERROR;
2102 /* the same part to test ENE */
2103 info->MS_Status = *(struct MS_STATUS *)&buf[0];
2105 if (info->MS_Status.Insert && info->MS_Status.Ready) {
2106 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert);
2107 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready);
2108 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro);
2109 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG);
2110 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2111 if (info->MS_Status.IsMSPro) {
2112 MSP_BlockSize = (buf[6] << 8) | buf[7];
2113 MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
2114 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2115 } else {
2116 ms_card_init(us); /* Card is MS (to ms.c)*/
2118 usb_stor_dbg(us, "MS Init Code OK !!\n");
2119 } else {
2120 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", buf[0]);
2121 return USB_STOR_TRANSPORT_ERROR;
2124 return USB_STOR_TRANSPORT_GOOD;
2127 static int ene_sd_init(struct us_data *us)
2129 int result;
2130 u8 buf[0x200];
2131 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2132 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2134 usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2135 /* SD Init Part-1 */
2136 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2137 if (result != USB_STOR_XFER_GOOD) {
2138 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2139 return USB_STOR_TRANSPORT_ERROR;
2142 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2143 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2144 bcb->Flags = US_BULK_FLAG_IN;
2145 bcb->CDB[0] = 0xF2;
2147 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2148 if (result != USB_STOR_XFER_GOOD) {
2149 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2150 return USB_STOR_TRANSPORT_ERROR;
2153 /* SD Init Part-2 */
2154 result = ene_load_bincode(us, SD_INIT2_PATTERN);
2155 if (result != USB_STOR_XFER_GOOD) {
2156 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2157 return USB_STOR_TRANSPORT_ERROR;
2160 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2161 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2162 bcb->DataTransferLength = 0x200;
2163 bcb->Flags = US_BULK_FLAG_IN;
2164 bcb->CDB[0] = 0xF1;
2166 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2167 if (result != USB_STOR_XFER_GOOD) {
2168 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2169 return USB_STOR_TRANSPORT_ERROR;
2172 info->SD_Status = *(struct SD_STATUS *)&buf[0];
2173 if (info->SD_Status.Insert && info->SD_Status.Ready) {
2174 struct SD_STATUS *s = &info->SD_Status;
2176 ene_get_card_status(us, (unsigned char *)&buf);
2177 usb_stor_dbg(us, "Insert = %x\n", s->Insert);
2178 usb_stor_dbg(us, "Ready = %x\n", s->Ready);
2179 usb_stor_dbg(us, "IsMMC = %x\n", s->IsMMC);
2180 usb_stor_dbg(us, "HiCapacity = %x\n", s->HiCapacity);
2181 usb_stor_dbg(us, "HiSpeed = %x\n", s->HiSpeed);
2182 usb_stor_dbg(us, "WtP = %x\n", s->WtP);
2183 } else {
2184 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", buf[0]);
2185 return USB_STOR_TRANSPORT_ERROR;
2187 return USB_STOR_TRANSPORT_GOOD;
2191 static int ene_init(struct us_data *us)
2193 int result;
2194 u8 misc_reg03 = 0;
2195 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2197 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2198 if (result != USB_STOR_XFER_GOOD)
2199 return USB_STOR_TRANSPORT_ERROR;
2201 if (misc_reg03 & 0x01) {
2202 if (!info->SD_Status.Ready) {
2203 result = ene_sd_init(us);
2204 if (result != USB_STOR_XFER_GOOD)
2205 return USB_STOR_TRANSPORT_ERROR;
2208 if (misc_reg03 & 0x02) {
2209 if (!info->MS_Status.Ready) {
2210 result = ene_ms_init(us);
2211 if (result != USB_STOR_XFER_GOOD)
2212 return USB_STOR_TRANSPORT_ERROR;
2215 return result;
2218 /*----- sd_scsi_irp() ---------*/
2219 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2221 int result;
2222 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2224 info->SrbStatus = SS_SUCCESS;
2225 switch (srb->cmnd[0]) {
2226 case TEST_UNIT_READY:
2227 result = sd_scsi_test_unit_ready(us, srb);
2228 break; /* 0x00 */
2229 case INQUIRY:
2230 result = sd_scsi_inquiry(us, srb);
2231 break; /* 0x12 */
2232 case MODE_SENSE:
2233 result = sd_scsi_mode_sense(us, srb);
2234 break; /* 0x1A */
2236 case START_STOP:
2237 result = SD_SCSI_Start_Stop(us, srb);
2238 break; //0x1B
2240 case READ_CAPACITY:
2241 result = sd_scsi_read_capacity(us, srb);
2242 break; /* 0x25 */
2243 case READ_10:
2244 result = sd_scsi_read(us, srb);
2245 break; /* 0x28 */
2246 case WRITE_10:
2247 result = sd_scsi_write(us, srb);
2248 break; /* 0x2A */
2249 default:
2250 info->SrbStatus = SS_ILLEGAL_REQUEST;
2251 result = USB_STOR_TRANSPORT_FAILED;
2252 break;
2254 return result;
2258 * ms_scsi_irp()
2260 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2262 int result;
2263 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2264 info->SrbStatus = SS_SUCCESS;
2265 switch (srb->cmnd[0]) {
2266 case TEST_UNIT_READY:
2267 result = ms_scsi_test_unit_ready(us, srb);
2268 break; /* 0x00 */
2269 case INQUIRY:
2270 result = ms_scsi_inquiry(us, srb);
2271 break; /* 0x12 */
2272 case MODE_SENSE:
2273 result = ms_scsi_mode_sense(us, srb);
2274 break; /* 0x1A */
2275 case READ_CAPACITY:
2276 result = ms_scsi_read_capacity(us, srb);
2277 break; /* 0x25 */
2278 case READ_10:
2279 result = ms_scsi_read(us, srb);
2280 break; /* 0x28 */
2281 case WRITE_10:
2282 result = ms_scsi_write(us, srb);
2283 break; /* 0x2A */
2284 default:
2285 info->SrbStatus = SS_ILLEGAL_REQUEST;
2286 result = USB_STOR_TRANSPORT_FAILED;
2287 break;
2289 return result;
2292 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2294 int result = 0;
2295 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2297 /*US_DEBUG(usb_stor_show_command(us, srb)); */
2298 scsi_set_resid(srb, 0);
2299 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) {
2300 result = ene_init(us);
2301 } else {
2302 if (info->SD_Status.Ready)
2303 result = sd_scsi_irp(us, srb);
2305 if (info->MS_Status.Ready)
2306 result = ms_scsi_irp(us, srb);
2308 return 0;
2312 static int ene_ub6250_probe(struct usb_interface *intf,
2313 const struct usb_device_id *id)
2315 int result;
2316 u8 misc_reg03 = 0;
2317 struct us_data *us;
2319 result = usb_stor_probe1(&us, intf, id,
2320 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list);
2321 if (result)
2322 return result;
2324 /* FIXME: where should the code alloc extra buf ? */
2325 if (!us->extra) {
2326 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2327 if (!us->extra)
2328 return -ENOMEM;
2329 us->extra_destructor = ene_ub6250_info_destructor;
2332 us->transport_name = "ene_ub6250";
2333 us->transport = ene_transport;
2334 us->max_lun = 0;
2336 result = usb_stor_probe2(us);
2337 if (result)
2338 return result;
2340 /* probe card type */
2341 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2342 if (result != USB_STOR_XFER_GOOD) {
2343 usb_stor_disconnect(intf);
2344 return USB_STOR_TRANSPORT_ERROR;
2347 if (!(misc_reg03 & 0x01)) {
2348 pr_info("ums_eneub6250: The driver only supports SD/MS card. "
2349 "To use SM card, please build driver/staging/keucr\n");
2352 return result;
2356 #ifdef CONFIG_PM
2358 static int ene_ub6250_resume(struct usb_interface *iface)
2360 u8 tmp = 0;
2361 struct us_data *us = usb_get_intfdata(iface);
2362 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2364 mutex_lock(&us->dev_mutex);
2366 if (us->suspend_resume_hook)
2367 (us->suspend_resume_hook)(us, US_RESUME);
2369 mutex_unlock(&us->dev_mutex);
2371 info->Power_IsResum = true;
2372 /*info->SD_Status.Ready = 0; */
2373 info->SD_Status = *(struct SD_STATUS *)&tmp;
2374 info->MS_Status = *(struct MS_STATUS *)&tmp;
2375 info->SM_Status = *(struct SM_STATUS *)&tmp;
2377 return 0;
2380 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2382 u8 tmp = 0;
2383 struct us_data *us = usb_get_intfdata(iface);
2384 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2386 /* Report the reset to the SCSI core */
2387 usb_stor_reset_resume(iface);
2389 /* FIXME: Notify the subdrivers that they need to reinitialize
2390 * the device */
2391 info->Power_IsResum = true;
2392 /*info->SD_Status.Ready = 0; */
2393 info->SD_Status = *(struct SD_STATUS *)&tmp;
2394 info->MS_Status = *(struct MS_STATUS *)&tmp;
2395 info->SM_Status = *(struct SM_STATUS *)&tmp;
2397 return 0;
2400 #else
2402 #define ene_ub6250_resume NULL
2403 #define ene_ub6250_reset_resume NULL
2405 #endif
2407 static struct usb_driver ene_ub6250_driver = {
2408 .name = "ums_eneub6250",
2409 .probe = ene_ub6250_probe,
2410 .disconnect = usb_stor_disconnect,
2411 .suspend = usb_stor_suspend,
2412 .resume = ene_ub6250_resume,
2413 .reset_resume = ene_ub6250_reset_resume,
2414 .pre_reset = usb_stor_pre_reset,
2415 .post_reset = usb_stor_post_reset,
2416 .id_table = ene_ub6250_usb_ids,
2417 .soft_unbind = 1,
2418 .no_dynamic_id = 1,
2421 module_usb_driver(ene_ub6250_driver);