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 "ene-ub6250/sd_init1.bin"
34 #define SD_INIT2_FIRMWARE "ene-ub6250/sd_init2.bin"
35 #define SD_RW_FIRMWARE "ene-ub6250/sd_rdwr.bin"
36 #define MS_INIT_FIRMWARE "ene-ub6250/ms_init.bin"
37 #define MSP_RW_FIRMWARE "ene-ub6250/msp_rdwr.bin"
38 #define MS_RW_FIRMWARE "ene-ub6250/ms_rdwr.bin"
40 #define DRV_NAME "ums_eneub6250"
42 MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
43 MODULE_LICENSE("GPL");
44 MODULE_FIRMWARE(SD_INIT1_FIRMWARE);
45 MODULE_FIRMWARE(SD_INIT2_FIRMWARE);
46 MODULE_FIRMWARE(SD_RW_FIRMWARE);
47 MODULE_FIRMWARE(MS_INIT_FIRMWARE);
48 MODULE_FIRMWARE(MSP_RW_FIRMWARE);
49 MODULE_FIRMWARE(MS_RW_FIRMWARE);
52 * The table of devices
54 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
55 vendorName, productName, useProtocol, useTransport, \
56 initFunction, flags) \
57 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
58 .driver_info = (flags)}
60 static struct usb_device_id ene_ub6250_usb_ids[] = {
61 # include "unusual_ene_ub6250.h"
62 { } /* Terminating entry */
64 MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
71 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
72 vendor_name, product_name, use_protocol, use_transport, \
73 init_function, Flags) \
75 .vendorName = vendor_name, \
76 .productName = product_name, \
77 .useProtocol = use_protocol, \
78 .useTransport = use_transport, \
79 .initFunction = init_function, \
82 static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
83 # include "unusual_ene_ub6250.h"
84 { } /* Terminating entry */
91 /* ENE bin code len */
92 #define ENE_BIN_CODE_LEN 0x800
94 #define REG_CARD_STATUS 0xFF83
95 #define REG_HW_TRAP1 0xFF89
98 #define SS_SUCCESS 0x00 /* No Sense */
99 #define SS_NOT_READY 0x02
100 #define SS_MEDIUM_ERR 0x03
101 #define SS_HW_ERR 0x04
102 #define SS_ILLEGAL_REQUEST 0x05
103 #define SS_UNIT_ATTENTION 0x06
105 /* ENE Load FW Pattern */
106 #define SD_INIT1_PATTERN 1
107 #define SD_INIT2_PATTERN 2
108 #define SD_RW_PATTERN 3
109 #define MS_INIT_PATTERN 4
110 #define MSP_RW_PATTERN 5
111 #define MS_RW_PATTERN 6
112 #define SM_INIT_PATTERN 7
113 #define SM_RW_PATTERN 8
120 /* Status Register 1 */
121 #define MS_REG_ST1_MB 0x80 /* media busy */
122 #define MS_REG_ST1_FB1 0x40 /* flush busy 1 */
123 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
124 #define MS_REG_ST1_UCDT 0x10 /* unable to correct data */
125 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
126 #define MS_REG_ST1_UCEX 0x04 /* unable to correct extra */
127 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
128 #define MS_REG_ST1_UCFG 0x01 /* unable to correct overwrite flag */
129 #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)
132 #define MS_REG_OVR_BKST 0x80 /* block status */
133 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
134 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
135 #define MS_REG_OVR_PGST0 0x40 /* page status */
136 #define MS_REG_OVR_PGST1 0x20
137 #define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
138 #define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
139 #define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 /* NG */
140 #define MS_REG_OVR_PGST_DATA_ERROR 0x00 /* data error */
141 #define MS_REG_OVR_UDST 0x10 /* update status */
142 #define MS_REG_OVR_UDST_UPDATING 0x00 /* updating */
143 #define MS_REG_OVR_UDST_NO_UPDATE MS_REG_OVR_UDST
144 #define MS_REG_OVR_RESERVED 0x08
145 #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)
147 /* Management Flag */
148 #define MS_REG_MNG_SCMS0 0x20 /* serial copy management system */
149 #define MS_REG_MNG_SCMS1 0x10
150 #define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
151 #define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
152 #define MS_REG_MNG_SCMS_ONE_COPY MS_REG_MNG_SCMS1
153 #define MS_REG_MNG_SCMS_NO_COPY 0x00
154 #define MS_REG_MNG_ATFLG 0x08 /* address transfer table flag */
155 #define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG /* other */
156 #define MS_REG_MNG_ATFLG_ATTBL 0x00 /* address transfer table */
157 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
158 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
159 #define MS_REG_MNG_SYSFLG_BOOT 0x00 /* system block */
160 #define MS_REG_MNG_RESERVED 0xc3
161 #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)
164 #define MS_MAX_PAGES_PER_BLOCK 32
165 #define MS_MAX_INITIAL_ERROR_BLOCKS 10
166 #define MS_LIB_BITS_PER_BYTE 8
168 #define MS_SYSINF_FORMAT_FAT 1
169 #define MS_SYSINF_USAGE_GENERAL 0
171 #define MS_SYSINF_MSCLASS_TYPE_1 1
172 #define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */
174 #define MS_SYSINF_CARDTYPE_RDONLY 1
175 #define MS_SYSINF_CARDTYPE_RDWR 2
176 #define MS_SYSINF_CARDTYPE_HYBRID 3
177 #define MS_SYSINF_SECURITY 0x01
178 #define MS_SYSINF_SECURITY_NO_SUPPORT MS_SYSINF_SECURITY
179 #define MS_SYSINF_SECURITY_SUPPORT 0
181 #define MS_SYSINF_RESERVED1 1
182 #define MS_SYSINF_RESERVED2 1
184 #define MS_SYSENT_TYPE_INVALID_BLOCK 0x01
185 #define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */
187 #define SIZE_OF_KIRO 1024
188 #define BYTE_MASK 0xff
191 #define MS_STATUS_WRITE_PROTECT 0x0106
192 #define MS_STATUS_SUCCESS 0x0000
193 #define MS_ERROR_FLASH_READ 0x8003
194 #define MS_ERROR_FLASH_ERASE 0x8005
195 #define MS_LB_ERROR 0xfff0
196 #define MS_LB_BOOT_BLOCK 0xfff1
197 #define MS_LB_INITIAL_ERROR 0xfff2
198 #define MS_STATUS_SUCCESS_WITH_ECC 0xfff3
199 #define MS_LB_ACQUIRED_ERROR 0xfff4
200 #define MS_LB_NOT_USED_ERASED 0xfff5
201 #define MS_NOCARD_ERROR 0xfff8
202 #define MS_NO_MEMORY_ERROR 0xfff9
203 #define MS_STATUS_INT_ERROR 0xfffa
204 #define MS_STATUS_ERROR 0xfffe
205 #define MS_LB_NOT_USED 0xffff
207 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */
208 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
210 #define MS_BOOT_BLOCK_ID 0x0001
211 #define MS_BOOT_BLOCK_FORMAT_VERSION 0x0100
212 #define MS_BOOT_BLOCK_DATA_ENTRIES 2
214 #define MS_NUMBER_OF_SYSTEM_ENTRY 4
215 #define MS_NUMBER_OF_BOOT_BLOCK 2
216 #define MS_BYTES_PER_PAGE 512
217 #define MS_LOGICAL_BLOCKS_PER_SEGMENT 496
218 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT 494
220 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */
221 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff
224 #define MS_REG_OVR_BKST 0x80 /* block status */
225 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
226 #define MS_REG_OVR_BKST_NG 0x00 /* NG */
228 /* Status Register 1 */
229 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
230 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
231 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
233 /* MemoryStick Register */
234 /* Status Register 0 */
235 #define MS_REG_ST0_WP 0x01 /* write protected */
236 #define MS_REG_ST0_WP_ON MS_REG_ST0_WP
238 #define MS_LIB_CTRL_RDONLY 0
239 #define MS_LIB_CTRL_WRPROTECT 1
242 #define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
243 #define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
245 #define ms_lib_ctrl_set(pdx, Flag) ((pdx)->MS_Lib.flags |= (1 << (Flag)))
246 #define ms_lib_ctrl_reset(pdx, Flag) ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
247 #define ms_lib_ctrl_check(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag)))
249 #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))
250 #define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
251 #define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0))
285 struct ms_bootblock_cis {
286 u8 bCistplDEVICE[6]; /* 0 */
287 u8 bCistplDEVICE0C[6]; /* 6 */
288 u8 bCistplJEDECC[4]; /* 12 */
289 u8 bCistplMANFID[6]; /* 16 */
290 u8 bCistplVER1[32]; /* 22 */
291 u8 bCistplFUNCID[4]; /* 54 */
292 u8 bCistplFUNCE0[4]; /* 58 */
293 u8 bCistplFUNCE1[5]; /* 62 */
294 u8 bCistplCONF[7]; /* 67 */
295 u8 bCistplCFTBLENT0[10];/* 74 */
296 u8 bCistplCFTBLENT1[8]; /* 84 */
297 u8 bCistplCFTBLENT2[12];/* 92 */
298 u8 bCistplCFTBLENT3[8]; /* 104 */
299 u8 bCistplCFTBLENT4[17];/* 112 */
300 u8 bCistplCFTBLENT5[8]; /* 129 */
301 u8 bCistplCFTBLENT6[17];/* 137 */
302 u8 bCistplCFTBLENT7[8]; /* 154 */
303 u8 bCistplNOLINK[3]; /* 162 */
306 struct ms_bootblock_idi {
307 #define MS_IDI_GENERAL_CONF 0x848A
308 u16 wIDIgeneralConfiguration; /* 0 */
309 u16 wIDInumberOfCylinder; /* 1 */
310 u16 wIDIreserved0; /* 2 */
311 u16 wIDInumberOfHead; /* 3 */
312 u16 wIDIbytesPerTrack; /* 4 */
313 u16 wIDIbytesPerSector; /* 5 */
314 u16 wIDIsectorsPerTrack; /* 6 */
315 u16 wIDItotalSectors[2]; /* 7-8 high,low */
316 u16 wIDIreserved1[11]; /* 9-19 */
317 u16 wIDIbufferType; /* 20 */
318 u16 wIDIbufferSize; /* 21 */
319 u16 wIDIlongCmdECC; /* 22 */
320 u16 wIDIfirmVersion[4]; /* 23-26 */
321 u16 wIDImodelName[20]; /* 27-46 */
322 u16 wIDIreserved2; /* 47 */
323 u16 wIDIlongWordSupported; /* 48 */
324 u16 wIDIdmaSupported; /* 49 */
325 u16 wIDIreserved3; /* 50 */
326 u16 wIDIpioTiming; /* 51 */
327 u16 wIDIdmaTiming; /* 52 */
328 u16 wIDItransferParameter; /* 53 */
329 u16 wIDIformattedCylinder; /* 54 */
330 u16 wIDIformattedHead; /* 55 */
331 u16 wIDIformattedSectorsPerTrack;/* 56 */
332 u16 wIDIformattedTotalSectors[2];/* 57-58 */
333 u16 wIDImultiSector; /* 59 */
334 u16 wIDIlbaSectors[2]; /* 60-61 */
335 u16 wIDIsingleWordDMA; /* 62 */
336 u16 wIDImultiWordDMA; /* 63 */
337 u16 wIDIreserved4[192]; /* 64-255 */
340 struct ms_bootblock_sysent_rec {
347 struct ms_bootblock_sysent {
348 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
351 struct ms_bootblock_sysinf {
352 u8 bMsClass; /* must be 1 */
353 u8 bCardType; /* see below */
354 u16 wBlockSize; /* n KB */
355 u16 wBlockNumber; /* number of physical block */
356 u16 wTotalBlockNumber; /* number of logical block */
357 u16 wPageSize; /* must be 0x200 */
358 u8 bExtraSize; /* 0x10 */
362 u8 bAssemblyMakerCode;
363 u8 bAssemblyMachineCode[3];
364 u16 wMemoryMakerCode;
365 u16 wMemoryDeviceCode;
371 u16 wControllerChipNumber;
372 u16 wControllerFunction; /* New MS */
373 u8 bReserved3[9]; /* New MS */
374 u8 bParallelSupport; /* New MS */
375 u16 wFormatValue; /* New MS */
385 struct ms_bootblock_header {
389 u8 bNumberOfDataEntry;
393 struct ms_bootblock_page0 {
394 struct ms_bootblock_header header;
395 struct ms_bootblock_sysent sysent;
396 struct ms_bootblock_sysinf sysinf;
399 struct ms_bootblock_cis_idi {
401 struct ms_bootblock_cis cis;
406 struct ms_bootblock_idi idi;
412 /* ENE MS Lib struct */
413 struct ms_lib_type_extdat {
426 u32 NumberOfCylinder;
427 u32 SectorsPerCylinder;
428 u16 cardType; /* R/W, RO, Hybrid */
431 u16 NumberOfPhyBlock;
432 u16 NumberOfLogBlock;
434 u16 *Phy2LogMap; /* phy2log table */
435 u16 *Log2PhyMap; /* log2phy table */
437 unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
438 unsigned char *blkpag;
439 struct ms_lib_type_extdat *blkext;
440 unsigned char copybuf[512];
444 /* SD Block Length */
445 /* 2^9 = 512 Bytes, The HW maximum read/write data length */
446 #define SD_BLOCK_LEN 9
448 struct ene_ub6250_info {
450 /* I/O bounce buffer */
454 struct SD_STATUS SD_Status;
455 struct MS_STATUS MS_Status;
456 struct SM_STATUS SM_Status;
458 /* ----- SD Control Data ---------------- */
459 /*SD_REGISTER SD_Regs; */
465 /* SD/MMC New spec. */
468 u8 SD20_HIGH_CAPACITY;
472 u8 MMC_HIGH_CAPACITY;
474 /*----- MS Control Data ---------------- */
477 struct ms_lib_ctrl MS_Lib;
481 /*----- SM Control Data ---------------- */
485 unsigned char *testbuf;
490 /*------Power Managerment ---------------*/
494 static int ene_sd_init(struct us_data *us);
495 static int ene_ms_init(struct us_data *us);
496 static int ene_load_bincode(struct us_data *us, unsigned char flag);
498 static void ene_ub6250_info_destructor(void *extra)
500 struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra;
507 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
509 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
510 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
513 unsigned int residue;
514 unsigned int cswlen = 0, partial = 0;
515 unsigned int transfer_length = bcb->DataTransferLength;
517 /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
518 /* send cmd to out endpoint */
519 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
520 bcb, US_BULK_CB_WRAP_LEN, NULL);
521 if (result != USB_STOR_XFER_GOOD) {
522 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
523 return USB_STOR_TRANSPORT_ERROR;
527 unsigned int pipe = fDir;
529 if (fDir == FDIR_READ)
530 pipe = us->recv_bulk_pipe;
532 pipe = us->send_bulk_pipe;
536 result = usb_stor_bulk_srb(us, pipe, us->srb);
538 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
539 transfer_length, 0, &partial);
541 if (result != USB_STOR_XFER_GOOD) {
542 usb_stor_dbg(us, "data transfer fail ---\n");
543 return USB_STOR_TRANSPORT_ERROR;
547 /* Get CSW for device status */
548 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
549 US_BULK_CS_WRAP_LEN, &cswlen);
551 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
552 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
553 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
554 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
557 if (result == USB_STOR_XFER_STALLED) {
558 /* get the status again */
559 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
560 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
561 bcs, US_BULK_CS_WRAP_LEN, NULL);
564 if (result != USB_STOR_XFER_GOOD)
565 return USB_STOR_TRANSPORT_ERROR;
567 /* check bulk status */
568 residue = le32_to_cpu(bcs->Residue);
571 * try to compute the actual residue, based on how much data
572 * was really transferred and what the device tells us
574 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
575 residue = min(residue, transfer_length);
577 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
581 if (bcs->Status != US_BULK_STAT_OK)
582 return USB_STOR_TRANSPORT_ERROR;
584 return USB_STOR_TRANSPORT_GOOD;
587 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
589 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
591 if (info->SD_Status.Insert && info->SD_Status.Ready)
592 return USB_STOR_TRANSPORT_GOOD;
595 return USB_STOR_TRANSPORT_GOOD;
598 return USB_STOR_TRANSPORT_GOOD;
601 static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
603 unsigned char data_ptr[36] = {
604 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
605 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
606 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
607 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
609 usb_stor_set_xfer_buf(data_ptr, 36, srb);
610 return USB_STOR_TRANSPORT_GOOD;
613 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
615 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
616 unsigned char mediaNoWP[12] = {
617 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
618 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
619 unsigned char mediaWP[12] = {
620 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
621 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
623 if (info->SD_Status.WtP)
624 usb_stor_set_xfer_buf(mediaWP, 12, srb);
626 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
629 return USB_STOR_TRANSPORT_GOOD;
632 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
636 unsigned int offset = 0;
637 unsigned char buf[8];
638 struct scatterlist *sg = NULL;
639 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
641 usb_stor_dbg(us, "sd_scsi_read_capacity\n");
642 if (info->SD_Status.HiCapacity) {
644 if (info->SD_Status.IsMMC)
645 bl_num = info->HC_C_SIZE-1;
647 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
649 bl_len = 1 << (info->SD_READ_BL_LEN);
650 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
651 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
653 info->bl_num = bl_num;
654 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
655 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
657 /*srb->request_bufflen = 8; */
658 buf[0] = (bl_num >> 24) & 0xff;
659 buf[1] = (bl_num >> 16) & 0xff;
660 buf[2] = (bl_num >> 8) & 0xff;
661 buf[3] = (bl_num >> 0) & 0xff;
662 buf[4] = (bl_len >> 24) & 0xff;
663 buf[5] = (bl_len >> 16) & 0xff;
664 buf[6] = (bl_len >> 8) & 0xff;
665 buf[7] = (bl_len >> 0) & 0xff;
667 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
669 return USB_STOR_TRANSPORT_GOOD;
672 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
675 unsigned char *cdb = srb->cmnd;
676 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
677 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
679 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
680 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
681 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
682 u32 bnByte = bn * 0x200;
683 u32 blenByte = blen * 0x200;
685 if (bn > info->bl_num)
686 return USB_STOR_TRANSPORT_ERROR;
688 result = ene_load_bincode(us, SD_RW_PATTERN);
689 if (result != USB_STOR_XFER_GOOD) {
690 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
691 return USB_STOR_TRANSPORT_ERROR;
694 if (info->SD_Status.HiCapacity)
697 /* set up the command wrapper */
698 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
699 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
700 bcb->DataTransferLength = blenByte;
701 bcb->Flags = US_BULK_FLAG_IN;
703 bcb->CDB[5] = (unsigned char)(bnByte);
704 bcb->CDB[4] = (unsigned char)(bnByte>>8);
705 bcb->CDB[3] = (unsigned char)(bnByte>>16);
706 bcb->CDB[2] = (unsigned char)(bnByte>>24);
708 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
712 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
715 unsigned char *cdb = srb->cmnd;
716 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
717 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
719 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
720 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
721 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
722 u32 bnByte = bn * 0x200;
723 u32 blenByte = blen * 0x200;
725 if (bn > info->bl_num)
726 return USB_STOR_TRANSPORT_ERROR;
728 result = ene_load_bincode(us, SD_RW_PATTERN);
729 if (result != USB_STOR_XFER_GOOD) {
730 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
731 return USB_STOR_TRANSPORT_ERROR;
734 if (info->SD_Status.HiCapacity)
737 /* set up the command wrapper */
738 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
739 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
740 bcb->DataTransferLength = blenByte;
743 bcb->CDB[5] = (unsigned char)(bnByte);
744 bcb->CDB[4] = (unsigned char)(bnByte>>8);
745 bcb->CDB[3] = (unsigned char)(bnByte>>16);
746 bcb->CDB[2] = (unsigned char)(bnByte>>24);
748 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
756 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
758 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
760 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
763 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
764 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
769 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
771 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
773 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
776 info->MS_Lib.Phy2LogMap[phyblk] = mark;
781 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
783 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
786 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
788 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
791 static int ms_lib_free_logicalmap(struct us_data *us)
793 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
795 kfree(info->MS_Lib.Phy2LogMap);
796 info->MS_Lib.Phy2LogMap = NULL;
798 kfree(info->MS_Lib.Log2PhyMap);
799 info->MS_Lib.Log2PhyMap = NULL;
804 static int ms_lib_alloc_logicalmap(struct us_data *us)
807 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
809 info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL);
810 info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL);
812 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
813 ms_lib_free_logicalmap(us);
817 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
818 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
820 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
821 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
826 static void ms_lib_clear_writebuf(struct us_data *us)
829 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
831 info->MS_Lib.wrtblk = (u16)-1;
832 ms_lib_clear_pagemap(info);
834 if (info->MS_Lib.blkpag)
835 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
837 if (info->MS_Lib.blkext) {
838 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
839 info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
840 info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
841 info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
842 info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
847 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
850 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
852 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
853 for (Count = 0; PhyBlock < Ende; PhyBlock++) {
854 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
856 case MS_LB_NOT_USED_ERASED:
866 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
867 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
869 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
870 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
871 u8 *bbuf = info->bbuf;
873 u32 bn = PhyBlockAddr * 0x20 + PageNum;
875 result = ene_load_bincode(us, MS_RW_PATTERN);
876 if (result != USB_STOR_XFER_GOOD)
877 return USB_STOR_TRANSPORT_ERROR;
880 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
881 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
882 bcb->DataTransferLength = 0x200;
883 bcb->Flags = US_BULK_FLAG_IN;
886 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
888 bcb->CDB[5] = (unsigned char)(bn);
889 bcb->CDB[4] = (unsigned char)(bn>>8);
890 bcb->CDB[3] = (unsigned char)(bn>>16);
891 bcb->CDB[2] = (unsigned char)(bn>>24);
893 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
894 if (result != USB_STOR_XFER_GOOD)
895 return USB_STOR_TRANSPORT_ERROR;
898 /* Read Extra Data */
899 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
900 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
901 bcb->DataTransferLength = 0x4;
902 bcb->Flags = US_BULK_FLAG_IN;
906 bcb->CDB[5] = (unsigned char)(PageNum);
907 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
908 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
909 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
912 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
913 if (result != USB_STOR_XFER_GOOD)
914 return USB_STOR_TRANSPORT_ERROR;
916 ExtraDat->reserved = 0;
917 ExtraDat->intr = 0x80; /* Not yet,fireware support */
918 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
920 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
921 ExtraDat->ovrflg = bbuf[0];
922 ExtraDat->mngflg = bbuf[1];
923 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
925 return USB_STOR_TRANSPORT_GOOD;
928 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
930 struct ms_bootblock_sysent *SysEntry;
931 struct ms_bootblock_sysinf *SysInfo;
935 struct ms_lib_type_extdat ExtraData;
936 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
938 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
939 if (PageBuffer == NULL)
944 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
946 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
947 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
948 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
949 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
950 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
951 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
952 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
955 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
956 case MS_SYSINF_CARDTYPE_RDONLY:
957 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
959 case MS_SYSINF_CARDTYPE_RDWR:
960 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
962 case MS_SYSINF_CARDTYPE_HYBRID:
967 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
968 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
969 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
970 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
971 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
972 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
974 /*Allocate to all number of logicalblock and physicalblock */
975 if (ms_lib_alloc_logicalmap(us))
978 /* Mark the book block */
979 ms_lib_set_bootblockmark(us, PhyBlock);
981 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
983 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
984 u32 EntryOffset, EntrySize;
986 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
988 if (EntryOffset == 0xffffff)
990 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
995 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
999 u8 PrevPageNumber = 0;
1002 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
1005 while (EntrySize > 0) {
1007 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1008 if (PageNumber != PrevPageNumber) {
1009 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1010 case MS_STATUS_SUCCESS:
1012 case MS_STATUS_WRITE_PROTECT:
1013 case MS_ERROR_FLASH_READ:
1014 case MS_STATUS_ERROR:
1019 PrevPageNumber = PageNumber;
1022 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1023 if (phyblk < 0x0fff)
1024 ms_lib_set_initialerrorblock(us, phyblk);
1029 } else if (i == 1) { /* CIS/IDI */
1030 struct ms_bootblock_idi *idi;
1032 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1035 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1036 case MS_STATUS_SUCCESS:
1038 case MS_STATUS_WRITE_PROTECT:
1039 case MS_ERROR_FLASH_READ:
1040 case MS_STATUS_ERROR:
1045 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1046 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1049 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1050 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1059 ms_lib_free_logicalmap(us);
1067 static void ms_lib_free_writebuf(struct us_data *us)
1069 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1070 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1072 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1074 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1076 if (info->MS_Lib.blkpag) {
1077 kfree(info->MS_Lib.blkpag); /* Arnold test ... */
1078 info->MS_Lib.blkpag = NULL;
1081 if (info->MS_Lib.blkext) {
1082 kfree(info->MS_Lib.blkext); /* Arnold test ... */
1083 info->MS_Lib.blkext = NULL;
1088 static void ms_lib_free_allocatedarea(struct us_data *us)
1090 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1092 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1093 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1095 /* set struct us point flag to 0 */
1096 info->MS_Lib.flags = 0;
1097 info->MS_Lib.BytesPerSector = 0;
1098 info->MS_Lib.SectorsPerCylinder = 0;
1100 info->MS_Lib.cardType = 0;
1101 info->MS_Lib.blockSize = 0;
1102 info->MS_Lib.PagesPerBlock = 0;
1104 info->MS_Lib.NumberOfPhyBlock = 0;
1105 info->MS_Lib.NumberOfLogBlock = 0;
1109 static int ms_lib_alloc_writebuf(struct us_data *us)
1111 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1113 info->MS_Lib.wrtblk = (u16)-1;
1115 info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL);
1116 info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL);
1118 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1119 ms_lib_free_writebuf(us);
1123 ms_lib_clear_writebuf(us);
1128 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1130 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1132 if (logblk == MS_LB_NOT_USED)
1135 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1136 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1139 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1140 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1145 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1146 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1148 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1151 result = ene_load_bincode(us, MS_RW_PATTERN);
1152 if (result != USB_STOR_XFER_GOOD)
1153 return USB_STOR_TRANSPORT_ERROR;
1155 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1156 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1157 bcb->DataTransferLength = 0x200*len;
1161 bcb->CDB[4] = (unsigned char)(oldphy);
1162 bcb->CDB[3] = (unsigned char)(oldphy>>8);
1163 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1164 bcb->CDB[7] = (unsigned char)(newphy);
1165 bcb->CDB[6] = (unsigned char)(newphy>>8);
1166 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1167 bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1168 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1169 bcb->CDB[10] = PageNum;
1171 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1172 if (result != USB_STOR_XFER_GOOD)
1173 return USB_STOR_TRANSPORT_ERROR;
1175 return USB_STOR_TRANSPORT_GOOD;
1178 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1180 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1182 u32 bn = PhyBlockAddr;
1184 result = ene_load_bincode(us, MS_RW_PATTERN);
1185 if (result != USB_STOR_XFER_GOOD)
1186 return USB_STOR_TRANSPORT_ERROR;
1188 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1189 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1190 bcb->DataTransferLength = 0x200;
1191 bcb->Flags = US_BULK_FLAG_IN;
1194 bcb->CDB[4] = (unsigned char)(bn);
1195 bcb->CDB[3] = (unsigned char)(bn>>8);
1196 bcb->CDB[2] = (unsigned char)(bn>>16);
1198 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1199 if (result != USB_STOR_XFER_GOOD)
1200 return USB_STOR_TRANSPORT_ERROR;
1202 return USB_STOR_TRANSPORT_GOOD;
1205 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1207 unsigned char *PageBuf = NULL;
1208 u16 result = MS_STATUS_SUCCESS;
1210 struct ms_lib_type_extdat extdat;
1211 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1213 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1214 if (PageBuf == NULL) {
1215 result = MS_NO_MEMORY_ERROR;
1219 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1221 blk = be16_to_cpu(PageBuf[index]);
1222 if (blk == MS_LB_NOT_USED)
1224 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1225 result = MS_ERROR_FLASH_READ;
1236 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1239 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1241 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1244 log = info->MS_Lib.Phy2LogMap[phyblk];
1246 if (log < info->MS_Lib.NumberOfLogBlock)
1247 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1249 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1250 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1255 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1256 u8 PageNum, u8 OverwriteFlag)
1258 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1261 result = ene_load_bincode(us, MS_RW_PATTERN);
1262 if (result != USB_STOR_XFER_GOOD)
1263 return USB_STOR_TRANSPORT_ERROR;
1265 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1266 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1267 bcb->DataTransferLength = 0x4;
1268 bcb->Flags = US_BULK_FLAG_IN;
1271 bcb->CDB[5] = (unsigned char)(PageNum);
1272 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1273 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1274 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1275 bcb->CDB[6] = OverwriteFlag;
1280 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1281 if (result != USB_STOR_XFER_GOOD)
1282 return USB_STOR_TRANSPORT_ERROR;
1284 return USB_STOR_TRANSPORT_GOOD;
1287 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1289 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1291 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1292 return MS_STATUS_ERROR;
1294 ms_lib_setacquired_errorblock(us, phyblk);
1296 if (ms_lib_iswritable(info))
1297 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1299 return MS_STATUS_SUCCESS;
1302 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1305 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1307 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1308 return MS_STATUS_ERROR;
1310 log = info->MS_Lib.Phy2LogMap[phyblk];
1312 if (log < info->MS_Lib.NumberOfLogBlock)
1313 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1315 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1317 if (ms_lib_iswritable(info)) {
1318 switch (ms_read_eraseblock(us, phyblk)) {
1319 case MS_STATUS_SUCCESS:
1320 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1321 return MS_STATUS_SUCCESS;
1322 case MS_ERROR_FLASH_ERASE:
1323 case MS_STATUS_INT_ERROR:
1324 ms_lib_error_phyblock(us, phyblk);
1325 return MS_ERROR_FLASH_ERASE;
1326 case MS_STATUS_ERROR:
1328 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1329 ms_lib_setacquired_errorblock(us, phyblk);
1330 return MS_STATUS_ERROR;
1334 ms_lib_setacquired_errorblock(us, phyblk);
1336 return MS_STATUS_SUCCESS;
1339 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1340 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1342 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1343 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1344 u8 *bbuf = info->bbuf;
1347 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1348 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1349 bcb->DataTransferLength = 0x4;
1350 bcb->Flags = US_BULK_FLAG_IN;
1353 bcb->CDB[5] = (unsigned char)(PageNum);
1354 bcb->CDB[4] = (unsigned char)(PhyBlock);
1355 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1356 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1359 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1360 if (result != USB_STOR_XFER_GOOD)
1361 return USB_STOR_TRANSPORT_ERROR;
1363 ExtraDat->reserved = 0;
1364 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
1365 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
1366 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
1367 ExtraDat->ovrflg = bbuf[0];
1368 ExtraDat->mngflg = bbuf[1];
1369 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
1371 return USB_STOR_TRANSPORT_GOOD;
1374 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1377 struct ms_lib_type_extdat extdat; /* need check */
1378 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1381 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1384 for (blk = phyblk + 1; blk != phyblk; blk++) {
1385 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1386 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1388 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1390 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1391 switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1392 case MS_STATUS_SUCCESS:
1393 case MS_STATUS_SUCCESS_WITH_ECC:
1395 case MS_NOCARD_ERROR:
1396 return MS_NOCARD_ERROR;
1397 case MS_STATUS_INT_ERROR:
1399 case MS_ERROR_FLASH_READ:
1401 ms_lib_setacquired_errorblock(us, blk);
1405 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1406 ms_lib_setacquired_errorblock(us, blk);
1410 switch (ms_lib_erase_phyblock(us, blk)) {
1411 case MS_STATUS_SUCCESS:
1413 case MS_STATUS_ERROR:
1415 case MS_ERROR_FLASH_ERASE:
1417 ms_lib_error_phyblock(us, blk);
1425 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1428 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1430 phyblk = ms_libconv_to_physical(info, logblk);
1431 if (phyblk >= MS_LB_ERROR) {
1432 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1435 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1436 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1437 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1440 return ms_libsearch_block_from_physical(us, phyblk);
1443 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1445 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1447 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1448 if (info->MS_Status.Insert && info->MS_Status.Ready) {
1449 return USB_STOR_TRANSPORT_GOOD;
1452 return USB_STOR_TRANSPORT_GOOD;
1455 return USB_STOR_TRANSPORT_GOOD;
1458 static int ms_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
1460 /* pr_info("MS_SCSI_Inquiry\n"); */
1461 unsigned char data_ptr[36] = {
1462 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
1463 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
1464 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
1465 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
1467 usb_stor_set_xfer_buf(data_ptr, 36, srb);
1468 return USB_STOR_TRANSPORT_GOOD;
1471 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1473 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1474 unsigned char mediaNoWP[12] = {
1475 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1476 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1477 unsigned char mediaWP[12] = {
1478 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1479 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1481 if (info->MS_Status.WtP)
1482 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1484 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1486 return USB_STOR_TRANSPORT_GOOD;
1489 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1493 unsigned int offset = 0;
1494 unsigned char buf[8];
1495 struct scatterlist *sg = NULL;
1496 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1498 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1500 if (info->MS_Status.IsMSPro)
1501 bl_num = info->MSP_TotalBlock - 1;
1503 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1505 info->bl_num = bl_num;
1506 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1507 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1509 /*srb->request_bufflen = 8; */
1510 buf[0] = (bl_num >> 24) & 0xff;
1511 buf[1] = (bl_num >> 16) & 0xff;
1512 buf[2] = (bl_num >> 8) & 0xff;
1513 buf[3] = (bl_num >> 0) & 0xff;
1514 buf[4] = (bl_len >> 24) & 0xff;
1515 buf[5] = (bl_len >> 16) & 0xff;
1516 buf[6] = (bl_len >> 8) & 0xff;
1517 buf[7] = (bl_len >> 0) & 0xff;
1519 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1521 return USB_STOR_TRANSPORT_GOOD;
1524 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1526 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1529 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1530 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1533 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1537 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1538 u8 PageNum, u8 blen, void *buf)
1540 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1543 /* Read Extra Data */
1544 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1545 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1546 bcb->DataTransferLength = 0x4 * blen;
1547 bcb->Flags = US_BULK_FLAG_IN;
1550 bcb->CDB[5] = (unsigned char)(PageNum);
1551 bcb->CDB[4] = (unsigned char)(PhyBlock);
1552 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1553 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1556 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1557 if (result != USB_STOR_XFER_GOOD)
1558 return USB_STOR_TRANSPORT_ERROR;
1560 return USB_STOR_TRANSPORT_GOOD;
1563 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1565 u16 PhyBlock, newblk, i;
1566 u16 LogStart, LogEnde;
1567 struct ms_lib_type_extdat extdat;
1568 u32 count = 0, index = 0;
1569 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1570 u8 *bbuf = info->bbuf;
1572 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1573 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1575 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1576 switch (ms_libconv_to_logical(info, PhyBlock)) {
1577 case MS_STATUS_ERROR:
1583 if (count == PhyBlock) {
1584 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1588 index = (PhyBlock % 0x80) * 4;
1590 extdat.ovrflg = bbuf[index];
1591 extdat.mngflg = bbuf[index+1];
1592 extdat.logadr = memstick_logaddr(bbuf[index+2],
1595 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1596 ms_lib_setacquired_errorblock(us, PhyBlock);
1600 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1601 ms_lib_erase_phyblock(us, PhyBlock);
1605 if (extdat.logadr != MS_LB_NOT_USED) {
1606 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1607 ms_lib_erase_phyblock(us, PhyBlock);
1611 newblk = ms_libconv_to_physical(info, extdat.logadr);
1613 if (newblk != MS_LB_NOT_USED) {
1614 if (extdat.logadr == 0) {
1615 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1616 if (ms_lib_check_disableblock(us, btBlk1st)) {
1617 ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1622 ms_lib_read_extra(us, newblk, 0, &extdat);
1623 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1624 ms_lib_erase_phyblock(us, PhyBlock);
1627 ms_lib_erase_phyblock(us, newblk);
1631 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1636 return MS_STATUS_SUCCESS;
1640 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1643 unsigned char *cdb = srb->cmnd;
1644 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1645 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1647 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1648 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1649 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1650 u32 blenByte = blen * 0x200;
1652 if (bn > info->bl_num)
1653 return USB_STOR_TRANSPORT_ERROR;
1655 if (info->MS_Status.IsMSPro) {
1656 result = ene_load_bincode(us, MSP_RW_PATTERN);
1657 if (result != USB_STOR_XFER_GOOD) {
1658 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1659 return USB_STOR_TRANSPORT_ERROR;
1662 /* set up the command wrapper */
1663 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1664 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1665 bcb->DataTransferLength = blenByte;
1666 bcb->Flags = US_BULK_FLAG_IN;
1669 bcb->CDB[5] = (unsigned char)(bn);
1670 bcb->CDB[4] = (unsigned char)(bn>>8);
1671 bcb->CDB[3] = (unsigned char)(bn>>16);
1672 bcb->CDB[2] = (unsigned char)(bn>>24);
1674 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1683 buf = kmalloc(blenByte, GFP_KERNEL);
1685 return USB_STOR_TRANSPORT_ERROR;
1687 result = ene_load_bincode(us, MS_RW_PATTERN);
1688 if (result != USB_STOR_XFER_GOOD) {
1689 pr_info("Load MS RW pattern Fail !!\n");
1690 result = USB_STOR_TRANSPORT_ERROR;
1694 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1695 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1698 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1699 len = info->MS_Lib.PagesPerBlock-PageNum;
1703 phyblk = ms_libconv_to_physical(info, logblk);
1704 blkno = phyblk * 0x20 + PageNum;
1706 /* set up the command wrapper */
1707 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1708 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1709 bcb->DataTransferLength = 0x200 * len;
1710 bcb->Flags = US_BULK_FLAG_IN;
1713 bcb->CDB[5] = (unsigned char)(blkno);
1714 bcb->CDB[4] = (unsigned char)(blkno>>8);
1715 bcb->CDB[3] = (unsigned char)(blkno>>16);
1716 bcb->CDB[2] = (unsigned char)(blkno>>24);
1718 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1719 if (result != USB_STOR_XFER_GOOD) {
1720 pr_info("MS_SCSI_Read --- result = %x\n", result);
1721 result = USB_STOR_TRANSPORT_ERROR;
1730 offset += MS_BYTES_PER_PAGE*len;
1732 usb_stor_set_xfer_buf(buf, blenByte, srb);
1739 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1742 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1743 unsigned char *cdb = srb->cmnd;
1744 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1746 u32 bn = ((cdb[2] << 24) & 0xff000000) |
1747 ((cdb[3] << 16) & 0x00ff0000) |
1748 ((cdb[4] << 8) & 0x0000ff00) |
1749 ((cdb[5] << 0) & 0x000000ff);
1750 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1751 u32 blenByte = blen * 0x200;
1753 if (bn > info->bl_num)
1754 return USB_STOR_TRANSPORT_ERROR;
1756 if (info->MS_Status.IsMSPro) {
1757 result = ene_load_bincode(us, MSP_RW_PATTERN);
1758 if (result != USB_STOR_XFER_GOOD) {
1759 pr_info("Load MSP RW pattern Fail !!\n");
1760 return USB_STOR_TRANSPORT_ERROR;
1763 /* set up the command wrapper */
1764 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1765 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1766 bcb->DataTransferLength = blenByte;
1770 bcb->CDB[5] = (unsigned char)(bn);
1771 bcb->CDB[4] = (unsigned char)(bn>>8);
1772 bcb->CDB[3] = (unsigned char)(bn>>16);
1773 bcb->CDB[2] = (unsigned char)(bn>>24);
1775 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1781 u16 len, oldphy, newphy;
1783 buf = kmalloc(blenByte, GFP_KERNEL);
1785 return USB_STOR_TRANSPORT_ERROR;
1786 usb_stor_set_xfer_buf(buf, blenByte, srb);
1788 result = ene_load_bincode(us, MS_RW_PATTERN);
1789 if (result != USB_STOR_XFER_GOOD) {
1790 pr_info("Load MS RW pattern Fail !!\n");
1791 result = USB_STOR_TRANSPORT_ERROR;
1795 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1796 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1799 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1800 len = info->MS_Lib.PagesPerBlock-PageNum;
1804 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1805 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1807 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1809 if (result != USB_STOR_XFER_GOOD) {
1810 pr_info("MS_SCSI_Write --- result = %x\n", result);
1811 result = USB_STOR_TRANSPORT_ERROR;
1815 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1816 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1823 offset += MS_BYTES_PER_PAGE*len;
1835 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1837 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1840 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1841 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1842 bcb->DataTransferLength = 0x01;
1843 bcb->Flags = US_BULK_FLAG_IN;
1845 bcb->CDB[2] = (unsigned char)(index>>8);
1846 bcb->CDB[3] = (unsigned char)index;
1848 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1852 static int ene_get_card_status(struct us_data *us, u8 *buf)
1856 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1858 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1859 reg4b = *(u32 *)&buf[0x18];
1860 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1862 tmpreg = (u16) reg4b;
1863 reg4b = *(u32 *)(&buf[0x14]);
1864 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1865 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1867 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1868 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1869 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1870 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1872 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1873 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1874 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1876 info->SD_Block_Mult = 1;
1879 return USB_STOR_TRANSPORT_GOOD;
1882 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1885 char *fw_name = NULL;
1886 unsigned char *buf = NULL;
1887 const struct firmware *sd_fw = NULL;
1888 int result = USB_STOR_TRANSPORT_ERROR;
1889 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1890 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1892 if (info->BIN_FLAG == flag)
1893 return USB_STOR_TRANSPORT_GOOD;
1897 case SD_INIT1_PATTERN:
1898 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1899 fw_name = SD_INIT1_FIRMWARE;
1901 case SD_INIT2_PATTERN:
1902 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1903 fw_name = SD_INIT2_FIRMWARE;
1906 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1907 fw_name = SD_RW_FIRMWARE;
1910 case MS_INIT_PATTERN:
1911 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1912 fw_name = MS_INIT_FIRMWARE;
1914 case MSP_RW_PATTERN:
1915 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1916 fw_name = MSP_RW_FIRMWARE;
1919 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1920 fw_name = MS_RW_FIRMWARE;
1923 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1927 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1929 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1932 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1936 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1937 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1938 bcb->DataTransferLength = sd_fw->size;
1942 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1943 info->BIN_FLAG = flag;
1947 release_firmware(sd_fw);
1951 static int ms_card_init(struct us_data *us)
1955 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1956 struct ms_lib_type_extdat extdat;
1957 u16 btBlk1st, btBlk2nd;
1959 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1961 printk(KERN_INFO "MS_CardInit start\n");
1963 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1965 /* get two PageBuffer */
1966 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1967 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1968 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1969 result = MS_NO_MEMORY_ERROR;
1973 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1976 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1978 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1979 case MS_STATUS_SUCCESS:
1981 case MS_STATUS_INT_ERROR:
1983 case MS_STATUS_ERROR:
1988 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1991 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1992 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1993 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1994 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1997 if (btBlk1st != MS_LB_NOT_USED) {
1998 btBlk2nd = TmpBlock;
2002 btBlk1st = TmpBlock;
2003 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
2004 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2008 if (btBlk1st == MS_LB_NOT_USED) {
2009 result = MS_STATUS_ERROR;
2014 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2015 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2017 result = MS_STATUS_ERROR;
2018 /* 1st Boot Block */
2019 if (btBlk1stErred == 0)
2020 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2022 /* 2nd Boot Block */
2023 if (result && (btBlk2nd != MS_LB_NOT_USED))
2024 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2027 result = MS_STATUS_ERROR;
2031 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2032 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2034 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2036 if (btBlk2nd != MS_LB_NOT_USED) {
2037 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2038 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2040 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2043 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2047 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2048 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2049 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2050 if (ms_count_freeblock(us, TmpBlock) == 0) {
2051 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2057 if (ms_lib_alloc_writebuf(us)) {
2058 result = MS_NO_MEMORY_ERROR;
2062 result = MS_STATUS_SUCCESS;
2068 printk(KERN_INFO "MS_CardInit end\n");
2072 static int ene_ms_init(struct us_data *us)
2074 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2076 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2077 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2078 u8 *bbuf = info->bbuf;
2080 printk(KERN_INFO "transport --- ENE_MSInit\n");
2082 /* the same part to test ENE */
2084 result = ene_load_bincode(us, MS_INIT_PATTERN);
2085 if (result != USB_STOR_XFER_GOOD) {
2086 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2087 return USB_STOR_TRANSPORT_ERROR;
2090 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2091 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2092 bcb->DataTransferLength = 0x200;
2093 bcb->Flags = US_BULK_FLAG_IN;
2097 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2098 if (result != USB_STOR_XFER_GOOD) {
2099 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2100 return USB_STOR_TRANSPORT_ERROR;
2102 /* the same part to test ENE */
2103 info->MS_Status = *(struct MS_STATUS *) bbuf;
2105 if (info->MS_Status.Insert && info->MS_Status.Ready) {
2106 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert);
2107 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready);
2108 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro);
2109 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG);
2110 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2111 if (info->MS_Status.IsMSPro) {
2112 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7];
2113 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
2114 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2116 ms_card_init(us); /* Card is MS (to ms.c)*/
2118 usb_stor_dbg(us, "MS Init Code OK !!\n");
2120 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
2121 return USB_STOR_TRANSPORT_ERROR;
2124 return USB_STOR_TRANSPORT_GOOD;
2127 static int ene_sd_init(struct us_data *us)
2130 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2131 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2132 u8 *bbuf = info->bbuf;
2134 usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2135 /* SD Init Part-1 */
2136 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2137 if (result != USB_STOR_XFER_GOOD) {
2138 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2139 return USB_STOR_TRANSPORT_ERROR;
2142 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2143 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2144 bcb->Flags = US_BULK_FLAG_IN;
2147 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2148 if (result != USB_STOR_XFER_GOOD) {
2149 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2150 return USB_STOR_TRANSPORT_ERROR;
2153 /* SD Init Part-2 */
2154 result = ene_load_bincode(us, SD_INIT2_PATTERN);
2155 if (result != USB_STOR_XFER_GOOD) {
2156 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2157 return USB_STOR_TRANSPORT_ERROR;
2160 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2161 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2162 bcb->DataTransferLength = 0x200;
2163 bcb->Flags = US_BULK_FLAG_IN;
2166 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2167 if (result != USB_STOR_XFER_GOOD) {
2168 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2169 return USB_STOR_TRANSPORT_ERROR;
2172 info->SD_Status = *(struct SD_STATUS *) bbuf;
2173 if (info->SD_Status.Insert && info->SD_Status.Ready) {
2174 struct SD_STATUS *s = &info->SD_Status;
2176 ene_get_card_status(us, bbuf);
2177 usb_stor_dbg(us, "Insert = %x\n", s->Insert);
2178 usb_stor_dbg(us, "Ready = %x\n", s->Ready);
2179 usb_stor_dbg(us, "IsMMC = %x\n", s->IsMMC);
2180 usb_stor_dbg(us, "HiCapacity = %x\n", s->HiCapacity);
2181 usb_stor_dbg(us, "HiSpeed = %x\n", s->HiSpeed);
2182 usb_stor_dbg(us, "WtP = %x\n", s->WtP);
2184 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
2185 return USB_STOR_TRANSPORT_ERROR;
2187 return USB_STOR_TRANSPORT_GOOD;
2191 static int ene_init(struct us_data *us)
2195 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2196 u8 *bbuf = info->bbuf;
2198 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
2199 if (result != USB_STOR_XFER_GOOD)
2200 return USB_STOR_TRANSPORT_ERROR;
2202 misc_reg03 = bbuf[0];
2203 if (misc_reg03 & 0x01) {
2204 if (!info->SD_Status.Ready) {
2205 result = ene_sd_init(us);
2206 if (result != USB_STOR_XFER_GOOD)
2207 return USB_STOR_TRANSPORT_ERROR;
2210 if (misc_reg03 & 0x02) {
2211 if (!info->MS_Status.Ready) {
2212 result = ene_ms_init(us);
2213 if (result != USB_STOR_XFER_GOOD)
2214 return USB_STOR_TRANSPORT_ERROR;
2220 /*----- sd_scsi_irp() ---------*/
2221 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2224 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2226 info->SrbStatus = SS_SUCCESS;
2227 switch (srb->cmnd[0]) {
2228 case TEST_UNIT_READY:
2229 result = sd_scsi_test_unit_ready(us, srb);
2232 result = sd_scsi_inquiry(us, srb);
2235 result = sd_scsi_mode_sense(us, srb);
2239 result = SD_SCSI_Start_Stop(us, srb);
2243 result = sd_scsi_read_capacity(us, srb);
2246 result = sd_scsi_read(us, srb);
2249 result = sd_scsi_write(us, srb);
2252 info->SrbStatus = SS_ILLEGAL_REQUEST;
2253 result = USB_STOR_TRANSPORT_FAILED;
2262 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2265 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2266 info->SrbStatus = SS_SUCCESS;
2267 switch (srb->cmnd[0]) {
2268 case TEST_UNIT_READY:
2269 result = ms_scsi_test_unit_ready(us, srb);
2272 result = ms_scsi_inquiry(us, srb);
2275 result = ms_scsi_mode_sense(us, srb);
2278 result = ms_scsi_read_capacity(us, srb);
2281 result = ms_scsi_read(us, srb);
2284 result = ms_scsi_write(us, srb);
2287 info->SrbStatus = SS_ILLEGAL_REQUEST;
2288 result = USB_STOR_TRANSPORT_FAILED;
2294 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2297 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2299 /*US_DEBUG(usb_stor_show_command(us, srb)); */
2300 scsi_set_resid(srb, 0);
2301 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) {
2302 result = ene_init(us);
2304 if (info->SD_Status.Ready)
2305 result = sd_scsi_irp(us, srb);
2307 if (info->MS_Status.Ready)
2308 result = ms_scsi_irp(us, srb);
2313 static struct scsi_host_template ene_ub6250_host_template;
2315 static int ene_ub6250_probe(struct usb_interface *intf,
2316 const struct usb_device_id *id)
2321 struct ene_ub6250_info *info;
2323 result = usb_stor_probe1(&us, intf, id,
2324 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2325 &ene_ub6250_host_template);
2329 /* FIXME: where should the code alloc extra buf ? */
2330 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2333 us->extra_destructor = ene_ub6250_info_destructor;
2335 info = (struct ene_ub6250_info *)(us->extra);
2336 info->bbuf = kmalloc(512, GFP_KERNEL);
2342 us->transport_name = "ene_ub6250";
2343 us->transport = ene_transport;
2346 result = usb_stor_probe2(us);
2350 /* probe card type */
2351 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2352 if (result != USB_STOR_XFER_GOOD) {
2353 usb_stor_disconnect(intf);
2354 return USB_STOR_TRANSPORT_ERROR;
2357 misc_reg03 = info->bbuf[0];
2358 if (!(misc_reg03 & 0x01)) {
2359 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2360 "It does not support SM cards.\n");
2369 static int ene_ub6250_resume(struct usb_interface *iface)
2372 struct us_data *us = usb_get_intfdata(iface);
2373 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2375 mutex_lock(&us->dev_mutex);
2377 if (us->suspend_resume_hook)
2378 (us->suspend_resume_hook)(us, US_RESUME);
2380 mutex_unlock(&us->dev_mutex);
2382 info->Power_IsResum = true;
2383 /*info->SD_Status.Ready = 0; */
2384 info->SD_Status = *(struct SD_STATUS *)&tmp;
2385 info->MS_Status = *(struct MS_STATUS *)&tmp;
2386 info->SM_Status = *(struct SM_STATUS *)&tmp;
2391 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.Ready = 0; */
2406 info->SD_Status = *(struct SD_STATUS *)&tmp;
2407 info->MS_Status = *(struct MS_STATUS *)&tmp;
2408 info->SM_Status = *(struct SM_STATUS *)&tmp;
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);