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
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>
28 #include "transport.h"
33 #define SD_INIT1_FIRMWARE "/*(DEBLOBBED)*/"
34 #define SD_INIT2_FIRMWARE "/*(DEBLOBBED)*/"
35 #define SD_RW_FIRMWARE "/*(DEBLOBBED)*/"
36 #define MS_INIT_FIRMWARE "/*(DEBLOBBED)*/"
37 #define MSP_RW_FIRMWARE "/*(DEBLOBBED)*/"
38 #define MS_RW_FIRMWARE "/*(DEBLOBBED)*/"
40 #define DRV_NAME "ums_eneub6250"
42 MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
43 MODULE_LICENSE("GPL");
47 * The table of devices
49 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
50 vendorName, productName, useProtocol, useTransport, \
51 initFunction, flags) \
52 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
53 .driver_info = (flags)}
55 static struct usb_device_id ene_ub6250_usb_ids[] = {
56 # include "unusual_ene_ub6250.h"
57 { } /* Terminating entry */
59 MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
66 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
67 vendor_name, product_name, use_protocol, use_transport, \
68 init_function, Flags) \
70 .vendorName = vendor_name, \
71 .productName = product_name, \
72 .useProtocol = use_protocol, \
73 .useTransport = use_transport, \
74 .initFunction = init_function, \
77 static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
78 # include "unusual_ene_ub6250.h"
79 { } /* Terminating entry */
86 /* ENE bin code len */
87 #define ENE_BIN_CODE_LEN 0x800
89 #define REG_CARD_STATUS 0xFF83
90 #define REG_HW_TRAP1 0xFF89
93 #define SS_SUCCESS 0x00 /* No Sense */
94 #define SS_NOT_READY 0x02
95 #define SS_MEDIUM_ERR 0x03
96 #define SS_HW_ERR 0x04
97 #define SS_ILLEGAL_REQUEST 0x05
98 #define SS_UNIT_ATTENTION 0x06
100 /* ENE Load FW Pattern */
101 #define SD_INIT1_PATTERN 1
102 #define SD_INIT2_PATTERN 2
103 #define SD_RW_PATTERN 3
104 #define MS_INIT_PATTERN 4
105 #define MSP_RW_PATTERN 5
106 #define MS_RW_PATTERN 6
107 #define SM_INIT_PATTERN 7
108 #define SM_RW_PATTERN 8
115 /* Status Register 1 */
116 #define MS_REG_ST1_MB 0x80 /* media busy */
117 #define MS_REG_ST1_FB1 0x40 /* flush busy 1 */
118 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
119 #define MS_REG_ST1_UCDT 0x10 /* unable to correct data */
120 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
121 #define MS_REG_ST1_UCEX 0x04 /* unable to correct extra */
122 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
123 #define MS_REG_ST1_UCFG 0x01 /* unable to correct overwrite flag */
124 #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)
127 #define MS_REG_OVR_BKST 0x80 /* block status */
128 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
129 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
130 #define MS_REG_OVR_PGST0 0x40 /* page status */
131 #define MS_REG_OVR_PGST1 0x20
132 #define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
133 #define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
134 #define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 /* NG */
135 #define MS_REG_OVR_PGST_DATA_ERROR 0x00 /* data error */
136 #define MS_REG_OVR_UDST 0x10 /* update status */
137 #define MS_REG_OVR_UDST_UPDATING 0x00 /* updating */
138 #define MS_REG_OVR_UDST_NO_UPDATE MS_REG_OVR_UDST
139 #define MS_REG_OVR_RESERVED 0x08
140 #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)
142 /* Management Flag */
143 #define MS_REG_MNG_SCMS0 0x20 /* serial copy management system */
144 #define MS_REG_MNG_SCMS1 0x10
145 #define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
146 #define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
147 #define MS_REG_MNG_SCMS_ONE_COPY MS_REG_MNG_SCMS1
148 #define MS_REG_MNG_SCMS_NO_COPY 0x00
149 #define MS_REG_MNG_ATFLG 0x08 /* address transfer table flag */
150 #define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG /* other */
151 #define MS_REG_MNG_ATFLG_ATTBL 0x00 /* address transfer table */
152 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
153 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
154 #define MS_REG_MNG_SYSFLG_BOOT 0x00 /* system block */
155 #define MS_REG_MNG_RESERVED 0xc3
156 #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)
159 #define MS_MAX_PAGES_PER_BLOCK 32
160 #define MS_MAX_INITIAL_ERROR_BLOCKS 10
161 #define MS_LIB_BITS_PER_BYTE 8
163 #define MS_SYSINF_FORMAT_FAT 1
164 #define MS_SYSINF_USAGE_GENERAL 0
166 #define MS_SYSINF_MSCLASS_TYPE_1 1
167 #define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */
169 #define MS_SYSINF_CARDTYPE_RDONLY 1
170 #define MS_SYSINF_CARDTYPE_RDWR 2
171 #define MS_SYSINF_CARDTYPE_HYBRID 3
172 #define MS_SYSINF_SECURITY 0x01
173 #define MS_SYSINF_SECURITY_NO_SUPPORT MS_SYSINF_SECURITY
174 #define MS_SYSINF_SECURITY_SUPPORT 0
176 #define MS_SYSINF_RESERVED1 1
177 #define MS_SYSINF_RESERVED2 1
179 #define MS_SYSENT_TYPE_INVALID_BLOCK 0x01
180 #define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */
182 #define SIZE_OF_KIRO 1024
183 #define BYTE_MASK 0xff
186 #define MS_STATUS_WRITE_PROTECT 0x0106
187 #define MS_STATUS_SUCCESS 0x0000
188 #define MS_ERROR_FLASH_READ 0x8003
189 #define MS_ERROR_FLASH_ERASE 0x8005
190 #define MS_LB_ERROR 0xfff0
191 #define MS_LB_BOOT_BLOCK 0xfff1
192 #define MS_LB_INITIAL_ERROR 0xfff2
193 #define MS_STATUS_SUCCESS_WITH_ECC 0xfff3
194 #define MS_LB_ACQUIRED_ERROR 0xfff4
195 #define MS_LB_NOT_USED_ERASED 0xfff5
196 #define MS_NOCARD_ERROR 0xfff8
197 #define MS_NO_MEMORY_ERROR 0xfff9
198 #define MS_STATUS_INT_ERROR 0xfffa
199 #define MS_STATUS_ERROR 0xfffe
200 #define MS_LB_NOT_USED 0xffff
202 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
203 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
205 #define MS_BOOT_BLOCK_ID 0x0001
206 #define MS_BOOT_BLOCK_FORMAT_VERSION 0x0100
207 #define MS_BOOT_BLOCK_DATA_ENTRIES 2
209 #define MS_NUMBER_OF_SYSTEM_ENTRY 4
210 #define MS_NUMBER_OF_BOOT_BLOCK 2
211 #define MS_BYTES_PER_PAGE 512
212 #define MS_LOGICAL_BLOCKS_PER_SEGMENT 496
213 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT 494
215 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */
216 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff
219 #define MS_REG_OVR_BKST 0x80 /* block status */
220 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
221 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
223 /* Status Register 1 */
224 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
225 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
226 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
228 /* MemoryStick Register */
229 /* Status Register 0 */
230 #define MS_REG_ST0_WP 0x01 /* write protected */
231 #define MS_REG_ST0_WP_ON MS_REG_ST0_WP
233 #define MS_LIB_CTRL_RDONLY 0
234 #define MS_LIB_CTRL_WRPROTECT 1
237 #define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
238 #define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
240 #define ms_lib_ctrl_set(pdx, Flag) ((pdx)->MS_Lib.flags |= (1 << (Flag)))
241 #define ms_lib_ctrl_reset(pdx, Flag) ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
242 #define ms_lib_ctrl_check(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag)))
244 #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))
245 #define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
246 #define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0))
250 #define SD_Insert BIT(0)
251 #define SD_Ready BIT(1)
252 #define SD_MediaChange BIT(2)
253 #define SD_IsMMC BIT(3)
254 #define SD_HiCapacity BIT(4)
255 #define SD_HiSpeed BIT(5)
256 #define SD_WtP BIT(6)
260 #define MS_Insert BIT(0)
261 #define MS_Ready BIT(1)
262 #define MS_MediaChange BIT(2)
263 #define MS_IsMSPro BIT(3)
264 #define MS_IsMSPHG BIT(4)
266 #define MS_WtP BIT(6)
270 #define SM_Insert BIT(0)
271 #define SM_Ready BIT(1)
272 #define SM_MediaChange BIT(2)
273 /* Bits 3-5 reserved */
274 #define SM_WtP BIT(6)
275 #define SM_IsMS BIT(7)
277 struct ms_bootblock_cis {
278 u8 bCistplDEVICE[6]; /* 0 */
279 u8 bCistplDEVICE0C[6]; /* 6 */
280 u8 bCistplJEDECC[4]; /* 12 */
281 u8 bCistplMANFID[6]; /* 16 */
282 u8 bCistplVER1[32]; /* 22 */
283 u8 bCistplFUNCID[4]; /* 54 */
284 u8 bCistplFUNCE0[4]; /* 58 */
285 u8 bCistplFUNCE1[5]; /* 62 */
286 u8 bCistplCONF[7]; /* 67 */
287 u8 bCistplCFTBLENT0[10];/* 74 */
288 u8 bCistplCFTBLENT1[8]; /* 84 */
289 u8 bCistplCFTBLENT2[12];/* 92 */
290 u8 bCistplCFTBLENT3[8]; /* 104 */
291 u8 bCistplCFTBLENT4[17];/* 112 */
292 u8 bCistplCFTBLENT5[8]; /* 129 */
293 u8 bCistplCFTBLENT6[17];/* 137 */
294 u8 bCistplCFTBLENT7[8]; /* 154 */
295 u8 bCistplNOLINK[3]; /* 162 */
298 struct ms_bootblock_idi {
299 #define MS_IDI_GENERAL_CONF 0x848A
300 u16 wIDIgeneralConfiguration; /* 0 */
301 u16 wIDInumberOfCylinder; /* 1 */
302 u16 wIDIreserved0; /* 2 */
303 u16 wIDInumberOfHead; /* 3 */
304 u16 wIDIbytesPerTrack; /* 4 */
305 u16 wIDIbytesPerSector; /* 5 */
306 u16 wIDIsectorsPerTrack; /* 6 */
307 u16 wIDItotalSectors[2]; /* 7-8 high,low */
308 u16 wIDIreserved1[11]; /* 9-19 */
309 u16 wIDIbufferType; /* 20 */
310 u16 wIDIbufferSize; /* 21 */
311 u16 wIDIlongCmdECC; /* 22 */
312 u16 wIDIfirmVersion[4]; /* 23-26 */
313 u16 wIDImodelName[20]; /* 27-46 */
314 u16 wIDIreserved2; /* 47 */
315 u16 wIDIlongWordSupported; /* 48 */
316 u16 wIDIdmaSupported; /* 49 */
317 u16 wIDIreserved3; /* 50 */
318 u16 wIDIpioTiming; /* 51 */
319 u16 wIDIdmaTiming; /* 52 */
320 u16 wIDItransferParameter; /* 53 */
321 u16 wIDIformattedCylinder; /* 54 */
322 u16 wIDIformattedHead; /* 55 */
323 u16 wIDIformattedSectorsPerTrack;/* 56 */
324 u16 wIDIformattedTotalSectors[2];/* 57-58 */
325 u16 wIDImultiSector; /* 59 */
326 u16 wIDIlbaSectors[2]; /* 60-61 */
327 u16 wIDIsingleWordDMA; /* 62 */
328 u16 wIDImultiWordDMA; /* 63 */
329 u16 wIDIreserved4[192]; /* 64-255 */
332 struct ms_bootblock_sysent_rec {
339 struct ms_bootblock_sysent {
340 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
343 struct ms_bootblock_sysinf {
344 u8 bMsClass; /* must be 1 */
345 u8 bCardType; /* see below */
346 u16 wBlockSize; /* n KB */
347 u16 wBlockNumber; /* number of physical block */
348 u16 wTotalBlockNumber; /* number of logical block */
349 u16 wPageSize; /* must be 0x200 */
350 u8 bExtraSize; /* 0x10 */
354 u8 bAssemblyMakerCode;
355 u8 bAssemblyMachineCode[3];
356 u16 wMemoryMakerCode;
357 u16 wMemoryDeviceCode;
363 u16 wControllerChipNumber;
364 u16 wControllerFunction; /* New MS */
365 u8 bReserved3[9]; /* New MS */
366 u8 bParallelSupport; /* New MS */
367 u16 wFormatValue; /* New MS */
377 struct ms_bootblock_header {
381 u8 bNumberOfDataEntry;
385 struct ms_bootblock_page0 {
386 struct ms_bootblock_header header;
387 struct ms_bootblock_sysent sysent;
388 struct ms_bootblock_sysinf sysinf;
391 struct ms_bootblock_cis_idi {
393 struct ms_bootblock_cis cis;
398 struct ms_bootblock_idi idi;
404 /* ENE MS Lib struct */
405 struct ms_lib_type_extdat {
418 u32 NumberOfCylinder;
419 u32 SectorsPerCylinder;
420 u16 cardType; /* R/W, RO, Hybrid */
423 u16 NumberOfPhyBlock;
424 u16 NumberOfLogBlock;
426 u16 *Phy2LogMap; /* phy2log table */
427 u16 *Log2PhyMap; /* log2phy table */
429 unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
430 unsigned char *blkpag;
431 struct ms_lib_type_extdat *blkext;
432 unsigned char copybuf[512];
436 /* SD Block Length */
437 /* 2^9 = 512 Bytes, The HW maximum read/write data length */
438 #define SD_BLOCK_LEN 9
440 struct ene_ub6250_info {
442 /* I/O bounce buffer */
450 /* ----- SD Control Data ---------------- */
451 /*SD_REGISTER SD_Regs; */
457 /* SD/MMC New spec. */
460 u8 SD20_HIGH_CAPACITY;
464 u8 MMC_HIGH_CAPACITY;
466 /*----- MS Control Data ---------------- */
469 struct ms_lib_ctrl MS_Lib;
473 /*----- SM Control Data ---------------- */
477 unsigned char *testbuf;
482 /*------Power Managerment ---------------*/
486 static int ene_sd_init(struct us_data *us);
487 static int ene_ms_init(struct us_data *us);
488 static int ene_load_bincode(struct us_data *us, unsigned char flag);
490 static void ene_ub6250_info_destructor(void *extra)
492 struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra;
499 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
501 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
502 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
505 unsigned int residue;
506 unsigned int cswlen = 0, partial = 0;
507 unsigned int transfer_length = bcb->DataTransferLength;
509 /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
510 /* send cmd to out endpoint */
511 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
512 bcb, US_BULK_CB_WRAP_LEN, NULL);
513 if (result != USB_STOR_XFER_GOOD) {
514 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
515 return USB_STOR_TRANSPORT_ERROR;
519 unsigned int pipe = fDir;
521 if (fDir == FDIR_READ)
522 pipe = us->recv_bulk_pipe;
524 pipe = us->send_bulk_pipe;
528 result = usb_stor_bulk_srb(us, pipe, us->srb);
530 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
531 transfer_length, 0, &partial);
533 if (result != USB_STOR_XFER_GOOD) {
534 usb_stor_dbg(us, "data transfer fail ---\n");
535 return USB_STOR_TRANSPORT_ERROR;
539 /* Get CSW for device status */
540 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
541 US_BULK_CS_WRAP_LEN, &cswlen);
543 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
544 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
545 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
546 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
549 if (result == USB_STOR_XFER_STALLED) {
550 /* get the status again */
551 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
552 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
553 bcs, US_BULK_CS_WRAP_LEN, NULL);
556 if (result != USB_STOR_XFER_GOOD)
557 return USB_STOR_TRANSPORT_ERROR;
559 /* check bulk status */
560 residue = le32_to_cpu(bcs->Residue);
563 * try to compute the actual residue, based on how much data
564 * was really transferred and what the device tells us
566 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
567 residue = min(residue, transfer_length);
569 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
573 if (bcs->Status != US_BULK_STAT_OK)
574 return USB_STOR_TRANSPORT_ERROR;
576 return USB_STOR_TRANSPORT_GOOD;
579 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
581 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
583 if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready))
584 return USB_STOR_TRANSPORT_GOOD;
587 return USB_STOR_TRANSPORT_GOOD;
590 return USB_STOR_TRANSPORT_GOOD;
593 static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
595 unsigned char data_ptr[36] = {
596 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
597 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
598 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
599 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
601 usb_stor_set_xfer_buf(data_ptr, 36, srb);
602 return USB_STOR_TRANSPORT_GOOD;
605 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
607 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
608 unsigned char mediaNoWP[12] = {
609 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
610 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
611 unsigned char mediaWP[12] = {
612 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
613 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
615 if (info->SD_Status & SD_WtP)
616 usb_stor_set_xfer_buf(mediaWP, 12, srb);
618 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
621 return USB_STOR_TRANSPORT_GOOD;
624 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
628 unsigned int offset = 0;
629 unsigned char buf[8];
630 struct scatterlist *sg = NULL;
631 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
633 usb_stor_dbg(us, "sd_scsi_read_capacity\n");
634 if (info->SD_Status & SD_HiCapacity) {
636 if (info->SD_Status & SD_IsMMC)
637 bl_num = info->HC_C_SIZE-1;
639 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
641 bl_len = 1 << (info->SD_READ_BL_LEN);
642 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
643 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
645 info->bl_num = bl_num;
646 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
647 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
649 /*srb->request_bufflen = 8; */
650 buf[0] = (bl_num >> 24) & 0xff;
651 buf[1] = (bl_num >> 16) & 0xff;
652 buf[2] = (bl_num >> 8) & 0xff;
653 buf[3] = (bl_num >> 0) & 0xff;
654 buf[4] = (bl_len >> 24) & 0xff;
655 buf[5] = (bl_len >> 16) & 0xff;
656 buf[6] = (bl_len >> 8) & 0xff;
657 buf[7] = (bl_len >> 0) & 0xff;
659 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
661 return USB_STOR_TRANSPORT_GOOD;
664 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
667 unsigned char *cdb = srb->cmnd;
668 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
669 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
671 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
672 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
673 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
674 u32 bnByte = bn * 0x200;
675 u32 blenByte = blen * 0x200;
677 if (bn > info->bl_num)
678 return USB_STOR_TRANSPORT_ERROR;
680 result = ene_load_bincode(us, SD_RW_PATTERN);
681 if (result != USB_STOR_XFER_GOOD) {
682 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
683 return USB_STOR_TRANSPORT_ERROR;
686 if (info->SD_Status & SD_HiCapacity)
689 /* set up the command wrapper */
690 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
691 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
692 bcb->DataTransferLength = blenByte;
693 bcb->Flags = US_BULK_FLAG_IN;
695 bcb->CDB[5] = (unsigned char)(bnByte);
696 bcb->CDB[4] = (unsigned char)(bnByte>>8);
697 bcb->CDB[3] = (unsigned char)(bnByte>>16);
698 bcb->CDB[2] = (unsigned char)(bnByte>>24);
700 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
704 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
707 unsigned char *cdb = srb->cmnd;
708 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
709 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
711 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
712 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
713 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
714 u32 bnByte = bn * 0x200;
715 u32 blenByte = blen * 0x200;
717 if (bn > info->bl_num)
718 return USB_STOR_TRANSPORT_ERROR;
720 result = ene_load_bincode(us, SD_RW_PATTERN);
721 if (result != USB_STOR_XFER_GOOD) {
722 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
723 return USB_STOR_TRANSPORT_ERROR;
726 if (info->SD_Status & SD_HiCapacity)
729 /* set up the command wrapper */
730 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
731 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
732 bcb->DataTransferLength = blenByte;
735 bcb->CDB[5] = (unsigned char)(bnByte);
736 bcb->CDB[4] = (unsigned char)(bnByte>>8);
737 bcb->CDB[3] = (unsigned char)(bnByte>>16);
738 bcb->CDB[2] = (unsigned char)(bnByte>>24);
740 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
748 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
750 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
752 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
755 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
756 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
761 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
763 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
765 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
768 info->MS_Lib.Phy2LogMap[phyblk] = mark;
773 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
775 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
778 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
780 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
783 static int ms_lib_free_logicalmap(struct us_data *us)
785 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
787 kfree(info->MS_Lib.Phy2LogMap);
788 info->MS_Lib.Phy2LogMap = NULL;
790 kfree(info->MS_Lib.Log2PhyMap);
791 info->MS_Lib.Log2PhyMap = NULL;
796 static int ms_lib_alloc_logicalmap(struct us_data *us)
799 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
801 info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL);
802 info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL);
804 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
805 ms_lib_free_logicalmap(us);
809 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
810 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
812 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
813 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
818 static void ms_lib_clear_writebuf(struct us_data *us)
821 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
823 info->MS_Lib.wrtblk = (u16)-1;
824 ms_lib_clear_pagemap(info);
826 if (info->MS_Lib.blkpag)
827 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
829 if (info->MS_Lib.blkext) {
830 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
831 info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
832 info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
833 info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
834 info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
839 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
842 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
844 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
845 for (Count = 0; PhyBlock < Ende; PhyBlock++) {
846 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
848 case MS_LB_NOT_USED_ERASED:
858 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
859 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
861 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
862 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
863 u8 *bbuf = info->bbuf;
865 u32 bn = PhyBlockAddr * 0x20 + PageNum;
867 result = ene_load_bincode(us, MS_RW_PATTERN);
868 if (result != USB_STOR_XFER_GOOD)
869 return USB_STOR_TRANSPORT_ERROR;
872 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
873 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
874 bcb->DataTransferLength = 0x200;
875 bcb->Flags = US_BULK_FLAG_IN;
878 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
880 bcb->CDB[5] = (unsigned char)(bn);
881 bcb->CDB[4] = (unsigned char)(bn>>8);
882 bcb->CDB[3] = (unsigned char)(bn>>16);
883 bcb->CDB[2] = (unsigned char)(bn>>24);
885 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
886 if (result != USB_STOR_XFER_GOOD)
887 return USB_STOR_TRANSPORT_ERROR;
890 /* Read Extra Data */
891 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
892 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
893 bcb->DataTransferLength = 0x4;
894 bcb->Flags = US_BULK_FLAG_IN;
898 bcb->CDB[5] = (unsigned char)(PageNum);
899 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
900 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
901 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
904 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
905 if (result != USB_STOR_XFER_GOOD)
906 return USB_STOR_TRANSPORT_ERROR;
908 ExtraDat->reserved = 0;
909 ExtraDat->intr = 0x80; /* Not yet,fireware support */
910 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
912 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
913 ExtraDat->ovrflg = bbuf[0];
914 ExtraDat->mngflg = bbuf[1];
915 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
917 return USB_STOR_TRANSPORT_GOOD;
920 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
922 struct ms_bootblock_sysent *SysEntry;
923 struct ms_bootblock_sysinf *SysInfo;
927 struct ms_lib_type_extdat ExtraData;
928 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
930 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
931 if (PageBuffer == NULL)
936 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
938 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
939 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
940 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
941 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
942 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
943 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
944 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
947 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
948 case MS_SYSINF_CARDTYPE_RDONLY:
949 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
951 case MS_SYSINF_CARDTYPE_RDWR:
952 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
954 case MS_SYSINF_CARDTYPE_HYBRID:
959 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
960 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
961 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
962 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
963 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
964 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
966 /*Allocate to all number of logicalblock and physicalblock */
967 if (ms_lib_alloc_logicalmap(us))
970 /* Mark the book block */
971 ms_lib_set_bootblockmark(us, PhyBlock);
973 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
975 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
976 u32 EntryOffset, EntrySize;
978 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
980 if (EntryOffset == 0xffffff)
982 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
987 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
991 u8 PrevPageNumber = 0;
994 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
997 while (EntrySize > 0) {
999 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1000 if (PageNumber != PrevPageNumber) {
1001 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1002 case MS_STATUS_SUCCESS:
1004 case MS_STATUS_WRITE_PROTECT:
1005 case MS_ERROR_FLASH_READ:
1006 case MS_STATUS_ERROR:
1011 PrevPageNumber = PageNumber;
1014 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1015 if (phyblk < 0x0fff)
1016 ms_lib_set_initialerrorblock(us, phyblk);
1021 } else if (i == 1) { /* CIS/IDI */
1022 struct ms_bootblock_idi *idi;
1024 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1027 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1028 case MS_STATUS_SUCCESS:
1030 case MS_STATUS_WRITE_PROTECT:
1031 case MS_ERROR_FLASH_READ:
1032 case MS_STATUS_ERROR:
1037 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1038 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1041 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1042 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1051 ms_lib_free_logicalmap(us);
1059 static void ms_lib_free_writebuf(struct us_data *us)
1061 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1062 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1064 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1066 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1068 if (info->MS_Lib.blkpag) {
1069 kfree(info->MS_Lib.blkpag); /* Arnold test ... */
1070 info->MS_Lib.blkpag = NULL;
1073 if (info->MS_Lib.blkext) {
1074 kfree(info->MS_Lib.blkext); /* Arnold test ... */
1075 info->MS_Lib.blkext = NULL;
1080 static void ms_lib_free_allocatedarea(struct us_data *us)
1082 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1084 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1085 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1087 /* set struct us point flag to 0 */
1088 info->MS_Lib.flags = 0;
1089 info->MS_Lib.BytesPerSector = 0;
1090 info->MS_Lib.SectorsPerCylinder = 0;
1092 info->MS_Lib.cardType = 0;
1093 info->MS_Lib.blockSize = 0;
1094 info->MS_Lib.PagesPerBlock = 0;
1096 info->MS_Lib.NumberOfPhyBlock = 0;
1097 info->MS_Lib.NumberOfLogBlock = 0;
1101 static int ms_lib_alloc_writebuf(struct us_data *us)
1103 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1105 info->MS_Lib.wrtblk = (u16)-1;
1107 info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL);
1108 info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL);
1110 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1111 ms_lib_free_writebuf(us);
1115 ms_lib_clear_writebuf(us);
1120 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1122 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1124 if (logblk == MS_LB_NOT_USED)
1127 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1128 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1131 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1132 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1137 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1138 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1140 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
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;
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;
1174 u32 bn = PhyBlockAddr;
1176 result = ene_load_bincode(us, MS_RW_PATTERN);
1177 if (result != USB_STOR_XFER_GOOD)
1178 return USB_STOR_TRANSPORT_ERROR;
1180 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1181 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1182 bcb->DataTransferLength = 0x200;
1183 bcb->Flags = US_BULK_FLAG_IN;
1186 bcb->CDB[4] = (unsigned char)(bn);
1187 bcb->CDB[3] = (unsigned char)(bn>>8);
1188 bcb->CDB[2] = (unsigned char)(bn>>16);
1190 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1191 if (result != USB_STOR_XFER_GOOD)
1192 return USB_STOR_TRANSPORT_ERROR;
1194 return USB_STOR_TRANSPORT_GOOD;
1197 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1199 unsigned char *PageBuf = NULL;
1200 u16 result = MS_STATUS_SUCCESS;
1202 struct ms_lib_type_extdat extdat;
1203 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1205 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1206 if (PageBuf == NULL) {
1207 result = MS_NO_MEMORY_ERROR;
1211 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1213 blk = be16_to_cpu(PageBuf[index]);
1214 if (blk == MS_LB_NOT_USED)
1216 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1217 result = MS_ERROR_FLASH_READ;
1228 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1231 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1233 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1236 log = info->MS_Lib.Phy2LogMap[phyblk];
1238 if (log < info->MS_Lib.NumberOfLogBlock)
1239 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1241 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1242 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1247 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1248 u8 PageNum, u8 OverwriteFlag)
1250 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1253 result = ene_load_bincode(us, MS_RW_PATTERN);
1254 if (result != USB_STOR_XFER_GOOD)
1255 return USB_STOR_TRANSPORT_ERROR;
1257 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1258 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1259 bcb->DataTransferLength = 0x4;
1260 bcb->Flags = US_BULK_FLAG_IN;
1263 bcb->CDB[5] = (unsigned char)(PageNum);
1264 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1265 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1266 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1267 bcb->CDB[6] = OverwriteFlag;
1272 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1273 if (result != USB_STOR_XFER_GOOD)
1274 return USB_STOR_TRANSPORT_ERROR;
1276 return USB_STOR_TRANSPORT_GOOD;
1279 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1281 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1283 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1284 return MS_STATUS_ERROR;
1286 ms_lib_setacquired_errorblock(us, phyblk);
1288 if (ms_lib_iswritable(info))
1289 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1291 return MS_STATUS_SUCCESS;
1294 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1297 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1299 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1300 return MS_STATUS_ERROR;
1302 log = info->MS_Lib.Phy2LogMap[phyblk];
1304 if (log < info->MS_Lib.NumberOfLogBlock)
1305 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1307 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1309 if (ms_lib_iswritable(info)) {
1310 switch (ms_read_eraseblock(us, phyblk)) {
1311 case MS_STATUS_SUCCESS:
1312 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1313 return MS_STATUS_SUCCESS;
1314 case MS_ERROR_FLASH_ERASE:
1315 case MS_STATUS_INT_ERROR:
1316 ms_lib_error_phyblock(us, phyblk);
1317 return MS_ERROR_FLASH_ERASE;
1318 case MS_STATUS_ERROR:
1320 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1321 ms_lib_setacquired_errorblock(us, phyblk);
1322 return MS_STATUS_ERROR;
1326 ms_lib_setacquired_errorblock(us, phyblk);
1328 return MS_STATUS_SUCCESS;
1331 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1332 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1334 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1335 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1336 u8 *bbuf = info->bbuf;
1339 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1340 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1341 bcb->DataTransferLength = 0x4;
1342 bcb->Flags = US_BULK_FLAG_IN;
1345 bcb->CDB[5] = (unsigned char)(PageNum);
1346 bcb->CDB[4] = (unsigned char)(PhyBlock);
1347 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1348 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1351 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1352 if (result != USB_STOR_XFER_GOOD)
1353 return USB_STOR_TRANSPORT_ERROR;
1355 ExtraDat->reserved = 0;
1356 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
1357 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
1358 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
1359 ExtraDat->ovrflg = bbuf[0];
1360 ExtraDat->mngflg = bbuf[1];
1361 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
1363 return USB_STOR_TRANSPORT_GOOD;
1366 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1370 struct ms_lib_type_extdat extdat; /* need check */
1371 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1374 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1377 for (blk = phyblk + 1; blk != phyblk; blk++) {
1378 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1379 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1381 Newblk = info->MS_Lib.Phy2LogMap[blk];
1382 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1384 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1385 switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1386 case MS_STATUS_SUCCESS:
1387 case MS_STATUS_SUCCESS_WITH_ECC:
1389 case MS_NOCARD_ERROR:
1390 return MS_NOCARD_ERROR;
1391 case MS_STATUS_INT_ERROR:
1393 case MS_ERROR_FLASH_READ:
1395 ms_lib_setacquired_errorblock(us, blk);
1399 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1400 ms_lib_setacquired_errorblock(us, blk);
1404 switch (ms_lib_erase_phyblock(us, blk)) {
1405 case MS_STATUS_SUCCESS:
1407 case MS_STATUS_ERROR:
1409 case MS_ERROR_FLASH_ERASE:
1411 ms_lib_error_phyblock(us, blk);
1419 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1422 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1424 phyblk = ms_libconv_to_physical(info, logblk);
1425 if (phyblk >= MS_LB_ERROR) {
1426 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1429 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1430 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1431 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1434 return ms_libsearch_block_from_physical(us, phyblk);
1437 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1439 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1441 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1442 if ((info->MS_Status & MS_Insert) && (info->MS_Status & MS_Ready)) {
1443 return USB_STOR_TRANSPORT_GOOD;
1446 return USB_STOR_TRANSPORT_GOOD;
1449 return USB_STOR_TRANSPORT_GOOD;
1452 static int ms_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
1454 /* pr_info("MS_SCSI_Inquiry\n"); */
1455 unsigned char data_ptr[36] = {
1456 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
1457 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
1458 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
1459 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
1461 usb_stor_set_xfer_buf(data_ptr, 36, srb);
1462 return USB_STOR_TRANSPORT_GOOD;
1465 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1467 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1468 unsigned char mediaNoWP[12] = {
1469 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1470 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1471 unsigned char mediaWP[12] = {
1472 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1473 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1475 if (info->MS_Status & MS_WtP)
1476 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1478 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1480 return USB_STOR_TRANSPORT_GOOD;
1483 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1487 unsigned int offset = 0;
1488 unsigned char buf[8];
1489 struct scatterlist *sg = NULL;
1490 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1492 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1494 if (info->MS_Status & MS_IsMSPro)
1495 bl_num = info->MSP_TotalBlock - 1;
1497 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1499 info->bl_num = bl_num;
1500 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1501 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1503 /*srb->request_bufflen = 8; */
1504 buf[0] = (bl_num >> 24) & 0xff;
1505 buf[1] = (bl_num >> 16) & 0xff;
1506 buf[2] = (bl_num >> 8) & 0xff;
1507 buf[3] = (bl_num >> 0) & 0xff;
1508 buf[4] = (bl_len >> 24) & 0xff;
1509 buf[5] = (bl_len >> 16) & 0xff;
1510 buf[6] = (bl_len >> 8) & 0xff;
1511 buf[7] = (bl_len >> 0) & 0xff;
1513 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1515 return USB_STOR_TRANSPORT_GOOD;
1518 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1520 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1523 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1524 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1527 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1531 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1532 u8 PageNum, u8 blen, void *buf)
1534 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1537 /* Read Extra Data */
1538 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1539 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1540 bcb->DataTransferLength = 0x4 * blen;
1541 bcb->Flags = US_BULK_FLAG_IN;
1544 bcb->CDB[5] = (unsigned char)(PageNum);
1545 bcb->CDB[4] = (unsigned char)(PhyBlock);
1546 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1547 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1550 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1551 if (result != USB_STOR_XFER_GOOD)
1552 return USB_STOR_TRANSPORT_ERROR;
1554 return USB_STOR_TRANSPORT_GOOD;
1557 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1559 u16 PhyBlock, newblk, i;
1560 u16 LogStart, LogEnde;
1561 struct ms_lib_type_extdat extdat;
1562 u32 count = 0, index = 0;
1563 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1564 u8 *bbuf = info->bbuf;
1566 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1567 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1569 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1570 switch (ms_libconv_to_logical(info, PhyBlock)) {
1571 case MS_STATUS_ERROR:
1577 if (count == PhyBlock) {
1578 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1582 index = (PhyBlock % 0x80) * 4;
1584 extdat.ovrflg = bbuf[index];
1585 extdat.mngflg = bbuf[index+1];
1586 extdat.logadr = memstick_logaddr(bbuf[index+2],
1589 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1590 ms_lib_setacquired_errorblock(us, PhyBlock);
1594 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1595 ms_lib_erase_phyblock(us, PhyBlock);
1599 if (extdat.logadr != MS_LB_NOT_USED) {
1600 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1601 ms_lib_erase_phyblock(us, PhyBlock);
1605 newblk = ms_libconv_to_physical(info, extdat.logadr);
1607 if (newblk != MS_LB_NOT_USED) {
1608 if (extdat.logadr == 0) {
1609 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1610 if (ms_lib_check_disableblock(us, btBlk1st)) {
1611 ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1616 ms_lib_read_extra(us, newblk, 0, &extdat);
1617 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1618 ms_lib_erase_phyblock(us, PhyBlock);
1621 ms_lib_erase_phyblock(us, newblk);
1625 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1630 return MS_STATUS_SUCCESS;
1634 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1637 unsigned char *cdb = srb->cmnd;
1638 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1639 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1641 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1642 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1643 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1644 u32 blenByte = blen * 0x200;
1646 if (bn > info->bl_num)
1647 return USB_STOR_TRANSPORT_ERROR;
1649 if (info->MS_Status & MS_IsMSPro) {
1650 result = ene_load_bincode(us, MSP_RW_PATTERN);
1651 if (result != USB_STOR_XFER_GOOD) {
1652 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1653 return USB_STOR_TRANSPORT_ERROR;
1656 /* set up the command wrapper */
1657 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1658 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1659 bcb->DataTransferLength = blenByte;
1660 bcb->Flags = US_BULK_FLAG_IN;
1663 bcb->CDB[5] = (unsigned char)(bn);
1664 bcb->CDB[4] = (unsigned char)(bn>>8);
1665 bcb->CDB[3] = (unsigned char)(bn>>16);
1666 bcb->CDB[2] = (unsigned char)(bn>>24);
1668 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1677 buf = kmalloc(blenByte, GFP_KERNEL);
1679 return USB_STOR_TRANSPORT_ERROR;
1681 result = ene_load_bincode(us, MS_RW_PATTERN);
1682 if (result != USB_STOR_XFER_GOOD) {
1683 pr_info("Load MS RW pattern Fail !!\n");
1684 result = USB_STOR_TRANSPORT_ERROR;
1688 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1689 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1692 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1693 len = info->MS_Lib.PagesPerBlock-PageNum;
1697 phyblk = ms_libconv_to_physical(info, logblk);
1698 blkno = phyblk * 0x20 + PageNum;
1700 /* set up the command wrapper */
1701 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1702 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1703 bcb->DataTransferLength = 0x200 * len;
1704 bcb->Flags = US_BULK_FLAG_IN;
1707 bcb->CDB[5] = (unsigned char)(blkno);
1708 bcb->CDB[4] = (unsigned char)(blkno>>8);
1709 bcb->CDB[3] = (unsigned char)(blkno>>16);
1710 bcb->CDB[2] = (unsigned char)(blkno>>24);
1712 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1713 if (result != USB_STOR_XFER_GOOD) {
1714 pr_info("MS_SCSI_Read --- result = %x\n", result);
1715 result = USB_STOR_TRANSPORT_ERROR;
1724 offset += MS_BYTES_PER_PAGE*len;
1726 usb_stor_set_xfer_buf(buf, blenByte, srb);
1733 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1736 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1737 unsigned char *cdb = srb->cmnd;
1738 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1740 u32 bn = ((cdb[2] << 24) & 0xff000000) |
1741 ((cdb[3] << 16) & 0x00ff0000) |
1742 ((cdb[4] << 8) & 0x0000ff00) |
1743 ((cdb[5] << 0) & 0x000000ff);
1744 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1745 u32 blenByte = blen * 0x200;
1747 if (bn > info->bl_num)
1748 return USB_STOR_TRANSPORT_ERROR;
1750 if (info->MS_Status & MS_IsMSPro) {
1751 result = ene_load_bincode(us, MSP_RW_PATTERN);
1752 if (result != USB_STOR_XFER_GOOD) {
1753 pr_info("Load MSP RW pattern Fail !!\n");
1754 return USB_STOR_TRANSPORT_ERROR;
1757 /* set up the command wrapper */
1758 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1759 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1760 bcb->DataTransferLength = blenByte;
1764 bcb->CDB[5] = (unsigned char)(bn);
1765 bcb->CDB[4] = (unsigned char)(bn>>8);
1766 bcb->CDB[3] = (unsigned char)(bn>>16);
1767 bcb->CDB[2] = (unsigned char)(bn>>24);
1769 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1775 u16 len, oldphy, newphy;
1777 buf = kmalloc(blenByte, GFP_KERNEL);
1779 return USB_STOR_TRANSPORT_ERROR;
1780 usb_stor_set_xfer_buf(buf, blenByte, srb);
1782 result = ene_load_bincode(us, MS_RW_PATTERN);
1783 if (result != USB_STOR_XFER_GOOD) {
1784 pr_info("Load MS RW pattern Fail !!\n");
1785 result = USB_STOR_TRANSPORT_ERROR;
1789 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1790 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1793 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1794 len = info->MS_Lib.PagesPerBlock-PageNum;
1798 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1799 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1801 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1803 if (result != USB_STOR_XFER_GOOD) {
1804 pr_info("MS_SCSI_Write --- result = %x\n", result);
1805 result = USB_STOR_TRANSPORT_ERROR;
1809 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1810 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1817 offset += MS_BYTES_PER_PAGE*len;
1829 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1831 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1834 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1835 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1836 bcb->DataTransferLength = 0x01;
1837 bcb->Flags = US_BULK_FLAG_IN;
1839 bcb->CDB[2] = (unsigned char)(index>>8);
1840 bcb->CDB[3] = (unsigned char)index;
1842 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1846 static int ene_get_card_status(struct us_data *us, u8 *buf)
1850 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1852 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1853 reg4b = *(u32 *)&buf[0x18];
1854 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1856 tmpreg = (u16) reg4b;
1857 reg4b = *(u32 *)(&buf[0x14]);
1858 if ((info->SD_Status & SD_HiCapacity) && !(info->SD_Status & SD_IsMMC))
1859 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1861 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1862 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1863 if ((info->SD_Status & SD_HiCapacity) && (info->SD_Status & SD_IsMMC))
1864 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1866 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1867 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1868 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1870 info->SD_Block_Mult = 1;
1873 return USB_STOR_TRANSPORT_GOOD;
1876 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1879 char *fw_name = NULL;
1880 unsigned char *buf = NULL;
1881 const struct firmware *sd_fw = NULL;
1882 int result = USB_STOR_TRANSPORT_ERROR;
1883 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1884 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1886 if (info->BIN_FLAG == flag)
1887 return USB_STOR_TRANSPORT_GOOD;
1891 case SD_INIT1_PATTERN:
1892 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1893 fw_name = SD_INIT1_FIRMWARE;
1895 case SD_INIT2_PATTERN:
1896 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1897 fw_name = SD_INIT2_FIRMWARE;
1900 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1901 fw_name = SD_RW_FIRMWARE;
1904 case MS_INIT_PATTERN:
1905 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1906 fw_name = MS_INIT_FIRMWARE;
1908 case MSP_RW_PATTERN:
1909 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1910 fw_name = MSP_RW_FIRMWARE;
1913 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1914 fw_name = MS_RW_FIRMWARE;
1917 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1921 err = reject_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1923 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1926 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1930 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1931 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1932 bcb->DataTransferLength = sd_fw->size;
1936 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1937 if (us->srb != NULL)
1938 scsi_set_resid(us->srb, 0);
1939 info->BIN_FLAG = flag;
1943 release_firmware(sd_fw);
1947 static int ms_card_init(struct us_data *us)
1951 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1952 struct ms_lib_type_extdat extdat;
1953 u16 btBlk1st, btBlk2nd;
1955 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1957 printk(KERN_INFO "MS_CardInit start\n");
1959 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1961 /* get two PageBuffer */
1962 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1963 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1964 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1965 result = MS_NO_MEMORY_ERROR;
1969 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1972 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1974 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1975 case MS_STATUS_SUCCESS:
1977 case MS_STATUS_INT_ERROR:
1979 case MS_STATUS_ERROR:
1984 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1987 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1988 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1989 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1990 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1993 if (btBlk1st != MS_LB_NOT_USED) {
1994 btBlk2nd = TmpBlock;
1998 btBlk1st = TmpBlock;
1999 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
2000 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2004 if (btBlk1st == MS_LB_NOT_USED) {
2005 result = MS_STATUS_ERROR;
2010 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2011 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2013 result = MS_STATUS_ERROR;
2014 /* 1st Boot Block */
2015 if (btBlk1stErred == 0)
2016 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2018 /* 2nd Boot Block */
2019 if (result && (btBlk2nd != MS_LB_NOT_USED))
2020 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2023 result = MS_STATUS_ERROR;
2027 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2028 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2030 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2032 if (btBlk2nd != MS_LB_NOT_USED) {
2033 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2034 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2036 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2039 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2043 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2044 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2045 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2046 if (ms_count_freeblock(us, TmpBlock) == 0) {
2047 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2053 if (ms_lib_alloc_writebuf(us)) {
2054 result = MS_NO_MEMORY_ERROR;
2058 result = MS_STATUS_SUCCESS;
2064 printk(KERN_INFO "MS_CardInit end\n");
2068 static int ene_ms_init(struct us_data *us)
2070 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2072 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2073 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2074 u8 *bbuf = info->bbuf;
2077 printk(KERN_INFO "transport --- ENE_MSInit\n");
2079 /* the same part to test ENE */
2081 result = ene_load_bincode(us, MS_INIT_PATTERN);
2082 if (result != USB_STOR_XFER_GOOD) {
2083 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2084 return USB_STOR_TRANSPORT_ERROR;
2087 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2088 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2089 bcb->DataTransferLength = 0x200;
2090 bcb->Flags = US_BULK_FLAG_IN;
2094 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2095 if (result != USB_STOR_XFER_GOOD) {
2096 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2097 return USB_STOR_TRANSPORT_ERROR;
2099 /* the same part to test ENE */
2100 info->MS_Status = bbuf[0];
2102 s = info->MS_Status;
2103 if ((s & MS_Insert) && (s & MS_Ready)) {
2104 printk(KERN_INFO "Insert = %x\n", !!(s & MS_Insert));
2105 printk(KERN_INFO "Ready = %x\n", !!(s & MS_Ready));
2106 printk(KERN_INFO "IsMSPro = %x\n", !!(s & MS_IsMSPro));
2107 printk(KERN_INFO "IsMSPHG = %x\n", !!(s & MS_IsMSPHG));
2108 printk(KERN_INFO "WtP= %x\n", !!(s & MS_WtP));
2109 if (s & MS_IsMSPro) {
2110 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7];
2111 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
2112 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2114 ms_card_init(us); /* Card is MS (to ms.c)*/
2116 usb_stor_dbg(us, "MS Init Code OK !!\n");
2118 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
2119 return USB_STOR_TRANSPORT_ERROR;
2122 return USB_STOR_TRANSPORT_GOOD;
2125 static int ene_sd_init(struct us_data *us)
2128 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2129 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2130 u8 *bbuf = info->bbuf;
2132 usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2133 /* SD Init Part-1 */
2134 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2135 if (result != USB_STOR_XFER_GOOD) {
2136 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2137 return USB_STOR_TRANSPORT_ERROR;
2140 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2141 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2142 bcb->Flags = US_BULK_FLAG_IN;
2145 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2146 if (result != USB_STOR_XFER_GOOD) {
2147 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2148 return USB_STOR_TRANSPORT_ERROR;
2151 /* SD Init Part-2 */
2152 result = ene_load_bincode(us, SD_INIT2_PATTERN);
2153 if (result != USB_STOR_XFER_GOOD) {
2154 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2155 return USB_STOR_TRANSPORT_ERROR;
2158 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2159 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2160 bcb->DataTransferLength = 0x200;
2161 bcb->Flags = US_BULK_FLAG_IN;
2164 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2165 if (result != USB_STOR_XFER_GOOD) {
2166 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2167 return USB_STOR_TRANSPORT_ERROR;
2170 info->SD_Status = bbuf[0];
2171 if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready)) {
2172 unsigned int s = info->SD_Status;
2174 ene_get_card_status(us, bbuf);
2175 usb_stor_dbg(us, "Insert = %x\n", !!(s & SD_Insert));
2176 usb_stor_dbg(us, "Ready = %x\n", !!(s & SD_Ready));
2177 usb_stor_dbg(us, "IsMMC = %x\n", !!(s & SD_IsMMC));
2178 usb_stor_dbg(us, "HiCapacity = %x\n", !!(s & SD_HiCapacity));
2179 usb_stor_dbg(us, "HiSpeed = %x\n", !!(s & SD_HiSpeed));
2180 usb_stor_dbg(us, "WtP = %x\n", !!(s & SD_WtP));
2182 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
2183 return USB_STOR_TRANSPORT_ERROR;
2185 return USB_STOR_TRANSPORT_GOOD;
2189 static int ene_init(struct us_data *us)
2193 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2194 u8 *bbuf = info->bbuf;
2196 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
2197 if (result != USB_STOR_XFER_GOOD)
2198 return USB_STOR_TRANSPORT_ERROR;
2200 misc_reg03 = bbuf[0];
2201 if (misc_reg03 & 0x01) {
2202 if (!(info->SD_Status & SD_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 & MS_Ready)) {
2210 result = ene_ms_init(us);
2211 if (result != USB_STOR_XFER_GOOD)
2212 return USB_STOR_TRANSPORT_ERROR;
2218 /*----- sd_scsi_irp() ---------*/
2219 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
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);
2230 result = sd_scsi_inquiry(us, srb);
2233 result = sd_scsi_mode_sense(us, srb);
2237 result = SD_SCSI_Start_Stop(us, srb);
2241 result = sd_scsi_read_capacity(us, srb);
2244 result = sd_scsi_read(us, srb);
2247 result = sd_scsi_write(us, srb);
2250 info->SrbStatus = SS_ILLEGAL_REQUEST;
2251 result = USB_STOR_TRANSPORT_FAILED;
2260 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
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);
2270 result = ms_scsi_inquiry(us, srb);
2273 result = ms_scsi_mode_sense(us, srb);
2276 result = ms_scsi_read_capacity(us, srb);
2279 result = ms_scsi_read(us, srb);
2282 result = ms_scsi_write(us, srb);
2285 info->SrbStatus = SS_ILLEGAL_REQUEST;
2286 result = USB_STOR_TRANSPORT_FAILED;
2292 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2294 int result = USB_STOR_XFER_GOOD;
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 & SD_Ready) || (info->MS_Status & MS_Ready)))
2300 result = ene_init(us);
2301 if (result == USB_STOR_XFER_GOOD) {
2302 result = USB_STOR_TRANSPORT_ERROR;
2303 if (info->SD_Status & SD_Ready)
2304 result = sd_scsi_irp(us, srb);
2306 if (info->MS_Status & MS_Ready)
2307 result = ms_scsi_irp(us, srb);
2312 static struct scsi_host_template ene_ub6250_host_template;
2314 static int ene_ub6250_probe(struct usb_interface *intf,
2315 const struct usb_device_id *id)
2320 struct ene_ub6250_info *info;
2322 result = usb_stor_probe1(&us, intf, id,
2323 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2324 &ene_ub6250_host_template);
2328 /* FIXME: where should the code alloc extra buf ? */
2329 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2332 us->extra_destructor = ene_ub6250_info_destructor;
2334 info = (struct ene_ub6250_info *)(us->extra);
2335 info->bbuf = kmalloc(512, GFP_KERNEL);
2341 us->transport_name = "ene_ub6250";
2342 us->transport = ene_transport;
2345 result = usb_stor_probe2(us);
2349 /* probe card type */
2350 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2351 if (result != USB_STOR_XFER_GOOD) {
2352 usb_stor_disconnect(intf);
2353 return USB_STOR_TRANSPORT_ERROR;
2356 misc_reg03 = info->bbuf[0];
2357 if (!(misc_reg03 & 0x01)) {
2358 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2359 "It does not support SM cards.\n");
2368 static int ene_ub6250_resume(struct usb_interface *iface)
2370 struct us_data *us = usb_get_intfdata(iface);
2371 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2373 mutex_lock(&us->dev_mutex);
2375 if (us->suspend_resume_hook)
2376 (us->suspend_resume_hook)(us, US_RESUME);
2378 mutex_unlock(&us->dev_mutex);
2380 info->Power_IsResum = true;
2381 /* info->SD_Status &= ~SD_Ready; */
2382 info->SD_Status = 0;
2383 info->MS_Status = 0;
2384 info->SM_Status = 0;
2389 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2391 struct us_data *us = usb_get_intfdata(iface);
2392 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2394 /* Report the reset to the SCSI core */
2395 usb_stor_reset_resume(iface);
2398 * FIXME: Notify the subdrivers that they need to reinitialize
2401 info->Power_IsResum = true;
2402 /* info->SD_Status &= ~SD_Ready; */
2403 info->SD_Status = 0;
2404 info->MS_Status = 0;
2405 info->SM_Status = 0;
2412 #define ene_ub6250_resume NULL
2413 #define ene_ub6250_reset_resume NULL
2417 static struct usb_driver ene_ub6250_driver = {
2419 .probe = ene_ub6250_probe,
2420 .disconnect = usb_stor_disconnect,
2421 .suspend = usb_stor_suspend,
2422 .resume = ene_ub6250_resume,
2423 .reset_resume = ene_ub6250_reset_resume,
2424 .pre_reset = usb_stor_pre_reset,
2425 .post_reset = usb_stor_post_reset,
2426 .id_table = ene_ub6250_usb_ids,
2431 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);