1 // SPDX-License-Identifier: GPL-2.0+
2 #include <linux/jiffies.h>
3 #include <linux/errno.h>
4 #include <linux/module.h>
5 #include <linux/slab.h>
8 #include <scsi/scsi_cmnd.h>
10 #include <linux/firmware.h>
13 #include "transport.h"
18 #define SD_INIT1_FIRMWARE "/*(DEBLOBBED)*/"
19 #define SD_INIT2_FIRMWARE "/*(DEBLOBBED)*/"
20 #define SD_RW_FIRMWARE "/*(DEBLOBBED)*/"
21 #define MS_INIT_FIRMWARE "/*(DEBLOBBED)*/"
22 #define MSP_RW_FIRMWARE "/*(DEBLOBBED)*/"
23 #define MS_RW_FIRMWARE "/*(DEBLOBBED)*/"
25 #define DRV_NAME "ums_eneub6250"
27 MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
28 MODULE_LICENSE("GPL");
32 * The table of devices
34 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
35 vendorName, productName, useProtocol, useTransport, \
36 initFunction, flags) \
37 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
38 .driver_info = (flags)}
40 static struct usb_device_id ene_ub6250_usb_ids[] = {
41 # include "unusual_ene_ub6250.h"
42 { } /* Terminating entry */
44 MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
51 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
52 vendor_name, product_name, use_protocol, use_transport, \
53 init_function, Flags) \
55 .vendorName = vendor_name, \
56 .productName = product_name, \
57 .useProtocol = use_protocol, \
58 .useTransport = use_transport, \
59 .initFunction = init_function, \
62 static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
63 # include "unusual_ene_ub6250.h"
64 { } /* Terminating entry */
71 /* ENE bin code len */
72 #define ENE_BIN_CODE_LEN 0x800
74 #define REG_CARD_STATUS 0xFF83
75 #define REG_HW_TRAP1 0xFF89
78 #define SS_SUCCESS 0x000000 /* No Sense */
79 #define SS_NOT_READY 0x023A00 /* Medium not present */
80 #define SS_MEDIUM_ERR 0x031100 /* Unrecovered read error */
81 #define SS_HW_ERR 0x040800 /* Communication failure */
82 #define SS_ILLEGAL_REQUEST 0x052000 /* Invalid command */
83 #define SS_UNIT_ATTENTION 0x062900 /* Reset occurred */
85 /* ENE Load FW Pattern */
86 #define SD_INIT1_PATTERN 1
87 #define SD_INIT2_PATTERN 2
88 #define SD_RW_PATTERN 3
89 #define MS_INIT_PATTERN 4
90 #define MSP_RW_PATTERN 5
91 #define MS_RW_PATTERN 6
92 #define SM_INIT_PATTERN 7
93 #define SM_RW_PATTERN 8
100 /* Status Register 1 */
101 #define MS_REG_ST1_MB 0x80 /* media busy */
102 #define MS_REG_ST1_FB1 0x40 /* flush busy 1 */
103 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
104 #define MS_REG_ST1_UCDT 0x10 /* unable to correct data */
105 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
106 #define MS_REG_ST1_UCEX 0x04 /* unable to correct extra */
107 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
108 #define MS_REG_ST1_UCFG 0x01 /* unable to correct overwrite flag */
109 #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)
112 #define MS_REG_OVR_BKST 0x80 /* block status */
113 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
114 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
115 #define MS_REG_OVR_PGST0 0x40 /* page status */
116 #define MS_REG_OVR_PGST1 0x20
117 #define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
118 #define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
119 #define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 /* NG */
120 #define MS_REG_OVR_PGST_DATA_ERROR 0x00 /* data error */
121 #define MS_REG_OVR_UDST 0x10 /* update status */
122 #define MS_REG_OVR_UDST_UPDATING 0x00 /* updating */
123 #define MS_REG_OVR_UDST_NO_UPDATE MS_REG_OVR_UDST
124 #define MS_REG_OVR_RESERVED 0x08
125 #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)
127 /* Management Flag */
128 #define MS_REG_MNG_SCMS0 0x20 /* serial copy management system */
129 #define MS_REG_MNG_SCMS1 0x10
130 #define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
131 #define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
132 #define MS_REG_MNG_SCMS_ONE_COPY MS_REG_MNG_SCMS1
133 #define MS_REG_MNG_SCMS_NO_COPY 0x00
134 #define MS_REG_MNG_ATFLG 0x08 /* address transfer table flag */
135 #define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG /* other */
136 #define MS_REG_MNG_ATFLG_ATTBL 0x00 /* address transfer table */
137 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
138 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
139 #define MS_REG_MNG_SYSFLG_BOOT 0x00 /* system block */
140 #define MS_REG_MNG_RESERVED 0xc3
141 #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)
144 #define MS_MAX_PAGES_PER_BLOCK 32
145 #define MS_MAX_INITIAL_ERROR_BLOCKS 10
146 #define MS_LIB_BITS_PER_BYTE 8
148 #define MS_SYSINF_FORMAT_FAT 1
149 #define MS_SYSINF_USAGE_GENERAL 0
151 #define MS_SYSINF_MSCLASS_TYPE_1 1
152 #define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */
154 #define MS_SYSINF_CARDTYPE_RDONLY 1
155 #define MS_SYSINF_CARDTYPE_RDWR 2
156 #define MS_SYSINF_CARDTYPE_HYBRID 3
157 #define MS_SYSINF_SECURITY 0x01
158 #define MS_SYSINF_SECURITY_NO_SUPPORT MS_SYSINF_SECURITY
159 #define MS_SYSINF_SECURITY_SUPPORT 0
161 #define MS_SYSINF_RESERVED1 1
162 #define MS_SYSINF_RESERVED2 1
164 #define MS_SYSENT_TYPE_INVALID_BLOCK 0x01
165 #define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */
167 #define SIZE_OF_KIRO 1024
168 #define BYTE_MASK 0xff
171 #define MS_STATUS_WRITE_PROTECT 0x0106
172 #define MS_STATUS_SUCCESS 0x0000
173 #define MS_ERROR_FLASH_READ 0x8003
174 #define MS_ERROR_FLASH_ERASE 0x8005
175 #define MS_LB_ERROR 0xfff0
176 #define MS_LB_BOOT_BLOCK 0xfff1
177 #define MS_LB_INITIAL_ERROR 0xfff2
178 #define MS_STATUS_SUCCESS_WITH_ECC 0xfff3
179 #define MS_LB_ACQUIRED_ERROR 0xfff4
180 #define MS_LB_NOT_USED_ERASED 0xfff5
181 #define MS_NOCARD_ERROR 0xfff8
182 #define MS_NO_MEMORY_ERROR 0xfff9
183 #define MS_STATUS_INT_ERROR 0xfffa
184 #define MS_STATUS_ERROR 0xfffe
185 #define MS_LB_NOT_USED 0xffff
187 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
188 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
190 #define MS_BOOT_BLOCK_ID 0x0001
191 #define MS_BOOT_BLOCK_FORMAT_VERSION 0x0100
192 #define MS_BOOT_BLOCK_DATA_ENTRIES 2
194 #define MS_NUMBER_OF_SYSTEM_ENTRY 4
195 #define MS_NUMBER_OF_BOOT_BLOCK 2
196 #define MS_BYTES_PER_PAGE 512
197 #define MS_LOGICAL_BLOCKS_PER_SEGMENT 496
198 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT 494
200 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */
201 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff
204 #define MS_REG_OVR_BKST 0x80 /* block status */
205 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
206 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
208 /* Status Register 1 */
209 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
210 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
211 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
213 /* MemoryStick Register */
214 /* Status Register 0 */
215 #define MS_REG_ST0_WP 0x01 /* write protected */
216 #define MS_REG_ST0_WP_ON MS_REG_ST0_WP
218 #define MS_LIB_CTRL_RDONLY 0
219 #define MS_LIB_CTRL_WRPROTECT 1
222 #define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
223 #define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
225 #define ms_lib_ctrl_set(pdx, Flag) ((pdx)->MS_Lib.flags |= (1 << (Flag)))
226 #define ms_lib_ctrl_reset(pdx, Flag) ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
227 #define ms_lib_ctrl_check(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag)))
229 #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))
230 #define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
231 #define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0))
235 #define SD_Insert BIT(0)
236 #define SD_Ready BIT(1)
237 #define SD_MediaChange BIT(2)
238 #define SD_IsMMC BIT(3)
239 #define SD_HiCapacity BIT(4)
240 #define SD_HiSpeed BIT(5)
241 #define SD_WtP BIT(6)
245 #define MS_Insert BIT(0)
246 #define MS_Ready BIT(1)
247 #define MS_MediaChange BIT(2)
248 #define MS_IsMSPro BIT(3)
249 #define MS_IsMSPHG BIT(4)
251 #define MS_WtP BIT(6)
255 #define SM_Insert BIT(0)
256 #define SM_Ready BIT(1)
257 #define SM_MediaChange BIT(2)
258 /* Bits 3-5 reserved */
259 #define SM_WtP BIT(6)
260 #define SM_IsMS BIT(7)
262 struct ms_bootblock_cis {
263 u8 bCistplDEVICE[6]; /* 0 */
264 u8 bCistplDEVICE0C[6]; /* 6 */
265 u8 bCistplJEDECC[4]; /* 12 */
266 u8 bCistplMANFID[6]; /* 16 */
267 u8 bCistplVER1[32]; /* 22 */
268 u8 bCistplFUNCID[4]; /* 54 */
269 u8 bCistplFUNCE0[4]; /* 58 */
270 u8 bCistplFUNCE1[5]; /* 62 */
271 u8 bCistplCONF[7]; /* 67 */
272 u8 bCistplCFTBLENT0[10];/* 74 */
273 u8 bCistplCFTBLENT1[8]; /* 84 */
274 u8 bCistplCFTBLENT2[12];/* 92 */
275 u8 bCistplCFTBLENT3[8]; /* 104 */
276 u8 bCistplCFTBLENT4[17];/* 112 */
277 u8 bCistplCFTBLENT5[8]; /* 129 */
278 u8 bCistplCFTBLENT6[17];/* 137 */
279 u8 bCistplCFTBLENT7[8]; /* 154 */
280 u8 bCistplNOLINK[3]; /* 162 */
283 struct ms_bootblock_idi {
284 #define MS_IDI_GENERAL_CONF 0x848A
285 u16 wIDIgeneralConfiguration; /* 0 */
286 u16 wIDInumberOfCylinder; /* 1 */
287 u16 wIDIreserved0; /* 2 */
288 u16 wIDInumberOfHead; /* 3 */
289 u16 wIDIbytesPerTrack; /* 4 */
290 u16 wIDIbytesPerSector; /* 5 */
291 u16 wIDIsectorsPerTrack; /* 6 */
292 u16 wIDItotalSectors[2]; /* 7-8 high,low */
293 u16 wIDIreserved1[11]; /* 9-19 */
294 u16 wIDIbufferType; /* 20 */
295 u16 wIDIbufferSize; /* 21 */
296 u16 wIDIlongCmdECC; /* 22 */
297 u16 wIDIfirmVersion[4]; /* 23-26 */
298 u16 wIDImodelName[20]; /* 27-46 */
299 u16 wIDIreserved2; /* 47 */
300 u16 wIDIlongWordSupported; /* 48 */
301 u16 wIDIdmaSupported; /* 49 */
302 u16 wIDIreserved3; /* 50 */
303 u16 wIDIpioTiming; /* 51 */
304 u16 wIDIdmaTiming; /* 52 */
305 u16 wIDItransferParameter; /* 53 */
306 u16 wIDIformattedCylinder; /* 54 */
307 u16 wIDIformattedHead; /* 55 */
308 u16 wIDIformattedSectorsPerTrack;/* 56 */
309 u16 wIDIformattedTotalSectors[2];/* 57-58 */
310 u16 wIDImultiSector; /* 59 */
311 u16 wIDIlbaSectors[2]; /* 60-61 */
312 u16 wIDIsingleWordDMA; /* 62 */
313 u16 wIDImultiWordDMA; /* 63 */
314 u16 wIDIreserved4[192]; /* 64-255 */
317 struct ms_bootblock_sysent_rec {
324 struct ms_bootblock_sysent {
325 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
328 struct ms_bootblock_sysinf {
329 u8 bMsClass; /* must be 1 */
330 u8 bCardType; /* see below */
331 u16 wBlockSize; /* n KB */
332 u16 wBlockNumber; /* number of physical block */
333 u16 wTotalBlockNumber; /* number of logical block */
334 u16 wPageSize; /* must be 0x200 */
335 u8 bExtraSize; /* 0x10 */
339 u8 bAssemblyMakerCode;
340 u8 bAssemblyMachineCode[3];
341 u16 wMemoryMakerCode;
342 u16 wMemoryDeviceCode;
348 u16 wControllerChipNumber;
349 u16 wControllerFunction; /* New MS */
350 u8 bReserved3[9]; /* New MS */
351 u8 bParallelSupport; /* New MS */
352 u16 wFormatValue; /* New MS */
362 struct ms_bootblock_header {
366 u8 bNumberOfDataEntry;
370 struct ms_bootblock_page0 {
371 struct ms_bootblock_header header;
372 struct ms_bootblock_sysent sysent;
373 struct ms_bootblock_sysinf sysinf;
376 struct ms_bootblock_cis_idi {
378 struct ms_bootblock_cis cis;
383 struct ms_bootblock_idi idi;
389 /* ENE MS Lib struct */
390 struct ms_lib_type_extdat {
403 u32 NumberOfCylinder;
404 u32 SectorsPerCylinder;
405 u16 cardType; /* R/W, RO, Hybrid */
408 u16 NumberOfPhyBlock;
409 u16 NumberOfLogBlock;
411 u16 *Phy2LogMap; /* phy2log table */
412 u16 *Log2PhyMap; /* log2phy table */
414 unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
415 unsigned char *blkpag;
416 struct ms_lib_type_extdat *blkext;
417 unsigned char copybuf[512];
421 /* SD Block Length */
422 /* 2^9 = 512 Bytes, The HW maximum read/write data length */
423 #define SD_BLOCK_LEN 9
425 struct ene_ub6250_info {
427 /* I/O bounce buffer */
435 /* ----- SD Control Data ---------------- */
436 /*SD_REGISTER SD_Regs; */
442 /* SD/MMC New spec. */
445 u8 SD20_HIGH_CAPACITY;
449 u8 MMC_HIGH_CAPACITY;
451 /*----- MS Control Data ---------------- */
454 struct ms_lib_ctrl MS_Lib;
458 /*----- SM Control Data ---------------- */
462 unsigned char *testbuf;
467 /*------Power Managerment ---------------*/
471 static int ene_sd_init(struct us_data *us);
472 static int ene_ms_init(struct us_data *us);
473 static int ene_load_bincode(struct us_data *us, unsigned char flag);
475 static void ene_ub6250_info_destructor(void *extra)
477 struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra;
484 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
486 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
487 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
490 unsigned int residue;
491 unsigned int cswlen = 0, partial = 0;
492 unsigned int transfer_length = bcb->DataTransferLength;
494 /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
495 /* send cmd to out endpoint */
496 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
497 bcb, US_BULK_CB_WRAP_LEN, NULL);
498 if (result != USB_STOR_XFER_GOOD) {
499 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
500 return USB_STOR_TRANSPORT_ERROR;
504 unsigned int pipe = fDir;
506 if (fDir == FDIR_READ)
507 pipe = us->recv_bulk_pipe;
509 pipe = us->send_bulk_pipe;
513 result = usb_stor_bulk_srb(us, pipe, us->srb);
515 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
516 transfer_length, 0, &partial);
518 if (result != USB_STOR_XFER_GOOD) {
519 usb_stor_dbg(us, "data transfer fail ---\n");
520 return USB_STOR_TRANSPORT_ERROR;
524 /* Get CSW for device status */
525 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
526 US_BULK_CS_WRAP_LEN, &cswlen);
528 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
529 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
530 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
531 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
534 if (result == USB_STOR_XFER_STALLED) {
535 /* get the status again */
536 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
537 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
538 bcs, US_BULK_CS_WRAP_LEN, NULL);
541 if (result != USB_STOR_XFER_GOOD)
542 return USB_STOR_TRANSPORT_ERROR;
544 /* check bulk status */
545 residue = le32_to_cpu(bcs->Residue);
548 * try to compute the actual residue, based on how much data
549 * was really transferred and what the device tells us
551 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
552 residue = min(residue, transfer_length);
554 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
558 if (bcs->Status != US_BULK_STAT_OK)
559 return USB_STOR_TRANSPORT_ERROR;
561 return USB_STOR_TRANSPORT_GOOD;
564 static int do_scsi_request_sense(struct us_data *us, struct scsi_cmnd *srb)
566 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
567 unsigned char buf[18];
570 buf[0] = 0x70; /* Current error */
571 buf[2] = info->SrbStatus >> 16; /* Sense key */
572 buf[7] = 10; /* Additional length */
573 buf[12] = info->SrbStatus >> 8; /* ASC */
574 buf[13] = info->SrbStatus; /* ASCQ */
576 usb_stor_set_xfer_buf(buf, sizeof(buf), srb);
577 return USB_STOR_TRANSPORT_GOOD;
580 static int do_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
582 unsigned char data_ptr[36] = {
583 0x00, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
584 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
585 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
586 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
588 usb_stor_set_xfer_buf(data_ptr, 36, srb);
589 return USB_STOR_TRANSPORT_GOOD;
592 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
594 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
596 if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready))
597 return USB_STOR_TRANSPORT_GOOD;
600 return USB_STOR_TRANSPORT_GOOD;
603 return USB_STOR_TRANSPORT_GOOD;
606 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
608 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
609 unsigned char mediaNoWP[12] = {
610 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
611 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
612 unsigned char mediaWP[12] = {
613 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
614 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
616 if (info->SD_Status & SD_WtP)
617 usb_stor_set_xfer_buf(mediaWP, 12, srb);
619 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
622 return USB_STOR_TRANSPORT_GOOD;
625 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
629 unsigned int offset = 0;
630 unsigned char buf[8];
631 struct scatterlist *sg = NULL;
632 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
634 usb_stor_dbg(us, "sd_scsi_read_capacity\n");
635 if (info->SD_Status & SD_HiCapacity) {
637 if (info->SD_Status & SD_IsMMC)
638 bl_num = info->HC_C_SIZE-1;
640 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
642 bl_len = 1 << (info->SD_READ_BL_LEN);
643 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
644 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
646 info->bl_num = bl_num;
647 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
648 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
650 /*srb->request_bufflen = 8; */
651 buf[0] = (bl_num >> 24) & 0xff;
652 buf[1] = (bl_num >> 16) & 0xff;
653 buf[2] = (bl_num >> 8) & 0xff;
654 buf[3] = (bl_num >> 0) & 0xff;
655 buf[4] = (bl_len >> 24) & 0xff;
656 buf[5] = (bl_len >> 16) & 0xff;
657 buf[6] = (bl_len >> 8) & 0xff;
658 buf[7] = (bl_len >> 0) & 0xff;
660 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
662 return USB_STOR_TRANSPORT_GOOD;
665 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
668 unsigned char *cdb = srb->cmnd;
669 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
670 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
672 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
673 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
674 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
675 u32 bnByte = bn * 0x200;
676 u32 blenByte = blen * 0x200;
678 if (bn > info->bl_num)
679 return USB_STOR_TRANSPORT_ERROR;
681 result = ene_load_bincode(us, SD_RW_PATTERN);
682 if (result != USB_STOR_XFER_GOOD) {
683 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
684 return USB_STOR_TRANSPORT_ERROR;
687 if (info->SD_Status & SD_HiCapacity)
690 /* set up the command wrapper */
691 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
692 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
693 bcb->DataTransferLength = blenByte;
694 bcb->Flags = US_BULK_FLAG_IN;
696 bcb->CDB[5] = (unsigned char)(bnByte);
697 bcb->CDB[4] = (unsigned char)(bnByte>>8);
698 bcb->CDB[3] = (unsigned char)(bnByte>>16);
699 bcb->CDB[2] = (unsigned char)(bnByte>>24);
701 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
705 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
708 unsigned char *cdb = srb->cmnd;
709 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
710 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
712 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
713 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
714 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
715 u32 bnByte = bn * 0x200;
716 u32 blenByte = blen * 0x200;
718 if (bn > info->bl_num)
719 return USB_STOR_TRANSPORT_ERROR;
721 result = ene_load_bincode(us, SD_RW_PATTERN);
722 if (result != USB_STOR_XFER_GOOD) {
723 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
724 return USB_STOR_TRANSPORT_ERROR;
727 if (info->SD_Status & SD_HiCapacity)
730 /* set up the command wrapper */
731 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
732 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
733 bcb->DataTransferLength = blenByte;
736 bcb->CDB[5] = (unsigned char)(bnByte);
737 bcb->CDB[4] = (unsigned char)(bnByte>>8);
738 bcb->CDB[3] = (unsigned char)(bnByte>>16);
739 bcb->CDB[2] = (unsigned char)(bnByte>>24);
741 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
749 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
751 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
753 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
756 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
757 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
762 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
764 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
766 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
769 info->MS_Lib.Phy2LogMap[phyblk] = mark;
774 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
776 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
779 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
781 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
784 static int ms_lib_free_logicalmap(struct us_data *us)
786 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
788 kfree(info->MS_Lib.Phy2LogMap);
789 info->MS_Lib.Phy2LogMap = NULL;
791 kfree(info->MS_Lib.Log2PhyMap);
792 info->MS_Lib.Log2PhyMap = NULL;
797 static int ms_lib_alloc_logicalmap(struct us_data *us)
800 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
802 info->MS_Lib.Phy2LogMap = kmalloc_array(info->MS_Lib.NumberOfPhyBlock,
805 info->MS_Lib.Log2PhyMap = kmalloc_array(info->MS_Lib.NumberOfLogBlock,
809 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
810 ms_lib_free_logicalmap(us);
814 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
815 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
817 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
818 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
823 static void ms_lib_clear_writebuf(struct us_data *us)
826 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
828 info->MS_Lib.wrtblk = (u16)-1;
829 ms_lib_clear_pagemap(info);
831 if (info->MS_Lib.blkpag)
832 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
834 if (info->MS_Lib.blkext) {
835 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
836 info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
837 info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
838 info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
839 info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
844 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
847 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
849 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
850 for (Count = 0; PhyBlock < Ende; PhyBlock++) {
851 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
853 case MS_LB_NOT_USED_ERASED:
863 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
864 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
866 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
867 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
868 u8 *bbuf = info->bbuf;
870 u32 bn = PhyBlockAddr * 0x20 + PageNum;
872 result = ene_load_bincode(us, MS_RW_PATTERN);
873 if (result != USB_STOR_XFER_GOOD)
874 return USB_STOR_TRANSPORT_ERROR;
877 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
878 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
879 bcb->DataTransferLength = 0x200;
880 bcb->Flags = US_BULK_FLAG_IN;
883 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
885 bcb->CDB[5] = (unsigned char)(bn);
886 bcb->CDB[4] = (unsigned char)(bn>>8);
887 bcb->CDB[3] = (unsigned char)(bn>>16);
888 bcb->CDB[2] = (unsigned char)(bn>>24);
890 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
891 if (result != USB_STOR_XFER_GOOD)
892 return USB_STOR_TRANSPORT_ERROR;
895 /* Read Extra Data */
896 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
897 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
898 bcb->DataTransferLength = 0x4;
899 bcb->Flags = US_BULK_FLAG_IN;
903 bcb->CDB[5] = (unsigned char)(PageNum);
904 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
905 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
906 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
909 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
910 if (result != USB_STOR_XFER_GOOD)
911 return USB_STOR_TRANSPORT_ERROR;
913 ExtraDat->reserved = 0;
914 ExtraDat->intr = 0x80; /* Not yet,fireware support */
915 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
917 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
918 ExtraDat->ovrflg = bbuf[0];
919 ExtraDat->mngflg = bbuf[1];
920 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
922 return USB_STOR_TRANSPORT_GOOD;
925 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
927 struct ms_bootblock_sysent *SysEntry;
928 struct ms_bootblock_sysinf *SysInfo;
932 struct ms_lib_type_extdat ExtraData;
933 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
935 PageBuffer = kzalloc(MS_BYTES_PER_PAGE * 2, GFP_KERNEL);
936 if (PageBuffer == NULL)
941 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
943 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
944 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
945 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
946 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
947 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
948 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
949 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
952 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
953 case MS_SYSINF_CARDTYPE_RDONLY:
954 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
956 case MS_SYSINF_CARDTYPE_RDWR:
957 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
959 case MS_SYSINF_CARDTYPE_HYBRID:
964 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
965 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
966 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
967 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
968 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
969 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
971 /*Allocate to all number of logicalblock and physicalblock */
972 if (ms_lib_alloc_logicalmap(us))
975 /* Mark the book block */
976 ms_lib_set_bootblockmark(us, PhyBlock);
978 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
980 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
981 u32 EntryOffset, EntrySize;
983 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
985 if (EntryOffset == 0xffffff)
987 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
992 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
996 u8 PrevPageNumber = 0;
999 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
1002 while (EntrySize > 0) {
1004 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1005 if (PageNumber != PrevPageNumber) {
1006 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1007 case MS_STATUS_SUCCESS:
1009 case MS_STATUS_WRITE_PROTECT:
1010 case MS_ERROR_FLASH_READ:
1011 case MS_STATUS_ERROR:
1016 PrevPageNumber = PageNumber;
1019 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1020 if (phyblk < 0x0fff)
1021 ms_lib_set_initialerrorblock(us, phyblk);
1026 } else if (i == 1) { /* CIS/IDI */
1027 struct ms_bootblock_idi *idi;
1029 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1032 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1033 case MS_STATUS_SUCCESS:
1035 case MS_STATUS_WRITE_PROTECT:
1036 case MS_ERROR_FLASH_READ:
1037 case MS_STATUS_ERROR:
1042 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1043 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1046 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1047 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1056 ms_lib_free_logicalmap(us);
1064 static void ms_lib_free_writebuf(struct us_data *us)
1066 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1067 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1069 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1071 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1073 if (info->MS_Lib.blkpag) {
1074 kfree(info->MS_Lib.blkpag); /* Arnold test ... */
1075 info->MS_Lib.blkpag = NULL;
1078 if (info->MS_Lib.blkext) {
1079 kfree(info->MS_Lib.blkext); /* Arnold test ... */
1080 info->MS_Lib.blkext = NULL;
1085 static void ms_lib_free_allocatedarea(struct us_data *us)
1087 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1089 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1090 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1092 /* set struct us point flag to 0 */
1093 info->MS_Lib.flags = 0;
1094 info->MS_Lib.BytesPerSector = 0;
1095 info->MS_Lib.SectorsPerCylinder = 0;
1097 info->MS_Lib.cardType = 0;
1098 info->MS_Lib.blockSize = 0;
1099 info->MS_Lib.PagesPerBlock = 0;
1101 info->MS_Lib.NumberOfPhyBlock = 0;
1102 info->MS_Lib.NumberOfLogBlock = 0;
1106 static int ms_lib_alloc_writebuf(struct us_data *us)
1108 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1110 info->MS_Lib.wrtblk = (u16)-1;
1112 info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock,
1113 info->MS_Lib.BytesPerSector,
1115 info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock,
1116 sizeof(struct ms_lib_type_extdat),
1119 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1120 ms_lib_free_writebuf(us);
1124 ms_lib_clear_writebuf(us);
1129 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1131 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1133 if (logblk == MS_LB_NOT_USED)
1136 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1137 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1140 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1141 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1146 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1147 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1149 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1152 result = ene_load_bincode(us, MS_RW_PATTERN);
1153 if (result != USB_STOR_XFER_GOOD)
1154 return USB_STOR_TRANSPORT_ERROR;
1156 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1157 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1158 bcb->DataTransferLength = 0x200*len;
1162 bcb->CDB[4] = (unsigned char)(oldphy);
1163 bcb->CDB[3] = (unsigned char)(oldphy>>8);
1164 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1165 bcb->CDB[7] = (unsigned char)(newphy);
1166 bcb->CDB[6] = (unsigned char)(newphy>>8);
1167 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1168 bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1169 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1170 bcb->CDB[10] = PageNum;
1172 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1173 if (result != USB_STOR_XFER_GOOD)
1174 return USB_STOR_TRANSPORT_ERROR;
1176 return USB_STOR_TRANSPORT_GOOD;
1179 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1181 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1183 u32 bn = PhyBlockAddr;
1185 result = ene_load_bincode(us, MS_RW_PATTERN);
1186 if (result != USB_STOR_XFER_GOOD)
1187 return USB_STOR_TRANSPORT_ERROR;
1189 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1190 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1191 bcb->DataTransferLength = 0x200;
1192 bcb->Flags = US_BULK_FLAG_IN;
1195 bcb->CDB[4] = (unsigned char)(bn);
1196 bcb->CDB[3] = (unsigned char)(bn>>8);
1197 bcb->CDB[2] = (unsigned char)(bn>>16);
1199 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1200 if (result != USB_STOR_XFER_GOOD)
1201 return USB_STOR_TRANSPORT_ERROR;
1203 return USB_STOR_TRANSPORT_GOOD;
1206 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1208 unsigned char *PageBuf = NULL;
1209 u16 result = MS_STATUS_SUCCESS;
1211 struct ms_lib_type_extdat extdat;
1212 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1214 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1215 if (PageBuf == NULL) {
1216 result = MS_NO_MEMORY_ERROR;
1220 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1222 blk = be16_to_cpu(PageBuf[index]);
1223 if (blk == MS_LB_NOT_USED)
1225 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1226 result = MS_ERROR_FLASH_READ;
1237 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1240 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1242 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1245 log = info->MS_Lib.Phy2LogMap[phyblk];
1247 if (log < info->MS_Lib.NumberOfLogBlock)
1248 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1250 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1251 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1256 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1257 u8 PageNum, u8 OverwriteFlag)
1259 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1262 result = ene_load_bincode(us, MS_RW_PATTERN);
1263 if (result != USB_STOR_XFER_GOOD)
1264 return USB_STOR_TRANSPORT_ERROR;
1266 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1267 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1268 bcb->DataTransferLength = 0x4;
1269 bcb->Flags = US_BULK_FLAG_IN;
1272 bcb->CDB[5] = (unsigned char)(PageNum);
1273 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1274 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1275 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1276 bcb->CDB[6] = OverwriteFlag;
1281 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1282 if (result != USB_STOR_XFER_GOOD)
1283 return USB_STOR_TRANSPORT_ERROR;
1285 return USB_STOR_TRANSPORT_GOOD;
1288 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1290 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1292 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1293 return MS_STATUS_ERROR;
1295 ms_lib_setacquired_errorblock(us, phyblk);
1297 if (ms_lib_iswritable(info))
1298 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1300 return MS_STATUS_SUCCESS;
1303 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1306 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1308 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1309 return MS_STATUS_ERROR;
1311 log = info->MS_Lib.Phy2LogMap[phyblk];
1313 if (log < info->MS_Lib.NumberOfLogBlock)
1314 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1316 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1318 if (ms_lib_iswritable(info)) {
1319 switch (ms_read_eraseblock(us, phyblk)) {
1320 case MS_STATUS_SUCCESS:
1321 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1322 return MS_STATUS_SUCCESS;
1323 case MS_ERROR_FLASH_ERASE:
1324 case MS_STATUS_INT_ERROR:
1325 ms_lib_error_phyblock(us, phyblk);
1326 return MS_ERROR_FLASH_ERASE;
1327 case MS_STATUS_ERROR:
1329 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1330 ms_lib_setacquired_errorblock(us, phyblk);
1331 return MS_STATUS_ERROR;
1335 ms_lib_setacquired_errorblock(us, phyblk);
1337 return MS_STATUS_SUCCESS;
1340 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1341 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1343 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1344 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1345 u8 *bbuf = info->bbuf;
1348 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1349 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1350 bcb->DataTransferLength = 0x4;
1351 bcb->Flags = US_BULK_FLAG_IN;
1354 bcb->CDB[5] = (unsigned char)(PageNum);
1355 bcb->CDB[4] = (unsigned char)(PhyBlock);
1356 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1357 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1360 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1361 if (result != USB_STOR_XFER_GOOD)
1362 return USB_STOR_TRANSPORT_ERROR;
1364 ExtraDat->reserved = 0;
1365 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
1366 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
1367 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
1368 ExtraDat->ovrflg = bbuf[0];
1369 ExtraDat->mngflg = bbuf[1];
1370 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
1372 return USB_STOR_TRANSPORT_GOOD;
1375 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1378 struct ms_lib_type_extdat extdat; /* need check */
1379 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1382 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1385 for (blk = phyblk + 1; blk != phyblk; blk++) {
1386 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1387 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1389 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1391 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1392 switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1393 case MS_STATUS_SUCCESS:
1394 case MS_STATUS_SUCCESS_WITH_ECC:
1396 case MS_NOCARD_ERROR:
1397 return MS_NOCARD_ERROR;
1398 case MS_STATUS_INT_ERROR:
1400 case MS_ERROR_FLASH_READ:
1402 ms_lib_setacquired_errorblock(us, blk);
1406 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1407 ms_lib_setacquired_errorblock(us, blk);
1411 switch (ms_lib_erase_phyblock(us, blk)) {
1412 case MS_STATUS_SUCCESS:
1414 case MS_STATUS_ERROR:
1416 case MS_ERROR_FLASH_ERASE:
1418 ms_lib_error_phyblock(us, blk);
1426 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1429 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1431 phyblk = ms_libconv_to_physical(info, logblk);
1432 if (phyblk >= MS_LB_ERROR) {
1433 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1436 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1437 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1438 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1441 return ms_libsearch_block_from_physical(us, phyblk);
1444 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1446 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1448 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1449 if ((info->MS_Status & MS_Insert) && (info->MS_Status & MS_Ready)) {
1450 return USB_STOR_TRANSPORT_GOOD;
1453 return USB_STOR_TRANSPORT_GOOD;
1456 return USB_STOR_TRANSPORT_GOOD;
1459 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1461 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1462 unsigned char mediaNoWP[12] = {
1463 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1464 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1465 unsigned char mediaWP[12] = {
1466 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1467 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1469 if (info->MS_Status & MS_WtP)
1470 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1472 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1474 return USB_STOR_TRANSPORT_GOOD;
1477 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1481 unsigned int offset = 0;
1482 unsigned char buf[8];
1483 struct scatterlist *sg = NULL;
1484 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1486 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1488 if (info->MS_Status & MS_IsMSPro)
1489 bl_num = info->MSP_TotalBlock - 1;
1491 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1493 info->bl_num = bl_num;
1494 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1495 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1497 /*srb->request_bufflen = 8; */
1498 buf[0] = (bl_num >> 24) & 0xff;
1499 buf[1] = (bl_num >> 16) & 0xff;
1500 buf[2] = (bl_num >> 8) & 0xff;
1501 buf[3] = (bl_num >> 0) & 0xff;
1502 buf[4] = (bl_len >> 24) & 0xff;
1503 buf[5] = (bl_len >> 16) & 0xff;
1504 buf[6] = (bl_len >> 8) & 0xff;
1505 buf[7] = (bl_len >> 0) & 0xff;
1507 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1509 return USB_STOR_TRANSPORT_GOOD;
1512 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1514 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1517 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1518 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1521 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1525 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1526 u8 PageNum, u8 blen, void *buf)
1528 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1531 /* Read Extra Data */
1532 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1533 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1534 bcb->DataTransferLength = 0x4 * blen;
1535 bcb->Flags = US_BULK_FLAG_IN;
1538 bcb->CDB[5] = (unsigned char)(PageNum);
1539 bcb->CDB[4] = (unsigned char)(PhyBlock);
1540 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1541 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1544 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1545 if (result != USB_STOR_XFER_GOOD)
1546 return USB_STOR_TRANSPORT_ERROR;
1548 return USB_STOR_TRANSPORT_GOOD;
1551 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1553 u16 PhyBlock, newblk, i;
1554 u16 LogStart, LogEnde;
1555 struct ms_lib_type_extdat extdat;
1556 u32 count = 0, index = 0;
1557 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1558 u8 *bbuf = info->bbuf;
1560 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1561 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1563 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1564 switch (ms_libconv_to_logical(info, PhyBlock)) {
1565 case MS_STATUS_ERROR:
1571 if (count == PhyBlock) {
1572 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1576 index = (PhyBlock % 0x80) * 4;
1578 extdat.ovrflg = bbuf[index];
1579 extdat.mngflg = bbuf[index+1];
1580 extdat.logadr = memstick_logaddr(bbuf[index+2],
1583 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1584 ms_lib_setacquired_errorblock(us, PhyBlock);
1588 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1589 ms_lib_erase_phyblock(us, PhyBlock);
1593 if (extdat.logadr != MS_LB_NOT_USED) {
1594 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1595 ms_lib_erase_phyblock(us, PhyBlock);
1599 newblk = ms_libconv_to_physical(info, extdat.logadr);
1601 if (newblk != MS_LB_NOT_USED) {
1602 if (extdat.logadr == 0) {
1603 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1604 if (ms_lib_check_disableblock(us, btBlk1st)) {
1605 ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1610 ms_lib_read_extra(us, newblk, 0, &extdat);
1611 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1612 ms_lib_erase_phyblock(us, PhyBlock);
1615 ms_lib_erase_phyblock(us, newblk);
1619 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1624 return MS_STATUS_SUCCESS;
1628 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1631 unsigned char *cdb = srb->cmnd;
1632 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1633 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1635 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1636 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1637 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1638 u32 blenByte = blen * 0x200;
1640 if (bn > info->bl_num)
1641 return USB_STOR_TRANSPORT_ERROR;
1643 if (info->MS_Status & MS_IsMSPro) {
1644 result = ene_load_bincode(us, MSP_RW_PATTERN);
1645 if (result != USB_STOR_XFER_GOOD) {
1646 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1647 return USB_STOR_TRANSPORT_ERROR;
1650 /* set up the command wrapper */
1651 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1652 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1653 bcb->DataTransferLength = blenByte;
1654 bcb->Flags = US_BULK_FLAG_IN;
1657 bcb->CDB[5] = (unsigned char)(bn);
1658 bcb->CDB[4] = (unsigned char)(bn>>8);
1659 bcb->CDB[3] = (unsigned char)(bn>>16);
1660 bcb->CDB[2] = (unsigned char)(bn>>24);
1662 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1671 buf = kmalloc(blenByte, GFP_KERNEL);
1673 return USB_STOR_TRANSPORT_ERROR;
1675 result = ene_load_bincode(us, MS_RW_PATTERN);
1676 if (result != USB_STOR_XFER_GOOD) {
1677 pr_info("Load MS RW pattern Fail !!\n");
1678 result = USB_STOR_TRANSPORT_ERROR;
1682 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1683 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1686 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1687 len = info->MS_Lib.PagesPerBlock-PageNum;
1691 phyblk = ms_libconv_to_physical(info, logblk);
1692 blkno = phyblk * 0x20 + PageNum;
1694 /* set up the command wrapper */
1695 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1696 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1697 bcb->DataTransferLength = 0x200 * len;
1698 bcb->Flags = US_BULK_FLAG_IN;
1701 bcb->CDB[5] = (unsigned char)(blkno);
1702 bcb->CDB[4] = (unsigned char)(blkno>>8);
1703 bcb->CDB[3] = (unsigned char)(blkno>>16);
1704 bcb->CDB[2] = (unsigned char)(blkno>>24);
1706 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1707 if (result != USB_STOR_XFER_GOOD) {
1708 pr_info("MS_SCSI_Read --- result = %x\n", result);
1709 result = USB_STOR_TRANSPORT_ERROR;
1718 offset += MS_BYTES_PER_PAGE*len;
1720 usb_stor_set_xfer_buf(buf, blenByte, srb);
1727 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1730 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1731 unsigned char *cdb = srb->cmnd;
1732 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1734 u32 bn = ((cdb[2] << 24) & 0xff000000) |
1735 ((cdb[3] << 16) & 0x00ff0000) |
1736 ((cdb[4] << 8) & 0x0000ff00) |
1737 ((cdb[5] << 0) & 0x000000ff);
1738 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1739 u32 blenByte = blen * 0x200;
1741 if (bn > info->bl_num)
1742 return USB_STOR_TRANSPORT_ERROR;
1744 if (info->MS_Status & MS_IsMSPro) {
1745 result = ene_load_bincode(us, MSP_RW_PATTERN);
1746 if (result != USB_STOR_XFER_GOOD) {
1747 pr_info("Load MSP RW pattern Fail !!\n");
1748 return USB_STOR_TRANSPORT_ERROR;
1751 /* set up the command wrapper */
1752 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1753 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1754 bcb->DataTransferLength = blenByte;
1758 bcb->CDB[5] = (unsigned char)(bn);
1759 bcb->CDB[4] = (unsigned char)(bn>>8);
1760 bcb->CDB[3] = (unsigned char)(bn>>16);
1761 bcb->CDB[2] = (unsigned char)(bn>>24);
1763 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1769 u16 len, oldphy, newphy;
1771 buf = kmalloc(blenByte, GFP_KERNEL);
1773 return USB_STOR_TRANSPORT_ERROR;
1774 usb_stor_set_xfer_buf(buf, blenByte, srb);
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;
1783 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1784 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1787 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1788 len = info->MS_Lib.PagesPerBlock-PageNum;
1792 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1793 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1795 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1797 if (result != USB_STOR_XFER_GOOD) {
1798 pr_info("MS_SCSI_Write --- result = %x\n", result);
1799 result = USB_STOR_TRANSPORT_ERROR;
1803 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1804 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1811 offset += MS_BYTES_PER_PAGE*len;
1823 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1825 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
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 = US_BULK_FLAG_IN;
1833 bcb->CDB[2] = (unsigned char)(index>>8);
1834 bcb->CDB[3] = (unsigned char)index;
1836 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1840 static int ene_get_card_status(struct us_data *us, u8 *buf)
1844 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1846 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1847 reg4b = *(u32 *)&buf[0x18];
1848 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1850 tmpreg = (u16) reg4b;
1851 reg4b = *(u32 *)(&buf[0x14]);
1852 if ((info->SD_Status & SD_HiCapacity) && !(info->SD_Status & SD_IsMMC))
1853 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
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 & SD_HiCapacity) && (info->SD_Status & SD_IsMMC))
1858 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
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;
1864 info->SD_Block_Mult = 1;
1867 return USB_STOR_TRANSPORT_GOOD;
1870 static int ene_load_bincode(struct us_data *us, unsigned char flag)
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;
1880 if (info->BIN_FLAG == flag)
1881 return USB_STOR_TRANSPORT_GOOD;
1885 case SD_INIT1_PATTERN:
1886 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1887 fw_name = SD_INIT1_FIRMWARE;
1889 case SD_INIT2_PATTERN:
1890 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1891 fw_name = SD_INIT2_FIRMWARE;
1894 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1895 fw_name = SD_RW_FIRMWARE;
1898 case MS_INIT_PATTERN:
1899 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1900 fw_name = MS_INIT_FIRMWARE;
1902 case MSP_RW_PATTERN:
1903 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1904 fw_name = MSP_RW_FIRMWARE;
1907 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1908 fw_name = MS_RW_FIRMWARE;
1911 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1915 err = reject_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1917 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1920 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1924 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1925 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1926 bcb->DataTransferLength = sd_fw->size;
1930 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1931 if (us->srb != NULL)
1932 scsi_set_resid(us->srb, 0);
1933 info->BIN_FLAG = flag;
1937 release_firmware(sd_fw);
1941 static int ms_card_init(struct us_data *us)
1945 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1946 struct ms_lib_type_extdat extdat;
1947 u16 btBlk1st, btBlk2nd;
1949 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1951 printk(KERN_INFO "MS_CardInit start\n");
1953 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1955 /* get two PageBuffer */
1956 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1957 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1958 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1959 result = MS_NO_MEMORY_ERROR;
1963 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1966 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1968 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1969 case MS_STATUS_SUCCESS:
1971 case MS_STATUS_INT_ERROR:
1973 case MS_STATUS_ERROR:
1978 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1981 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1982 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1983 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1984 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1987 if (btBlk1st != MS_LB_NOT_USED) {
1988 btBlk2nd = TmpBlock;
1992 btBlk1st = TmpBlock;
1993 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
1994 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
1998 if (btBlk1st == MS_LB_NOT_USED) {
1999 result = MS_STATUS_ERROR;
2004 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2005 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2007 result = MS_STATUS_ERROR;
2008 /* 1st Boot Block */
2009 if (btBlk1stErred == 0)
2010 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2012 /* 2nd Boot Block */
2013 if (result && (btBlk2nd != MS_LB_NOT_USED))
2014 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2017 result = MS_STATUS_ERROR;
2021 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2022 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2024 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2026 if (btBlk2nd != MS_LB_NOT_USED) {
2027 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2028 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2030 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2033 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2037 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2038 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2039 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2040 if (ms_count_freeblock(us, TmpBlock) == 0) {
2041 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2047 if (ms_lib_alloc_writebuf(us)) {
2048 result = MS_NO_MEMORY_ERROR;
2052 result = MS_STATUS_SUCCESS;
2058 printk(KERN_INFO "MS_CardInit end\n");
2062 static int ene_ms_init(struct us_data *us)
2064 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2066 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2067 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2068 u8 *bbuf = info->bbuf;
2071 printk(KERN_INFO "transport --- ENE_MSInit\n");
2073 /* the same part to test ENE */
2075 result = ene_load_bincode(us, MS_INIT_PATTERN);
2076 if (result != USB_STOR_XFER_GOOD) {
2077 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2078 return USB_STOR_TRANSPORT_ERROR;
2081 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2082 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2083 bcb->DataTransferLength = 0x200;
2084 bcb->Flags = US_BULK_FLAG_IN;
2088 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2089 if (result != USB_STOR_XFER_GOOD) {
2090 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2091 return USB_STOR_TRANSPORT_ERROR;
2093 /* the same part to test ENE */
2094 info->MS_Status = bbuf[0];
2096 s = info->MS_Status;
2097 if ((s & MS_Insert) && (s & MS_Ready)) {
2098 printk(KERN_INFO "Insert = %x\n", !!(s & MS_Insert));
2099 printk(KERN_INFO "Ready = %x\n", !!(s & MS_Ready));
2100 printk(KERN_INFO "IsMSPro = %x\n", !!(s & MS_IsMSPro));
2101 printk(KERN_INFO "IsMSPHG = %x\n", !!(s & MS_IsMSPHG));
2102 printk(KERN_INFO "WtP= %x\n", !!(s & MS_WtP));
2103 if (s & MS_IsMSPro) {
2104 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7];
2105 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
2106 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2108 ms_card_init(us); /* Card is MS (to ms.c)*/
2110 usb_stor_dbg(us, "MS Init Code OK !!\n");
2112 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
2113 return USB_STOR_TRANSPORT_ERROR;
2116 return USB_STOR_TRANSPORT_GOOD;
2119 static int ene_sd_init(struct us_data *us)
2122 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2123 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2124 u8 *bbuf = info->bbuf;
2126 usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2127 /* SD Init Part-1 */
2128 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2129 if (result != USB_STOR_XFER_GOOD) {
2130 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2131 return USB_STOR_TRANSPORT_ERROR;
2134 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2135 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2136 bcb->Flags = US_BULK_FLAG_IN;
2139 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2140 if (result != USB_STOR_XFER_GOOD) {
2141 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2142 return USB_STOR_TRANSPORT_ERROR;
2145 /* SD Init Part-2 */
2146 result = ene_load_bincode(us, SD_INIT2_PATTERN);
2147 if (result != USB_STOR_XFER_GOOD) {
2148 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2149 return USB_STOR_TRANSPORT_ERROR;
2152 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2153 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2154 bcb->DataTransferLength = 0x200;
2155 bcb->Flags = US_BULK_FLAG_IN;
2158 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2159 if (result != USB_STOR_XFER_GOOD) {
2160 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2161 return USB_STOR_TRANSPORT_ERROR;
2164 info->SD_Status = bbuf[0];
2165 if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready)) {
2166 unsigned int s = info->SD_Status;
2168 ene_get_card_status(us, bbuf);
2169 usb_stor_dbg(us, "Insert = %x\n", !!(s & SD_Insert));
2170 usb_stor_dbg(us, "Ready = %x\n", !!(s & SD_Ready));
2171 usb_stor_dbg(us, "IsMMC = %x\n", !!(s & SD_IsMMC));
2172 usb_stor_dbg(us, "HiCapacity = %x\n", !!(s & SD_HiCapacity));
2173 usb_stor_dbg(us, "HiSpeed = %x\n", !!(s & SD_HiSpeed));
2174 usb_stor_dbg(us, "WtP = %x\n", !!(s & SD_WtP));
2176 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
2177 return USB_STOR_TRANSPORT_ERROR;
2179 return USB_STOR_TRANSPORT_GOOD;
2183 static int ene_init(struct us_data *us)
2187 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2188 u8 *bbuf = info->bbuf;
2190 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
2191 if (result != USB_STOR_XFER_GOOD)
2192 return USB_STOR_TRANSPORT_ERROR;
2194 misc_reg03 = bbuf[0];
2195 if (misc_reg03 & 0x01) {
2196 if (!(info->SD_Status & SD_Ready)) {
2197 result = ene_sd_init(us);
2198 if (result != USB_STOR_XFER_GOOD)
2199 return USB_STOR_TRANSPORT_ERROR;
2202 if (misc_reg03 & 0x02) {
2203 if (!(info->MS_Status & MS_Ready)) {
2204 result = ene_ms_init(us);
2205 if (result != USB_STOR_XFER_GOOD)
2206 return USB_STOR_TRANSPORT_ERROR;
2212 /*----- sd_scsi_irp() ---------*/
2213 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2216 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2218 switch (srb->cmnd[0]) {
2219 case TEST_UNIT_READY:
2220 result = sd_scsi_test_unit_ready(us, srb);
2223 result = do_scsi_request_sense(us, srb);
2226 result = do_scsi_inquiry(us, srb);
2229 result = sd_scsi_mode_sense(us, srb);
2233 result = SD_SCSI_Start_Stop(us, srb);
2237 result = sd_scsi_read_capacity(us, srb);
2240 result = sd_scsi_read(us, srb);
2243 result = sd_scsi_write(us, srb);
2246 info->SrbStatus = SS_ILLEGAL_REQUEST;
2247 result = USB_STOR_TRANSPORT_FAILED;
2250 if (result == USB_STOR_TRANSPORT_GOOD)
2251 info->SrbStatus = SS_SUCCESS;
2258 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2261 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2263 switch (srb->cmnd[0]) {
2264 case TEST_UNIT_READY:
2265 result = ms_scsi_test_unit_ready(us, srb);
2268 result = do_scsi_request_sense(us, srb);
2271 result = do_scsi_inquiry(us, srb);
2274 result = ms_scsi_mode_sense(us, srb);
2277 result = ms_scsi_read_capacity(us, srb);
2280 result = ms_scsi_read(us, srb);
2283 result = ms_scsi_write(us, srb);
2286 info->SrbStatus = SS_ILLEGAL_REQUEST;
2287 result = USB_STOR_TRANSPORT_FAILED;
2290 if (result == USB_STOR_TRANSPORT_GOOD)
2291 info->SrbStatus = SS_SUCCESS;
2295 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2297 int result = USB_STOR_XFER_GOOD;
2298 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2300 /*US_DEBUG(usb_stor_show_command(us, srb)); */
2301 scsi_set_resid(srb, 0);
2302 if (unlikely(!(info->SD_Status & SD_Ready) || (info->MS_Status & MS_Ready)))
2303 result = ene_init(us);
2304 if (result == USB_STOR_XFER_GOOD) {
2305 result = USB_STOR_TRANSPORT_ERROR;
2306 if (info->SD_Status & SD_Ready)
2307 result = sd_scsi_irp(us, srb);
2309 if (info->MS_Status & MS_Ready)
2310 result = ms_scsi_irp(us, srb);
2315 static struct scsi_host_template ene_ub6250_host_template;
2317 static int ene_ub6250_probe(struct usb_interface *intf,
2318 const struct usb_device_id *id)
2323 struct ene_ub6250_info *info;
2325 result = usb_stor_probe1(&us, intf, id,
2326 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2327 &ene_ub6250_host_template);
2331 /* FIXME: where should the code alloc extra buf ? */
2332 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2335 us->extra_destructor = ene_ub6250_info_destructor;
2337 info = (struct ene_ub6250_info *)(us->extra);
2338 info->bbuf = kmalloc(512, GFP_KERNEL);
2344 us->transport_name = "ene_ub6250";
2345 us->transport = ene_transport;
2348 result = usb_stor_probe2(us);
2352 /* probe card type */
2353 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2354 if (result != USB_STOR_XFER_GOOD) {
2355 usb_stor_disconnect(intf);
2356 return USB_STOR_TRANSPORT_ERROR;
2359 misc_reg03 = info->bbuf[0];
2360 if (!(misc_reg03 & 0x01)) {
2361 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2362 "It does not support SM cards.\n");
2371 static int ene_ub6250_resume(struct usb_interface *iface)
2373 struct us_data *us = usb_get_intfdata(iface);
2374 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2376 mutex_lock(&us->dev_mutex);
2378 if (us->suspend_resume_hook)
2379 (us->suspend_resume_hook)(us, US_RESUME);
2381 mutex_unlock(&us->dev_mutex);
2383 info->Power_IsResum = true;
2384 /* info->SD_Status &= ~SD_Ready; */
2385 info->SD_Status = 0;
2386 info->MS_Status = 0;
2387 info->SM_Status = 0;
2392 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2394 struct us_data *us = usb_get_intfdata(iface);
2395 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2397 /* Report the reset to the SCSI core */
2398 usb_stor_reset_resume(iface);
2401 * FIXME: Notify the subdrivers that they need to reinitialize
2404 info->Power_IsResum = true;
2405 /* info->SD_Status &= ~SD_Ready; */
2406 info->SD_Status = 0;
2407 info->MS_Status = 0;
2408 info->SM_Status = 0;
2415 #define ene_ub6250_resume NULL
2416 #define ene_ub6250_reset_resume NULL
2420 static struct usb_driver ene_ub6250_driver = {
2422 .probe = ene_ub6250_probe,
2423 .disconnect = usb_stor_disconnect,
2424 .suspend = usb_stor_suspend,
2425 .resume = ene_ub6250_resume,
2426 .reset_resume = ene_ub6250_reset_resume,
2427 .pre_reset = usb_stor_pre_reset,
2428 .post_reset = usb_stor_post_reset,
2429 .id_table = ene_ub6250_usb_ids,
2434 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);