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 0x000000 /* No Sense */
94 #define SS_NOT_READY 0x023A00 /* Medium not present */
95 #define SS_MEDIUM_ERR 0x031100 /* Unrecovered read error */
96 #define SS_HW_ERR 0x040800 /* Communication failure */
97 #define SS_ILLEGAL_REQUEST 0x052000 /* Invalid command */
98 #define SS_UNIT_ATTENTION 0x062900 /* Reset occurred */
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))
280 struct ms_bootblock_cis {
281 u8 bCistplDEVICE[6]; /* 0 */
282 u8 bCistplDEVICE0C[6]; /* 6 */
283 u8 bCistplJEDECC[4]; /* 12 */
284 u8 bCistplMANFID[6]; /* 16 */
285 u8 bCistplVER1[32]; /* 22 */
286 u8 bCistplFUNCID[4]; /* 54 */
287 u8 bCistplFUNCE0[4]; /* 58 */
288 u8 bCistplFUNCE1[5]; /* 62 */
289 u8 bCistplCONF[7]; /* 67 */
290 u8 bCistplCFTBLENT0[10];/* 74 */
291 u8 bCistplCFTBLENT1[8]; /* 84 */
292 u8 bCistplCFTBLENT2[12];/* 92 */
293 u8 bCistplCFTBLENT3[8]; /* 104 */
294 u8 bCistplCFTBLENT4[17];/* 112 */
295 u8 bCistplCFTBLENT5[8]; /* 129 */
296 u8 bCistplCFTBLENT6[17];/* 137 */
297 u8 bCistplCFTBLENT7[8]; /* 154 */
298 u8 bCistplNOLINK[3]; /* 162 */
301 struct ms_bootblock_idi {
302 #define MS_IDI_GENERAL_CONF 0x848A
303 u16 wIDIgeneralConfiguration; /* 0 */
304 u16 wIDInumberOfCylinder; /* 1 */
305 u16 wIDIreserved0; /* 2 */
306 u16 wIDInumberOfHead; /* 3 */
307 u16 wIDIbytesPerTrack; /* 4 */
308 u16 wIDIbytesPerSector; /* 5 */
309 u16 wIDIsectorsPerTrack; /* 6 */
310 u16 wIDItotalSectors[2]; /* 7-8 high,low */
311 u16 wIDIreserved1[11]; /* 9-19 */
312 u16 wIDIbufferType; /* 20 */
313 u16 wIDIbufferSize; /* 21 */
314 u16 wIDIlongCmdECC; /* 22 */
315 u16 wIDIfirmVersion[4]; /* 23-26 */
316 u16 wIDImodelName[20]; /* 27-46 */
317 u16 wIDIreserved2; /* 47 */
318 u16 wIDIlongWordSupported; /* 48 */
319 u16 wIDIdmaSupported; /* 49 */
320 u16 wIDIreserved3; /* 50 */
321 u16 wIDIpioTiming; /* 51 */
322 u16 wIDIdmaTiming; /* 52 */
323 u16 wIDItransferParameter; /* 53 */
324 u16 wIDIformattedCylinder; /* 54 */
325 u16 wIDIformattedHead; /* 55 */
326 u16 wIDIformattedSectorsPerTrack;/* 56 */
327 u16 wIDIformattedTotalSectors[2];/* 57-58 */
328 u16 wIDImultiSector; /* 59 */
329 u16 wIDIlbaSectors[2]; /* 60-61 */
330 u16 wIDIsingleWordDMA; /* 62 */
331 u16 wIDImultiWordDMA; /* 63 */
332 u16 wIDIreserved4[192]; /* 64-255 */
335 struct ms_bootblock_sysent_rec {
342 struct ms_bootblock_sysent {
343 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
346 struct ms_bootblock_sysinf {
347 u8 bMsClass; /* must be 1 */
348 u8 bCardType; /* see below */
349 u16 wBlockSize; /* n KB */
350 u16 wBlockNumber; /* number of physical block */
351 u16 wTotalBlockNumber; /* number of logical block */
352 u16 wPageSize; /* must be 0x200 */
353 u8 bExtraSize; /* 0x10 */
357 u8 bAssemblyMakerCode;
358 u8 bAssemblyMachineCode[3];
359 u16 wMemoryMakerCode;
360 u16 wMemoryDeviceCode;
366 u16 wControllerChipNumber;
367 u16 wControllerFunction; /* New MS */
368 u8 bReserved3[9]; /* New MS */
369 u8 bParallelSupport; /* New MS */
370 u16 wFormatValue; /* New MS */
380 struct ms_bootblock_header {
384 u8 bNumberOfDataEntry;
388 struct ms_bootblock_page0 {
389 struct ms_bootblock_header header;
390 struct ms_bootblock_sysent sysent;
391 struct ms_bootblock_sysinf sysinf;
394 struct ms_bootblock_cis_idi {
396 struct ms_bootblock_cis cis;
401 struct ms_bootblock_idi idi;
407 /* ENE MS Lib struct */
408 struct ms_lib_type_extdat {
421 u32 NumberOfCylinder;
422 u32 SectorsPerCylinder;
423 u16 cardType; /* R/W, RO, Hybrid */
426 u16 NumberOfPhyBlock;
427 u16 NumberOfLogBlock;
429 u16 *Phy2LogMap; /* phy2log table */
430 u16 *Log2PhyMap; /* log2phy table */
432 unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
433 unsigned char *blkpag;
434 struct ms_lib_type_extdat *blkext;
435 unsigned char copybuf[512];
439 /* SD Block Length */
440 /* 2^9 = 512 Bytes, The HW maximum read/write data length */
441 #define SD_BLOCK_LEN 9
443 struct ene_ub6250_info {
445 /* I/O bounce buffer */
449 struct SD_STATUS SD_Status;
450 struct MS_STATUS MS_Status;
451 struct SM_STATUS SM_Status;
453 /* ----- SD Control Data ---------------- */
454 /*SD_REGISTER SD_Regs; */
460 /* SD/MMC New spec. */
463 u8 SD20_HIGH_CAPACITY;
467 u8 MMC_HIGH_CAPACITY;
469 /*----- MS Control Data ---------------- */
472 struct ms_lib_ctrl MS_Lib;
476 /*----- SM Control Data ---------------- */
480 unsigned char *testbuf;
485 /*------Power Managerment ---------------*/
489 static int ene_sd_init(struct us_data *us);
490 static int ene_ms_init(struct us_data *us);
491 static int ene_load_bincode(struct us_data *us, unsigned char flag);
493 static void ene_ub6250_info_destructor(void *extra)
495 struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra;
502 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
504 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
505 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
508 unsigned int residue;
509 unsigned int cswlen = 0, partial = 0;
510 unsigned int transfer_length = bcb->DataTransferLength;
512 /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
513 /* send cmd to out endpoint */
514 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
515 bcb, US_BULK_CB_WRAP_LEN, NULL);
516 if (result != USB_STOR_XFER_GOOD) {
517 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
518 return USB_STOR_TRANSPORT_ERROR;
522 unsigned int pipe = fDir;
524 if (fDir == FDIR_READ)
525 pipe = us->recv_bulk_pipe;
527 pipe = us->send_bulk_pipe;
531 result = usb_stor_bulk_srb(us, pipe, us->srb);
533 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
534 transfer_length, 0, &partial);
536 if (result != USB_STOR_XFER_GOOD) {
537 usb_stor_dbg(us, "data transfer fail ---\n");
538 return USB_STOR_TRANSPORT_ERROR;
542 /* Get CSW for device status */
543 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
544 US_BULK_CS_WRAP_LEN, &cswlen);
546 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
547 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
548 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
549 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
552 if (result == USB_STOR_XFER_STALLED) {
553 /* get the status again */
554 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
555 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
556 bcs, US_BULK_CS_WRAP_LEN, NULL);
559 if (result != USB_STOR_XFER_GOOD)
560 return USB_STOR_TRANSPORT_ERROR;
562 /* check bulk status */
563 residue = le32_to_cpu(bcs->Residue);
566 * try to compute the actual residue, based on how much data
567 * was really transferred and what the device tells us
569 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
570 residue = min(residue, transfer_length);
572 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
576 if (bcs->Status != US_BULK_STAT_OK)
577 return USB_STOR_TRANSPORT_ERROR;
579 return USB_STOR_TRANSPORT_GOOD;
582 static int do_scsi_request_sense(struct us_data *us, struct scsi_cmnd *srb)
584 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
585 unsigned char buf[18];
588 buf[0] = 0x70; /* Current error */
589 buf[2] = info->SrbStatus >> 16; /* Sense key */
590 buf[7] = 10; /* Additional length */
591 buf[12] = info->SrbStatus >> 8; /* ASC */
592 buf[13] = info->SrbStatus; /* ASCQ */
594 usb_stor_set_xfer_buf(buf, sizeof(buf), srb);
595 return USB_STOR_TRANSPORT_GOOD;
598 static int do_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
600 unsigned char data_ptr[36] = {
601 0x00, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
602 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
603 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
604 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
606 usb_stor_set_xfer_buf(data_ptr, 36, srb);
607 return USB_STOR_TRANSPORT_GOOD;
610 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
612 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
614 if (info->SD_Status.Insert && info->SD_Status.Ready)
615 return USB_STOR_TRANSPORT_GOOD;
618 return USB_STOR_TRANSPORT_GOOD;
621 return USB_STOR_TRANSPORT_GOOD;
624 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
626 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
627 unsigned char mediaNoWP[12] = {
628 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
629 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
630 unsigned char mediaWP[12] = {
631 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
632 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
634 if (info->SD_Status.WtP)
635 usb_stor_set_xfer_buf(mediaWP, 12, srb);
637 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
640 return USB_STOR_TRANSPORT_GOOD;
643 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
647 unsigned int offset = 0;
648 unsigned char buf[8];
649 struct scatterlist *sg = NULL;
650 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
652 usb_stor_dbg(us, "sd_scsi_read_capacity\n");
653 if (info->SD_Status.HiCapacity) {
655 if (info->SD_Status.IsMMC)
656 bl_num = info->HC_C_SIZE-1;
658 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
660 bl_len = 1 << (info->SD_READ_BL_LEN);
661 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
662 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
664 info->bl_num = bl_num;
665 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
666 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
668 /*srb->request_bufflen = 8; */
669 buf[0] = (bl_num >> 24) & 0xff;
670 buf[1] = (bl_num >> 16) & 0xff;
671 buf[2] = (bl_num >> 8) & 0xff;
672 buf[3] = (bl_num >> 0) & 0xff;
673 buf[4] = (bl_len >> 24) & 0xff;
674 buf[5] = (bl_len >> 16) & 0xff;
675 buf[6] = (bl_len >> 8) & 0xff;
676 buf[7] = (bl_len >> 0) & 0xff;
678 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
680 return USB_STOR_TRANSPORT_GOOD;
683 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
686 unsigned char *cdb = srb->cmnd;
687 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
688 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
690 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
691 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
692 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
693 u32 bnByte = bn * 0x200;
694 u32 blenByte = blen * 0x200;
696 if (bn > info->bl_num)
697 return USB_STOR_TRANSPORT_ERROR;
699 result = ene_load_bincode(us, SD_RW_PATTERN);
700 if (result != USB_STOR_XFER_GOOD) {
701 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
702 return USB_STOR_TRANSPORT_ERROR;
705 if (info->SD_Status.HiCapacity)
708 /* set up the command wrapper */
709 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
710 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
711 bcb->DataTransferLength = blenByte;
712 bcb->Flags = US_BULK_FLAG_IN;
714 bcb->CDB[5] = (unsigned char)(bnByte);
715 bcb->CDB[4] = (unsigned char)(bnByte>>8);
716 bcb->CDB[3] = (unsigned char)(bnByte>>16);
717 bcb->CDB[2] = (unsigned char)(bnByte>>24);
719 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
723 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
726 unsigned char *cdb = srb->cmnd;
727 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
728 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
730 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
731 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
732 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
733 u32 bnByte = bn * 0x200;
734 u32 blenByte = blen * 0x200;
736 if (bn > info->bl_num)
737 return USB_STOR_TRANSPORT_ERROR;
739 result = ene_load_bincode(us, SD_RW_PATTERN);
740 if (result != USB_STOR_XFER_GOOD) {
741 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
742 return USB_STOR_TRANSPORT_ERROR;
745 if (info->SD_Status.HiCapacity)
748 /* set up the command wrapper */
749 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
750 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
751 bcb->DataTransferLength = blenByte;
754 bcb->CDB[5] = (unsigned char)(bnByte);
755 bcb->CDB[4] = (unsigned char)(bnByte>>8);
756 bcb->CDB[3] = (unsigned char)(bnByte>>16);
757 bcb->CDB[2] = (unsigned char)(bnByte>>24);
759 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
767 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
769 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
771 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
774 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
775 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
780 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
782 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
784 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
787 info->MS_Lib.Phy2LogMap[phyblk] = mark;
792 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
794 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
797 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
799 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
802 static int ms_lib_free_logicalmap(struct us_data *us)
804 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
806 kfree(info->MS_Lib.Phy2LogMap);
807 info->MS_Lib.Phy2LogMap = NULL;
809 kfree(info->MS_Lib.Log2PhyMap);
810 info->MS_Lib.Log2PhyMap = NULL;
815 static int ms_lib_alloc_logicalmap(struct us_data *us)
818 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
820 info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL);
821 info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL);
823 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
824 ms_lib_free_logicalmap(us);
828 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
829 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
831 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
832 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
837 static void ms_lib_clear_writebuf(struct us_data *us)
840 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
842 info->MS_Lib.wrtblk = (u16)-1;
843 ms_lib_clear_pagemap(info);
845 if (info->MS_Lib.blkpag)
846 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
848 if (info->MS_Lib.blkext) {
849 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
850 info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
851 info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
852 info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
853 info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
858 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
861 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
863 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
864 for (Count = 0; PhyBlock < Ende; PhyBlock++) {
865 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
867 case MS_LB_NOT_USED_ERASED:
877 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
878 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
880 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
881 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
882 u8 *bbuf = info->bbuf;
884 u32 bn = PhyBlockAddr * 0x20 + PageNum;
886 result = ene_load_bincode(us, MS_RW_PATTERN);
887 if (result != USB_STOR_XFER_GOOD)
888 return USB_STOR_TRANSPORT_ERROR;
891 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
892 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
893 bcb->DataTransferLength = 0x200;
894 bcb->Flags = US_BULK_FLAG_IN;
897 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
899 bcb->CDB[5] = (unsigned char)(bn);
900 bcb->CDB[4] = (unsigned char)(bn>>8);
901 bcb->CDB[3] = (unsigned char)(bn>>16);
902 bcb->CDB[2] = (unsigned char)(bn>>24);
904 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
905 if (result != USB_STOR_XFER_GOOD)
906 return USB_STOR_TRANSPORT_ERROR;
909 /* Read Extra Data */
910 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
911 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
912 bcb->DataTransferLength = 0x4;
913 bcb->Flags = US_BULK_FLAG_IN;
917 bcb->CDB[5] = (unsigned char)(PageNum);
918 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
919 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
920 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
923 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
924 if (result != USB_STOR_XFER_GOOD)
925 return USB_STOR_TRANSPORT_ERROR;
927 ExtraDat->reserved = 0;
928 ExtraDat->intr = 0x80; /* Not yet,fireware support */
929 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
931 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
932 ExtraDat->ovrflg = bbuf[0];
933 ExtraDat->mngflg = bbuf[1];
934 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
936 return USB_STOR_TRANSPORT_GOOD;
939 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
941 struct ms_bootblock_sysent *SysEntry;
942 struct ms_bootblock_sysinf *SysInfo;
946 struct ms_lib_type_extdat ExtraData;
947 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
949 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
950 if (PageBuffer == NULL)
955 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
957 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
958 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
959 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
960 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
961 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
962 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
963 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
966 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
967 case MS_SYSINF_CARDTYPE_RDONLY:
968 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
970 case MS_SYSINF_CARDTYPE_RDWR:
971 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
973 case MS_SYSINF_CARDTYPE_HYBRID:
978 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
979 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
980 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
981 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
982 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
983 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
985 /*Allocate to all number of logicalblock and physicalblock */
986 if (ms_lib_alloc_logicalmap(us))
989 /* Mark the book block */
990 ms_lib_set_bootblockmark(us, PhyBlock);
992 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
994 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
995 u32 EntryOffset, EntrySize;
997 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
999 if (EntryOffset == 0xffffff)
1001 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
1006 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
1010 u8 PrevPageNumber = 0;
1013 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
1016 while (EntrySize > 0) {
1018 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1019 if (PageNumber != PrevPageNumber) {
1020 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1021 case MS_STATUS_SUCCESS:
1023 case MS_STATUS_WRITE_PROTECT:
1024 case MS_ERROR_FLASH_READ:
1025 case MS_STATUS_ERROR:
1030 PrevPageNumber = PageNumber;
1033 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1034 if (phyblk < 0x0fff)
1035 ms_lib_set_initialerrorblock(us, phyblk);
1040 } else if (i == 1) { /* CIS/IDI */
1041 struct ms_bootblock_idi *idi;
1043 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1046 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1047 case MS_STATUS_SUCCESS:
1049 case MS_STATUS_WRITE_PROTECT:
1050 case MS_ERROR_FLASH_READ:
1051 case MS_STATUS_ERROR:
1056 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1057 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1060 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1061 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1070 ms_lib_free_logicalmap(us);
1078 static void ms_lib_free_writebuf(struct us_data *us)
1080 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1081 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1083 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1085 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1087 if (info->MS_Lib.blkpag) {
1088 kfree(info->MS_Lib.blkpag); /* Arnold test ... */
1089 info->MS_Lib.blkpag = NULL;
1092 if (info->MS_Lib.blkext) {
1093 kfree(info->MS_Lib.blkext); /* Arnold test ... */
1094 info->MS_Lib.blkext = NULL;
1099 static void ms_lib_free_allocatedarea(struct us_data *us)
1101 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1103 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1104 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1106 /* set struct us point flag to 0 */
1107 info->MS_Lib.flags = 0;
1108 info->MS_Lib.BytesPerSector = 0;
1109 info->MS_Lib.SectorsPerCylinder = 0;
1111 info->MS_Lib.cardType = 0;
1112 info->MS_Lib.blockSize = 0;
1113 info->MS_Lib.PagesPerBlock = 0;
1115 info->MS_Lib.NumberOfPhyBlock = 0;
1116 info->MS_Lib.NumberOfLogBlock = 0;
1120 static int ms_lib_alloc_writebuf(struct us_data *us)
1122 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1124 info->MS_Lib.wrtblk = (u16)-1;
1126 info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL);
1127 info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL);
1129 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1130 ms_lib_free_writebuf(us);
1134 ms_lib_clear_writebuf(us);
1139 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1141 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1143 if (logblk == MS_LB_NOT_USED)
1146 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1147 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1150 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1151 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1156 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1157 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1159 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1162 result = ene_load_bincode(us, MS_RW_PATTERN);
1163 if (result != USB_STOR_XFER_GOOD)
1164 return USB_STOR_TRANSPORT_ERROR;
1166 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1167 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1168 bcb->DataTransferLength = 0x200*len;
1172 bcb->CDB[4] = (unsigned char)(oldphy);
1173 bcb->CDB[3] = (unsigned char)(oldphy>>8);
1174 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1175 bcb->CDB[7] = (unsigned char)(newphy);
1176 bcb->CDB[6] = (unsigned char)(newphy>>8);
1177 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1178 bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1179 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1180 bcb->CDB[10] = PageNum;
1182 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1183 if (result != USB_STOR_XFER_GOOD)
1184 return USB_STOR_TRANSPORT_ERROR;
1186 return USB_STOR_TRANSPORT_GOOD;
1189 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1191 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1193 u32 bn = PhyBlockAddr;
1195 result = ene_load_bincode(us, MS_RW_PATTERN);
1196 if (result != USB_STOR_XFER_GOOD)
1197 return USB_STOR_TRANSPORT_ERROR;
1199 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1200 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1201 bcb->DataTransferLength = 0x200;
1202 bcb->Flags = US_BULK_FLAG_IN;
1205 bcb->CDB[4] = (unsigned char)(bn);
1206 bcb->CDB[3] = (unsigned char)(bn>>8);
1207 bcb->CDB[2] = (unsigned char)(bn>>16);
1209 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1210 if (result != USB_STOR_XFER_GOOD)
1211 return USB_STOR_TRANSPORT_ERROR;
1213 return USB_STOR_TRANSPORT_GOOD;
1216 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1218 unsigned char *PageBuf = NULL;
1219 u16 result = MS_STATUS_SUCCESS;
1221 struct ms_lib_type_extdat extdat;
1222 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1224 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1225 if (PageBuf == NULL) {
1226 result = MS_NO_MEMORY_ERROR;
1230 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1232 blk = be16_to_cpu(PageBuf[index]);
1233 if (blk == MS_LB_NOT_USED)
1235 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1236 result = MS_ERROR_FLASH_READ;
1247 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1250 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1252 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1255 log = info->MS_Lib.Phy2LogMap[phyblk];
1257 if (log < info->MS_Lib.NumberOfLogBlock)
1258 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1260 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1261 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1266 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1267 u8 PageNum, u8 OverwriteFlag)
1269 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1272 result = ene_load_bincode(us, MS_RW_PATTERN);
1273 if (result != USB_STOR_XFER_GOOD)
1274 return USB_STOR_TRANSPORT_ERROR;
1276 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1277 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1278 bcb->DataTransferLength = 0x4;
1279 bcb->Flags = US_BULK_FLAG_IN;
1282 bcb->CDB[5] = (unsigned char)(PageNum);
1283 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1284 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1285 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1286 bcb->CDB[6] = OverwriteFlag;
1291 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1292 if (result != USB_STOR_XFER_GOOD)
1293 return USB_STOR_TRANSPORT_ERROR;
1295 return USB_STOR_TRANSPORT_GOOD;
1298 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1300 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1302 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1303 return MS_STATUS_ERROR;
1305 ms_lib_setacquired_errorblock(us, phyblk);
1307 if (ms_lib_iswritable(info))
1308 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1310 return MS_STATUS_SUCCESS;
1313 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1316 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1318 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1319 return MS_STATUS_ERROR;
1321 log = info->MS_Lib.Phy2LogMap[phyblk];
1323 if (log < info->MS_Lib.NumberOfLogBlock)
1324 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1326 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1328 if (ms_lib_iswritable(info)) {
1329 switch (ms_read_eraseblock(us, phyblk)) {
1330 case MS_STATUS_SUCCESS:
1331 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1332 return MS_STATUS_SUCCESS;
1333 case MS_ERROR_FLASH_ERASE:
1334 case MS_STATUS_INT_ERROR:
1335 ms_lib_error_phyblock(us, phyblk);
1336 return MS_ERROR_FLASH_ERASE;
1337 case MS_STATUS_ERROR:
1339 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1340 ms_lib_setacquired_errorblock(us, phyblk);
1341 return MS_STATUS_ERROR;
1345 ms_lib_setacquired_errorblock(us, phyblk);
1347 return MS_STATUS_SUCCESS;
1350 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1351 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1353 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1354 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1355 u8 *bbuf = info->bbuf;
1358 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1359 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1360 bcb->DataTransferLength = 0x4;
1361 bcb->Flags = US_BULK_FLAG_IN;
1364 bcb->CDB[5] = (unsigned char)(PageNum);
1365 bcb->CDB[4] = (unsigned char)(PhyBlock);
1366 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1367 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1370 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1371 if (result != USB_STOR_XFER_GOOD)
1372 return USB_STOR_TRANSPORT_ERROR;
1374 ExtraDat->reserved = 0;
1375 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
1376 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
1377 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
1378 ExtraDat->ovrflg = bbuf[0];
1379 ExtraDat->mngflg = bbuf[1];
1380 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
1382 return USB_STOR_TRANSPORT_GOOD;
1385 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1388 struct ms_lib_type_extdat extdat; /* need check */
1389 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1392 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1395 for (blk = phyblk + 1; blk != phyblk; blk++) {
1396 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1397 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1399 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1401 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1402 switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1403 case MS_STATUS_SUCCESS:
1404 case MS_STATUS_SUCCESS_WITH_ECC:
1406 case MS_NOCARD_ERROR:
1407 return MS_NOCARD_ERROR;
1408 case MS_STATUS_INT_ERROR:
1410 case MS_ERROR_FLASH_READ:
1412 ms_lib_setacquired_errorblock(us, blk);
1416 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1417 ms_lib_setacquired_errorblock(us, blk);
1421 switch (ms_lib_erase_phyblock(us, blk)) {
1422 case MS_STATUS_SUCCESS:
1424 case MS_STATUS_ERROR:
1426 case MS_ERROR_FLASH_ERASE:
1428 ms_lib_error_phyblock(us, blk);
1436 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1439 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1441 phyblk = ms_libconv_to_physical(info, logblk);
1442 if (phyblk >= MS_LB_ERROR) {
1443 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1446 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1447 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1448 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1451 return ms_libsearch_block_from_physical(us, phyblk);
1454 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1456 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1458 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1459 if (info->MS_Status.Insert && info->MS_Status.Ready) {
1460 return USB_STOR_TRANSPORT_GOOD;
1463 return USB_STOR_TRANSPORT_GOOD;
1466 return USB_STOR_TRANSPORT_GOOD;
1469 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1471 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1472 unsigned char mediaNoWP[12] = {
1473 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1474 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1475 unsigned char mediaWP[12] = {
1476 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1477 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1479 if (info->MS_Status.WtP)
1480 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1482 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1484 return USB_STOR_TRANSPORT_GOOD;
1487 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1491 unsigned int offset = 0;
1492 unsigned char buf[8];
1493 struct scatterlist *sg = NULL;
1494 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1496 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1498 if (info->MS_Status.IsMSPro)
1499 bl_num = info->MSP_TotalBlock - 1;
1501 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1503 info->bl_num = bl_num;
1504 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1505 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1507 /*srb->request_bufflen = 8; */
1508 buf[0] = (bl_num >> 24) & 0xff;
1509 buf[1] = (bl_num >> 16) & 0xff;
1510 buf[2] = (bl_num >> 8) & 0xff;
1511 buf[3] = (bl_num >> 0) & 0xff;
1512 buf[4] = (bl_len >> 24) & 0xff;
1513 buf[5] = (bl_len >> 16) & 0xff;
1514 buf[6] = (bl_len >> 8) & 0xff;
1515 buf[7] = (bl_len >> 0) & 0xff;
1517 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1519 return USB_STOR_TRANSPORT_GOOD;
1522 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1524 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1527 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1528 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1531 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1535 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1536 u8 PageNum, u8 blen, void *buf)
1538 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1541 /* Read Extra Data */
1542 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1543 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1544 bcb->DataTransferLength = 0x4 * blen;
1545 bcb->Flags = US_BULK_FLAG_IN;
1548 bcb->CDB[5] = (unsigned char)(PageNum);
1549 bcb->CDB[4] = (unsigned char)(PhyBlock);
1550 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1551 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1554 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1555 if (result != USB_STOR_XFER_GOOD)
1556 return USB_STOR_TRANSPORT_ERROR;
1558 return USB_STOR_TRANSPORT_GOOD;
1561 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1563 u16 PhyBlock, newblk, i;
1564 u16 LogStart, LogEnde;
1565 struct ms_lib_type_extdat extdat;
1566 u32 count = 0, index = 0;
1567 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1568 u8 *bbuf = info->bbuf;
1570 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1571 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1573 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1574 switch (ms_libconv_to_logical(info, PhyBlock)) {
1575 case MS_STATUS_ERROR:
1581 if (count == PhyBlock) {
1582 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1586 index = (PhyBlock % 0x80) * 4;
1588 extdat.ovrflg = bbuf[index];
1589 extdat.mngflg = bbuf[index+1];
1590 extdat.logadr = memstick_logaddr(bbuf[index+2],
1593 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1594 ms_lib_setacquired_errorblock(us, PhyBlock);
1598 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1599 ms_lib_erase_phyblock(us, PhyBlock);
1603 if (extdat.logadr != MS_LB_NOT_USED) {
1604 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1605 ms_lib_erase_phyblock(us, PhyBlock);
1609 newblk = ms_libconv_to_physical(info, extdat.logadr);
1611 if (newblk != MS_LB_NOT_USED) {
1612 if (extdat.logadr == 0) {
1613 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1614 if (ms_lib_check_disableblock(us, btBlk1st)) {
1615 ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1620 ms_lib_read_extra(us, newblk, 0, &extdat);
1621 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1622 ms_lib_erase_phyblock(us, PhyBlock);
1625 ms_lib_erase_phyblock(us, newblk);
1629 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1634 return MS_STATUS_SUCCESS;
1638 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1641 unsigned char *cdb = srb->cmnd;
1642 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1643 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1645 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1646 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1647 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1648 u32 blenByte = blen * 0x200;
1650 if (bn > info->bl_num)
1651 return USB_STOR_TRANSPORT_ERROR;
1653 if (info->MS_Status.IsMSPro) {
1654 result = ene_load_bincode(us, MSP_RW_PATTERN);
1655 if (result != USB_STOR_XFER_GOOD) {
1656 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1657 return USB_STOR_TRANSPORT_ERROR;
1660 /* set up the command wrapper */
1661 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1662 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1663 bcb->DataTransferLength = blenByte;
1664 bcb->Flags = US_BULK_FLAG_IN;
1667 bcb->CDB[5] = (unsigned char)(bn);
1668 bcb->CDB[4] = (unsigned char)(bn>>8);
1669 bcb->CDB[3] = (unsigned char)(bn>>16);
1670 bcb->CDB[2] = (unsigned char)(bn>>24);
1672 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1681 buf = kmalloc(blenByte, GFP_KERNEL);
1683 return USB_STOR_TRANSPORT_ERROR;
1685 result = ene_load_bincode(us, MS_RW_PATTERN);
1686 if (result != USB_STOR_XFER_GOOD) {
1687 pr_info("Load MS RW pattern Fail !!\n");
1688 result = USB_STOR_TRANSPORT_ERROR;
1692 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1693 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1696 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1697 len = info->MS_Lib.PagesPerBlock-PageNum;
1701 phyblk = ms_libconv_to_physical(info, logblk);
1702 blkno = phyblk * 0x20 + PageNum;
1704 /* set up the command wrapper */
1705 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1706 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1707 bcb->DataTransferLength = 0x200 * len;
1708 bcb->Flags = US_BULK_FLAG_IN;
1711 bcb->CDB[5] = (unsigned char)(blkno);
1712 bcb->CDB[4] = (unsigned char)(blkno>>8);
1713 bcb->CDB[3] = (unsigned char)(blkno>>16);
1714 bcb->CDB[2] = (unsigned char)(blkno>>24);
1716 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1717 if (result != USB_STOR_XFER_GOOD) {
1718 pr_info("MS_SCSI_Read --- result = %x\n", result);
1719 result = USB_STOR_TRANSPORT_ERROR;
1728 offset += MS_BYTES_PER_PAGE*len;
1730 usb_stor_set_xfer_buf(buf, blenByte, srb);
1737 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1740 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1741 unsigned char *cdb = srb->cmnd;
1742 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1744 u32 bn = ((cdb[2] << 24) & 0xff000000) |
1745 ((cdb[3] << 16) & 0x00ff0000) |
1746 ((cdb[4] << 8) & 0x0000ff00) |
1747 ((cdb[5] << 0) & 0x000000ff);
1748 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1749 u32 blenByte = blen * 0x200;
1751 if (bn > info->bl_num)
1752 return USB_STOR_TRANSPORT_ERROR;
1754 if (info->MS_Status.IsMSPro) {
1755 result = ene_load_bincode(us, MSP_RW_PATTERN);
1756 if (result != USB_STOR_XFER_GOOD) {
1757 pr_info("Load MSP RW pattern Fail !!\n");
1758 return USB_STOR_TRANSPORT_ERROR;
1761 /* set up the command wrapper */
1762 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1763 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1764 bcb->DataTransferLength = blenByte;
1768 bcb->CDB[5] = (unsigned char)(bn);
1769 bcb->CDB[4] = (unsigned char)(bn>>8);
1770 bcb->CDB[3] = (unsigned char)(bn>>16);
1771 bcb->CDB[2] = (unsigned char)(bn>>24);
1773 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1779 u16 len, oldphy, newphy;
1781 buf = kmalloc(blenByte, GFP_KERNEL);
1783 return USB_STOR_TRANSPORT_ERROR;
1784 usb_stor_set_xfer_buf(buf, blenByte, srb);
1786 result = ene_load_bincode(us, MS_RW_PATTERN);
1787 if (result != USB_STOR_XFER_GOOD) {
1788 pr_info("Load MS RW pattern Fail !!\n");
1789 result = USB_STOR_TRANSPORT_ERROR;
1793 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1794 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1797 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1798 len = info->MS_Lib.PagesPerBlock-PageNum;
1802 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1803 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1805 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1807 if (result != USB_STOR_XFER_GOOD) {
1808 pr_info("MS_SCSI_Write --- result = %x\n", result);
1809 result = USB_STOR_TRANSPORT_ERROR;
1813 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1814 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1821 offset += MS_BYTES_PER_PAGE*len;
1833 static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1835 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1838 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1839 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1840 bcb->DataTransferLength = 0x01;
1841 bcb->Flags = US_BULK_FLAG_IN;
1843 bcb->CDB[2] = (unsigned char)(index>>8);
1844 bcb->CDB[3] = (unsigned char)index;
1846 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1850 static int ene_get_card_status(struct us_data *us, u8 *buf)
1854 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1856 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
1857 reg4b = *(u32 *)&buf[0x18];
1858 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1860 tmpreg = (u16) reg4b;
1861 reg4b = *(u32 *)(&buf[0x14]);
1862 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1863 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1865 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1866 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1867 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1868 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1870 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1871 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1872 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1874 info->SD_Block_Mult = 1;
1877 return USB_STOR_TRANSPORT_GOOD;
1880 static int ene_load_bincode(struct us_data *us, unsigned char flag)
1883 char *fw_name = NULL;
1884 unsigned char *buf = NULL;
1885 const struct firmware *sd_fw = NULL;
1886 int result = USB_STOR_TRANSPORT_ERROR;
1887 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1888 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1890 if (info->BIN_FLAG == flag)
1891 return USB_STOR_TRANSPORT_GOOD;
1895 case SD_INIT1_PATTERN:
1896 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1897 fw_name = SD_INIT1_FIRMWARE;
1899 case SD_INIT2_PATTERN:
1900 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1901 fw_name = SD_INIT2_FIRMWARE;
1904 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1905 fw_name = SD_RW_FIRMWARE;
1908 case MS_INIT_PATTERN:
1909 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1910 fw_name = MS_INIT_FIRMWARE;
1912 case MSP_RW_PATTERN:
1913 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1914 fw_name = MSP_RW_FIRMWARE;
1917 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1918 fw_name = MS_RW_FIRMWARE;
1921 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1925 err = reject_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1927 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1930 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1934 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1935 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1936 bcb->DataTransferLength = sd_fw->size;
1940 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1941 if (us->srb != NULL)
1942 scsi_set_resid(us->srb, 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 switch (srb->cmnd[0]) {
2227 case TEST_UNIT_READY:
2228 result = sd_scsi_test_unit_ready(us, srb);
2231 result = do_scsi_request_sense(us, srb);
2234 result = do_scsi_inquiry(us, srb);
2237 result = sd_scsi_mode_sense(us, srb);
2241 result = SD_SCSI_Start_Stop(us, srb);
2245 result = sd_scsi_read_capacity(us, srb);
2248 result = sd_scsi_read(us, srb);
2251 result = sd_scsi_write(us, srb);
2254 info->SrbStatus = SS_ILLEGAL_REQUEST;
2255 result = USB_STOR_TRANSPORT_FAILED;
2258 if (result == USB_STOR_TRANSPORT_GOOD)
2259 info->SrbStatus = SS_SUCCESS;
2266 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2269 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2271 switch (srb->cmnd[0]) {
2272 case TEST_UNIT_READY:
2273 result = ms_scsi_test_unit_ready(us, srb);
2276 result = do_scsi_request_sense(us, srb);
2279 result = do_scsi_inquiry(us, srb);
2282 result = ms_scsi_mode_sense(us, srb);
2285 result = ms_scsi_read_capacity(us, srb);
2288 result = ms_scsi_read(us, srb);
2291 result = ms_scsi_write(us, srb);
2294 info->SrbStatus = SS_ILLEGAL_REQUEST;
2295 result = USB_STOR_TRANSPORT_FAILED;
2298 if (result == USB_STOR_TRANSPORT_GOOD)
2299 info->SrbStatus = SS_SUCCESS;
2303 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2305 int result = USB_STOR_XFER_GOOD;
2306 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2308 /*US_DEBUG(usb_stor_show_command(us, srb)); */
2309 scsi_set_resid(srb, 0);
2310 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready)))
2311 result = ene_init(us);
2312 if (result == USB_STOR_XFER_GOOD) {
2313 result = USB_STOR_TRANSPORT_ERROR;
2314 if (info->SD_Status.Ready)
2315 result = sd_scsi_irp(us, srb);
2317 if (info->MS_Status.Ready)
2318 result = ms_scsi_irp(us, srb);
2323 static struct scsi_host_template ene_ub6250_host_template;
2325 static int ene_ub6250_probe(struct usb_interface *intf,
2326 const struct usb_device_id *id)
2331 struct ene_ub6250_info *info;
2333 result = usb_stor_probe1(&us, intf, id,
2334 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2335 &ene_ub6250_host_template);
2339 /* FIXME: where should the code alloc extra buf ? */
2340 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2343 us->extra_destructor = ene_ub6250_info_destructor;
2345 info = (struct ene_ub6250_info *)(us->extra);
2346 info->bbuf = kmalloc(512, GFP_KERNEL);
2352 us->transport_name = "ene_ub6250";
2353 us->transport = ene_transport;
2356 result = usb_stor_probe2(us);
2360 /* probe card type */
2361 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2362 if (result != USB_STOR_XFER_GOOD) {
2363 usb_stor_disconnect(intf);
2364 return USB_STOR_TRANSPORT_ERROR;
2367 misc_reg03 = info->bbuf[0];
2368 if (!(misc_reg03 & 0x01)) {
2369 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2370 "It does not support SM cards.\n");
2379 static int ene_ub6250_resume(struct usb_interface *iface)
2382 struct us_data *us = usb_get_intfdata(iface);
2383 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2385 mutex_lock(&us->dev_mutex);
2387 if (us->suspend_resume_hook)
2388 (us->suspend_resume_hook)(us, US_RESUME);
2390 mutex_unlock(&us->dev_mutex);
2392 info->Power_IsResum = true;
2393 /*info->SD_Status.Ready = 0; */
2394 info->SD_Status = *(struct SD_STATUS *)&tmp;
2395 info->MS_Status = *(struct MS_STATUS *)&tmp;
2396 info->SM_Status = *(struct SM_STATUS *)&tmp;
2401 static int ene_ub6250_reset_resume(struct usb_interface *iface)
2404 struct us_data *us = usb_get_intfdata(iface);
2405 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2407 /* Report the reset to the SCSI core */
2408 usb_stor_reset_resume(iface);
2411 * FIXME: Notify the subdrivers that they need to reinitialize
2414 info->Power_IsResum = true;
2415 /*info->SD_Status.Ready = 0; */
2416 info->SD_Status = *(struct SD_STATUS *)&tmp;
2417 info->MS_Status = *(struct MS_STATUS *)&tmp;
2418 info->SM_Status = *(struct SM_STATUS *)&tmp;
2425 #define ene_ub6250_resume NULL
2426 #define ene_ub6250_reset_resume NULL
2430 static struct usb_driver ene_ub6250_driver = {
2432 .probe = ene_ub6250_probe,
2433 .disconnect = usb_stor_disconnect,
2434 .suspend = usb_stor_suspend,
2435 .resume = ene_ub6250_resume,
2436 .reset_resume = ene_ub6250_reset_resume,
2437 .pre_reset = usb_stor_pre_reset,
2438 .post_reset = usb_stor_post_reset,
2439 .id_table = ene_ub6250_usb_ids,
2444 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);