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"
32
MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
33
MODULE_LICENSE("GPL");
37
* The table of devices
39
#define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
40
vendorName, productName, useProtocol, useTransport, \
41
initFunction, flags) \
42
{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
43
.driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
45
struct usb_device_id ene_ub6250_usb_ids[] = {
46
# include "unusual_ene_ub6250.h"
47
{ } /* Terminating entry */
49
MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids);
56
#define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \
57
vendor_name, product_name, use_protocol, use_transport, \
58
init_function, Flags) \
60
.vendorName = vendor_name, \
61
.productName = product_name, \
62
.useProtocol = use_protocol, \
63
.useTransport = use_transport, \
64
.initFunction = init_function, \
67
static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
68
# include "unusual_ene_ub6250.h"
69
{ } /* Terminating entry */
76
/* ENE bin code len */
77
#define ENE_BIN_CODE_LEN 0x800
79
#define REG_CARD_STATUS 0xFF83
80
#define REG_HW_TRAP1 0xFF89
83
#define SS_SUCCESS 0x00 /* No Sense */
84
#define SS_NOT_READY 0x02
85
#define SS_MEDIUM_ERR 0x03
86
#define SS_HW_ERR 0x04
87
#define SS_ILLEGAL_REQUEST 0x05
88
#define SS_UNIT_ATTENTION 0x06
90
/* ENE Load FW Pattern */
91
#define SD_INIT1_PATTERN 1
92
#define SD_INIT2_PATTERN 2
93
#define SD_RW_PATTERN 3
94
#define MS_INIT_PATTERN 4
95
#define MSP_RW_PATTERN 5
96
#define MS_RW_PATTERN 6
97
#define SM_INIT_PATTERN 7
98
#define SM_RW_PATTERN 8
105
/* Status Register 1 */
106
#define MS_REG_ST1_MB 0x80 /* media busy */
107
#define MS_REG_ST1_FB1 0x40 /* flush busy 1 */
108
#define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
109
#define MS_REG_ST1_UCDT 0x10 /* unable to correct data */
110
#define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
111
#define MS_REG_ST1_UCEX 0x04 /* unable to correct extra */
112
#define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
113
#define MS_REG_ST1_UCFG 0x01 /* unable to correct overwrite flag */
114
#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)
117
#define MS_REG_OVR_BKST 0x80 /* block status */
118
#define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
119
#define MS_REG_OVR_BKST_NG 0x00 /* NG */
120
#define MS_REG_OVR_PGST0 0x40 /* page status */
121
#define MS_REG_OVR_PGST1 0x20
122
#define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1)
123
#define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */
124
#define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 /* NG */
125
#define MS_REG_OVR_PGST_DATA_ERROR 0x00 /* data error */
126
#define MS_REG_OVR_UDST 0x10 /* update status */
127
#define MS_REG_OVR_UDST_UPDATING 0x00 /* updating */
128
#define MS_REG_OVR_UDST_NO_UPDATE MS_REG_OVR_UDST
129
#define MS_REG_OVR_RESERVED 0x08
130
#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)
132
/* Management Flag */
133
#define MS_REG_MNG_SCMS0 0x20 /* serial copy management system */
134
#define MS_REG_MNG_SCMS1 0x10
135
#define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
136
#define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1)
137
#define MS_REG_MNG_SCMS_ONE_COPY MS_REG_MNG_SCMS1
138
#define MS_REG_MNG_SCMS_NO_COPY 0x00
139
#define MS_REG_MNG_ATFLG 0x08 /* address transfer table flag */
140
#define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG /* other */
141
#define MS_REG_MNG_ATFLG_ATTBL 0x00 /* address transfer table */
142
#define MS_REG_MNG_SYSFLG 0x04 /* system flag */
143
#define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
144
#define MS_REG_MNG_SYSFLG_BOOT 0x00 /* system block */
145
#define MS_REG_MNG_RESERVED 0xc3
146
#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)
149
#define MS_MAX_PAGES_PER_BLOCK 32
150
#define MS_MAX_INITIAL_ERROR_BLOCKS 10
151
#define MS_LIB_BITS_PER_BYTE 8
153
#define MS_SYSINF_FORMAT_FAT 1
154
#define MS_SYSINF_USAGE_GENERAL 0
156
#define MS_SYSINF_MSCLASS_TYPE_1 1
157
#define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */
159
#define MS_SYSINF_CARDTYPE_RDONLY 1
160
#define MS_SYSINF_CARDTYPE_RDWR 2
161
#define MS_SYSINF_CARDTYPE_HYBRID 3
162
#define MS_SYSINF_SECURITY 0x01
163
#define MS_SYSINF_SECURITY_NO_SUPPORT MS_SYSINF_SECURITY
164
#define MS_SYSINF_SECURITY_SUPPORT 0
166
#define MS_SYSINF_RESERVED1 1
167
#define MS_SYSINF_RESERVED2 1
169
#define MS_SYSENT_TYPE_INVALID_BLOCK 0x01
170
#define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */
172
#define SIZE_OF_KIRO 1024
173
#define BYTE_MASK 0xff
176
#define MS_STATUS_WRITE_PROTECT 0x0106
177
#define MS_STATUS_SUCCESS 0x0000
178
#define MS_ERROR_FLASH_READ 0x8003
179
#define MS_ERROR_FLASH_ERASE 0x8005
180
#define MS_LB_ERROR 0xfff0
181
#define MS_LB_BOOT_BLOCK 0xfff1
182
#define MS_LB_INITIAL_ERROR 0xfff2
183
#define MS_STATUS_SUCCESS_WITH_ECC 0xfff3
184
#define MS_LB_ACQUIRED_ERROR 0xfff4
185
#define MS_LB_NOT_USED_ERASED 0xfff5
186
#define MS_NOCARD_ERROR 0xfff8
187
#define MS_NO_MEMORY_ERROR 0xfff9
188
#define MS_STATUS_INT_ERROR 0xfffa
189
#define MS_STATUS_ERROR 0xfffe
190
#define MS_LB_NOT_USED 0xffff
192
#define MS_REG_MNG_SYSFLG 0x04 /* system flag */
193
#define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
195
#define MS_BOOT_BLOCK_ID 0x0001
196
#define MS_BOOT_BLOCK_FORMAT_VERSION 0x0100
197
#define MS_BOOT_BLOCK_DATA_ENTRIES 2
199
#define MS_NUMBER_OF_SYSTEM_ENTRY 4
200
#define MS_NUMBER_OF_BOOT_BLOCK 2
201
#define MS_BYTES_PER_PAGE 512
202
#define MS_LOGICAL_BLOCKS_PER_SEGMENT 496
203
#define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT 494
205
#define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */
206
#define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff
209
#define MS_REG_OVR_BKST 0x80 /* block status */
210
#define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */
211
#define MS_REG_OVR_BKST_NG 0x00 /* NG */
213
/* Status Register 1 */
214
#define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */
215
#define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */
216
#define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */
218
/* MemoryStick Register */
219
/* Status Register 0 */
220
#define MS_REG_ST0_WP 0x01 /* write protected */
221
#define MS_REG_ST0_WP_ON MS_REG_ST0_WP
223
#define MS_LIB_CTRL_RDONLY 0
224
#define MS_LIB_CTRL_WRPROTECT 1
227
#define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock])
228
#define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock])
230
#define ms_lib_ctrl_set(pdx, Flag) ((pdx)->MS_Lib.flags |= (1 << (Flag)))
231
#define ms_lib_ctrl_reset(pdx, Flag) ((pdx)->MS_Lib.flags &= ~(1 << (Flag)))
232
#define ms_lib_ctrl_check(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag)))
234
#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))
235
#define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap))
236
#define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0))
270
struct ms_bootblock_cis {
271
u8 bCistplDEVICE[6]; /* 0 */
272
u8 bCistplDEVICE0C[6]; /* 6 */
273
u8 bCistplJEDECC[4]; /* 12 */
274
u8 bCistplMANFID[6]; /* 16 */
275
u8 bCistplVER1[32]; /* 22 */
276
u8 bCistplFUNCID[4]; /* 54 */
277
u8 bCistplFUNCE0[4]; /* 58 */
278
u8 bCistplFUNCE1[5]; /* 62 */
279
u8 bCistplCONF[7]; /* 67 */
280
u8 bCistplCFTBLENT0[10];/* 74 */
281
u8 bCistplCFTBLENT1[8]; /* 84 */
282
u8 bCistplCFTBLENT2[12];/* 92 */
283
u8 bCistplCFTBLENT3[8]; /* 104 */
284
u8 bCistplCFTBLENT4[17];/* 112 */
285
u8 bCistplCFTBLENT5[8]; /* 129 */
286
u8 bCistplCFTBLENT6[17];/* 137 */
287
u8 bCistplCFTBLENT7[8]; /* 154 */
288
u8 bCistplNOLINK[3]; /* 162 */
291
struct ms_bootblock_idi {
292
#define MS_IDI_GENERAL_CONF 0x848A
293
u16 wIDIgeneralConfiguration; /* 0 */
294
u16 wIDInumberOfCylinder; /* 1 */
295
u16 wIDIreserved0; /* 2 */
296
u16 wIDInumberOfHead; /* 3 */
297
u16 wIDIbytesPerTrack; /* 4 */
298
u16 wIDIbytesPerSector; /* 5 */
299
u16 wIDIsectorsPerTrack; /* 6 */
300
u16 wIDItotalSectors[2]; /* 7-8 high,low */
301
u16 wIDIreserved1[11]; /* 9-19 */
302
u16 wIDIbufferType; /* 20 */
303
u16 wIDIbufferSize; /* 21 */
304
u16 wIDIlongCmdECC; /* 22 */
305
u16 wIDIfirmVersion[4]; /* 23-26 */
306
u16 wIDImodelName[20]; /* 27-46 */
307
u16 wIDIreserved2; /* 47 */
308
u16 wIDIlongWordSupported; /* 48 */
309
u16 wIDIdmaSupported; /* 49 */
310
u16 wIDIreserved3; /* 50 */
311
u16 wIDIpioTiming; /* 51 */
312
u16 wIDIdmaTiming; /* 52 */
313
u16 wIDItransferParameter; /* 53 */
314
u16 wIDIformattedCylinder; /* 54 */
315
u16 wIDIformattedHead; /* 55 */
316
u16 wIDIformattedSectorsPerTrack;/* 56 */
317
u16 wIDIformattedTotalSectors[2];/* 57-58 */
318
u16 wIDImultiSector; /* 59 */
319
u16 wIDIlbaSectors[2]; /* 60-61 */
320
u16 wIDIsingleWordDMA; /* 62 */
321
u16 wIDImultiWordDMA; /* 63 */
322
u16 wIDIreserved4[192]; /* 64-255 */
325
struct ms_bootblock_sysent_rec {
332
struct ms_bootblock_sysent {
333
struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
336
struct ms_bootblock_sysinf {
337
u8 bMsClass; /* must be 1 */
338
u8 bCardType; /* see below */
339
u16 wBlockSize; /* n KB */
340
u16 wBlockNumber; /* number of physical block */
341
u16 wTotalBlockNumber; /* number of logical block */
342
u16 wPageSize; /* must be 0x200 */
343
u8 bExtraSize; /* 0x10 */
347
u8 bAssemblyMakerCode;
348
u8 bAssemblyMachineCode[3];
349
u16 wMemoryMakerCode;
350
u16 wMemoryDeviceCode;
356
u16 wControllerChipNumber;
357
u16 wControllerFunction; /* New MS */
358
u8 bReserved3[9]; /* New MS */
359
u8 bParallelSupport; /* New MS */
360
u16 wFormatValue; /* New MS */
370
struct ms_bootblock_header {
374
u8 bNumberOfDataEntry;
378
struct ms_bootblock_page0 {
379
struct ms_bootblock_header header;
380
struct ms_bootblock_sysent sysent;
381
struct ms_bootblock_sysinf sysinf;
384
struct ms_bootblock_cis_idi {
386
struct ms_bootblock_cis cis;
391
struct ms_bootblock_idi idi;
397
/* ENE MS Lib struct */
398
struct ms_lib_type_extdat {
411
u32 NumberOfCylinder;
412
u32 SectorsPerCylinder;
413
u16 cardType; /* R/W, RO, Hybrid */
416
u16 NumberOfPhyBlock;
417
u16 NumberOfLogBlock;
419
u16 *Phy2LogMap; /* phy2log table */
420
u16 *Log2PhyMap; /* log2phy table */
422
unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE];
423
unsigned char *blkpag;
424
struct ms_lib_type_extdat *blkext;
425
unsigned char copybuf[512];
429
/* SD Block Length */
430
/* 2^9 = 512 Bytes, The HW maximum read/write data length */
431
#define SD_BLOCK_LEN 9
433
struct ene_ub6250_info {
435
struct SD_STATUS SD_Status;
436
struct MS_STATUS MS_Status;
437
struct SM_STATUS SM_Status;
439
/* ----- SD Control Data ---------------- */
440
/*SD_REGISTER SD_Regs; */
446
/* SD/MMC New spec. */
449
u8 SD20_HIGH_CAPACITY;
453
u8 MMC_HIGH_CAPACITY;
455
/*----- MS Control Data ---------------- */
458
struct ms_lib_ctrl MS_Lib;
462
/*----- SM Control Data ---------------- */
466
unsigned char *testbuf;
471
/*------Power Managerment ---------------*/
475
static int ene_sd_init(struct us_data *us);
476
static int ene_ms_init(struct us_data *us);
477
static int ene_load_bincode(struct us_data *us, unsigned char flag);
479
static void ene_ub6250_info_destructor(void *extra)
485
static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg)
487
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
488
struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
491
unsigned int residue;
492
unsigned int cswlen = 0, partial = 0;
493
unsigned int transfer_length = bcb->DataTransferLength;
495
/* US_DEBUGP("transport --- ene_send_scsi_cmd\n"); */
496
/* send cmd to out endpoint */
497
result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
498
bcb, US_BULK_CB_WRAP_LEN, NULL);
499
if (result != USB_STOR_XFER_GOOD) {
500
US_DEBUGP("send cmd to out endpoint fail ---\n");
501
return USB_STOR_TRANSPORT_ERROR;
505
unsigned int pipe = fDir;
507
if (fDir == FDIR_READ)
508
pipe = us->recv_bulk_pipe;
510
pipe = us->send_bulk_pipe;
514
result = usb_stor_bulk_srb(us, pipe, us->srb);
516
result = usb_stor_bulk_transfer_sg(us, pipe, buf,
517
transfer_length, 0, &partial);
519
if (result != USB_STOR_XFER_GOOD) {
520
US_DEBUGP("data transfer fail ---\n");
521
return USB_STOR_TRANSPORT_ERROR;
525
/* Get CSW for device status */
526
result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
527
US_BULK_CS_WRAP_LEN, &cswlen);
529
if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
530
US_DEBUGP("Received 0-length CSW; retrying...\n");
531
result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
532
bcs, US_BULK_CS_WRAP_LEN, &cswlen);
535
if (result == USB_STOR_XFER_STALLED) {
536
/* get the status again */
537
US_DEBUGP("Attempting to get CSW (2nd try)...\n");
538
result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
539
bcs, US_BULK_CS_WRAP_LEN, NULL);
542
if (result != USB_STOR_XFER_GOOD)
543
return USB_STOR_TRANSPORT_ERROR;
545
/* check bulk status */
546
residue = le32_to_cpu(bcs->Residue);
548
/* try to compute the actual residue, based on how much data
549
* was really transferred and what the device tells us */
550
if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
551
residue = min(residue, transfer_length);
553
scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
557
if (bcs->Status != US_BULK_STAT_OK)
558
return USB_STOR_TRANSPORT_ERROR;
560
return USB_STOR_TRANSPORT_GOOD;
563
static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
565
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
567
if (info->SD_Status.Insert && info->SD_Status.Ready)
568
return USB_STOR_TRANSPORT_GOOD;
571
return USB_STOR_TRANSPORT_GOOD;
574
return USB_STOR_TRANSPORT_GOOD;
577
static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
579
unsigned char data_ptr[36] = {
580
0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
581
0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
582
0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
583
0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 };
585
usb_stor_set_xfer_buf(data_ptr, 36, srb);
586
return USB_STOR_TRANSPORT_GOOD;
589
static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
591
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
592
unsigned char mediaNoWP[12] = {
593
0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
594
0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
595
unsigned char mediaWP[12] = {
596
0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
597
0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
599
if (info->SD_Status.WtP)
600
usb_stor_set_xfer_buf(mediaWP, 12, srb);
602
usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
605
return USB_STOR_TRANSPORT_GOOD;
608
static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
612
unsigned int offset = 0;
613
unsigned char buf[8];
614
struct scatterlist *sg = NULL;
615
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
617
US_DEBUGP("sd_scsi_read_capacity\n");
618
if (info->SD_Status.HiCapacity) {
620
if (info->SD_Status.IsMMC)
621
bl_num = info->HC_C_SIZE-1;
623
bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
625
bl_len = 1<<(info->SD_READ_BL_LEN);
626
bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1)
627
* (1 << (info->SD_C_SIZE_MULT + 2)) - 1;
629
info->bl_num = bl_num;
630
US_DEBUGP("bl_len = %x\n", bl_len);
631
US_DEBUGP("bl_num = %x\n", bl_num);
633
/*srb->request_bufflen = 8; */
634
buf[0] = (bl_num >> 24) & 0xff;
635
buf[1] = (bl_num >> 16) & 0xff;
636
buf[2] = (bl_num >> 8) & 0xff;
637
buf[3] = (bl_num >> 0) & 0xff;
638
buf[4] = (bl_len >> 24) & 0xff;
639
buf[5] = (bl_len >> 16) & 0xff;
640
buf[6] = (bl_len >> 8) & 0xff;
641
buf[7] = (bl_len >> 0) & 0xff;
643
usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
645
return USB_STOR_TRANSPORT_GOOD;
648
static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
651
unsigned char *cdb = srb->cmnd;
652
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
653
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
655
u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
656
((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
657
u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
658
u32 bnByte = bn * 0x200;
659
u32 blenByte = blen * 0x200;
661
if (bn > info->bl_num)
662
return USB_STOR_TRANSPORT_ERROR;
664
result = ene_load_bincode(us, SD_RW_PATTERN);
665
if (result != USB_STOR_XFER_GOOD) {
666
US_DEBUGP("Load SD RW pattern Fail !!\n");
667
return USB_STOR_TRANSPORT_ERROR;
670
if (info->SD_Status.HiCapacity)
673
/* set up the command wrapper */
674
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
675
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
676
bcb->DataTransferLength = blenByte;
679
bcb->CDB[5] = (unsigned char)(bnByte);
680
bcb->CDB[4] = (unsigned char)(bnByte>>8);
681
bcb->CDB[3] = (unsigned char)(bnByte>>16);
682
bcb->CDB[2] = (unsigned char)(bnByte>>24);
684
result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
688
static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
691
unsigned char *cdb = srb->cmnd;
692
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
693
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
695
u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
696
((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
697
u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
698
u32 bnByte = bn * 0x200;
699
u32 blenByte = blen * 0x200;
701
if (bn > info->bl_num)
702
return USB_STOR_TRANSPORT_ERROR;
704
result = ene_load_bincode(us, SD_RW_PATTERN);
705
if (result != USB_STOR_XFER_GOOD) {
706
US_DEBUGP("Load SD RW pattern Fail !!\n");
707
return USB_STOR_TRANSPORT_ERROR;
710
if (info->SD_Status.HiCapacity)
713
/* set up the command wrapper */
714
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
715
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
716
bcb->DataTransferLength = blenByte;
719
bcb->CDB[5] = (unsigned char)(bnByte);
720
bcb->CDB[4] = (unsigned char)(bnByte>>8);
721
bcb->CDB[3] = (unsigned char)(bnByte>>16);
722
bcb->CDB[2] = (unsigned char)(bnByte>>24);
724
result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
732
static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
734
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
736
if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
739
info->MS_Lib.Phy2LogMap[phyblk] = logblk;
740
info->MS_Lib.Log2PhyMap[logblk] = phyblk;
745
static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
747
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
749
if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
752
info->MS_Lib.Phy2LogMap[phyblk] = mark;
757
static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
759
return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
762
static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
764
return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
767
static int ms_lib_free_logicalmap(struct us_data *us)
769
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
771
kfree(info->MS_Lib.Phy2LogMap);
772
info->MS_Lib.Phy2LogMap = NULL;
774
kfree(info->MS_Lib.Log2PhyMap);
775
info->MS_Lib.Log2PhyMap = NULL;
780
int ms_lib_alloc_logicalmap(struct us_data *us)
783
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
785
info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL);
786
info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL);
788
if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
789
ms_lib_free_logicalmap(us);
793
for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
794
info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
796
for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
797
info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
802
static void ms_lib_clear_writebuf(struct us_data *us)
805
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
807
info->MS_Lib.wrtblk = (u16)-1;
808
ms_lib_clear_pagemap(info);
810
if (info->MS_Lib.blkpag)
811
memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
813
if (info->MS_Lib.blkext) {
814
for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) {
815
info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT;
816
info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT;
817
info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT;
818
info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED;
823
static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
826
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
828
Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
829
for (Count = 0; PhyBlock < Ende; PhyBlock++) {
830
switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
832
case MS_LB_NOT_USED_ERASED:
842
static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
843
u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
845
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
848
u32 bn = PhyBlockAddr * 0x20 + PageNum;
850
/* printk(KERN_INFO "MS --- MS_ReaderReadPage,
851
PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
853
result = ene_load_bincode(us, MS_RW_PATTERN);
854
if (result != USB_STOR_XFER_GOOD)
855
return USB_STOR_TRANSPORT_ERROR;
858
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
859
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
860
bcb->DataTransferLength = 0x200;
864
bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
866
bcb->CDB[5] = (unsigned char)(bn);
867
bcb->CDB[4] = (unsigned char)(bn>>8);
868
bcb->CDB[3] = (unsigned char)(bn>>16);
869
bcb->CDB[2] = (unsigned char)(bn>>24);
871
result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
872
if (result != USB_STOR_XFER_GOOD)
873
return USB_STOR_TRANSPORT_ERROR;
876
/* Read Extra Data */
877
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
878
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
879
bcb->DataTransferLength = 0x4;
884
bcb->CDB[5] = (unsigned char)(PageNum);
885
bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
886
bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
887
bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
890
result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
891
if (result != USB_STOR_XFER_GOOD)
892
return USB_STOR_TRANSPORT_ERROR;
894
ExtraDat->reserved = 0;
895
ExtraDat->intr = 0x80; /* Not yet,fireware support */
896
ExtraDat->status0 = 0x10; /* Not yet,fireware support */
898
ExtraDat->status1 = 0x00; /* Not yet,fireware support */
899
ExtraDat->ovrflg = ExtBuf[0];
900
ExtraDat->mngflg = ExtBuf[1];
901
ExtraDat->logadr = memstick_logaddr(ExtBuf[2], ExtBuf[3]);
903
return USB_STOR_TRANSPORT_GOOD;
906
static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
908
struct ms_bootblock_sysent *SysEntry;
909
struct ms_bootblock_sysinf *SysInfo;
913
struct ms_lib_type_extdat ExtraData;
914
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
916
PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
917
if (PageBuffer == NULL)
922
SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
924
if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
925
(be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
926
((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
927
(SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
928
(SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
929
(SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
930
(SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
933
switch (info->MS_Lib.cardType = SysInfo->bCardType) {
934
case MS_SYSINF_CARDTYPE_RDONLY:
935
ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
937
case MS_SYSINF_CARDTYPE_RDWR:
938
ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
940
case MS_SYSINF_CARDTYPE_HYBRID:
945
info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
946
info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
947
info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
948
info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
949
info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
950
info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
952
/*Allocate to all number of logicalblock and physicalblock */
953
if (ms_lib_alloc_logicalmap(us))
956
/* Mark the book block */
957
ms_lib_set_bootblockmark(us, PhyBlock);
959
SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
961
for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
962
u32 EntryOffset, EntrySize;
964
EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
966
if (EntryOffset == 0xffffff)
968
EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
973
if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
977
u8 PrevPageNumber = 0;
980
if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
983
while (EntrySize > 0) {
985
PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
986
if (PageNumber != PrevPageNumber) {
987
switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
988
case MS_STATUS_SUCCESS:
990
case MS_STATUS_WRITE_PROTECT:
991
case MS_ERROR_FLASH_READ:
992
case MS_STATUS_ERROR:
997
PrevPageNumber = PageNumber;
1000
phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1001
if (phyblk < 0x0fff)
1002
ms_lib_set_initialerrorblock(us, phyblk);
1007
} else if (i == 1) { /* CIS/IDI */
1008
struct ms_bootblock_idi *idi;
1010
if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1013
switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1014
case MS_STATUS_SUCCESS:
1016
case MS_STATUS_WRITE_PROTECT:
1017
case MS_ERROR_FLASH_READ:
1018
case MS_STATUS_ERROR:
1023
idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1024
if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1027
info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1028
if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1037
ms_lib_free_logicalmap(us);
1045
static void ms_lib_free_writebuf(struct us_data *us)
1047
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1048
info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1050
/* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1052
ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1054
if (info->MS_Lib.blkpag) {
1055
kfree((u8 *)(info->MS_Lib.blkpag)); /* Arnold test ... */
1056
info->MS_Lib.blkpag = NULL;
1059
if (info->MS_Lib.blkext) {
1060
kfree((u8 *)(info->MS_Lib.blkext)); /* Arnold test ... */
1061
info->MS_Lib.blkext = NULL;
1066
static void ms_lib_free_allocatedarea(struct us_data *us)
1068
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1070
ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1071
ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1073
/* set struct us point flag to 0 */
1074
info->MS_Lib.flags = 0;
1075
info->MS_Lib.BytesPerSector = 0;
1076
info->MS_Lib.SectorsPerCylinder = 0;
1078
info->MS_Lib.cardType = 0;
1079
info->MS_Lib.blockSize = 0;
1080
info->MS_Lib.PagesPerBlock = 0;
1082
info->MS_Lib.NumberOfPhyBlock = 0;
1083
info->MS_Lib.NumberOfLogBlock = 0;
1087
static int ms_lib_alloc_writebuf(struct us_data *us)
1089
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1091
info->MS_Lib.wrtblk = (u16)-1;
1093
info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL);
1094
info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL);
1096
if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1097
ms_lib_free_writebuf(us);
1101
ms_lib_clear_writebuf(us);
1106
static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1108
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1110
if (logblk == MS_LB_NOT_USED)
1113
if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1114
(phyblk >= info->MS_Lib.NumberOfPhyBlock))
1117
info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1118
info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1123
static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1124
u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1126
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1129
/* printk(KERN_INFO "MS_ReaderCopyBlock --- PhyBlockAddr = %x,
1130
PageNum = %x\n", PhyBlockAddr, PageNum); */
1131
result = ene_load_bincode(us, MS_RW_PATTERN);
1132
if (result != USB_STOR_XFER_GOOD)
1133
return USB_STOR_TRANSPORT_ERROR;
1135
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1136
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1137
bcb->DataTransferLength = 0x200*len;
1141
bcb->CDB[4] = (unsigned char)(oldphy);
1142
bcb->CDB[3] = (unsigned char)(oldphy>>8);
1143
bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */
1144
bcb->CDB[7] = (unsigned char)(newphy);
1145
bcb->CDB[6] = (unsigned char)(newphy>>8);
1146
bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */
1147
bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1148
bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1149
bcb->CDB[10] = PageNum;
1151
result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1152
if (result != USB_STOR_XFER_GOOD)
1153
return USB_STOR_TRANSPORT_ERROR;
1155
return USB_STOR_TRANSPORT_GOOD;
1158
static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1160
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1162
u32 bn = PhyBlockAddr;
1164
/* printk(KERN_INFO "MS --- ms_read_eraseblock,
1165
PhyBlockAddr = %x\n", PhyBlockAddr); */
1166
result = ene_load_bincode(us, MS_RW_PATTERN);
1167
if (result != USB_STOR_XFER_GOOD)
1168
return USB_STOR_TRANSPORT_ERROR;
1170
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1171
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1172
bcb->DataTransferLength = 0x200;
1176
bcb->CDB[4] = (unsigned char)(bn);
1177
bcb->CDB[3] = (unsigned char)(bn>>8);
1178
bcb->CDB[2] = (unsigned char)(bn>>16);
1180
result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1181
if (result != USB_STOR_XFER_GOOD)
1182
return USB_STOR_TRANSPORT_ERROR;
1184
return USB_STOR_TRANSPORT_GOOD;
1187
static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1189
unsigned char *PageBuf = NULL;
1190
u16 result = MS_STATUS_SUCCESS;
1192
struct ms_lib_type_extdat extdat;
1193
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1195
PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1196
if (PageBuf == NULL) {
1197
result = MS_NO_MEMORY_ERROR;
1201
ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1203
blk = be16_to_cpu(PageBuf[index]);
1204
if (blk == MS_LB_NOT_USED)
1206
if (blk == info->MS_Lib.Log2PhyMap[0]) {
1207
result = MS_ERROR_FLASH_READ;
1218
static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1221
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1223
if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1226
log = info->MS_Lib.Phy2LogMap[phyblk];
1228
if (log < info->MS_Lib.NumberOfLogBlock)
1229
info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1231
if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1232
info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1237
static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1238
u8 PageNum, u8 OverwriteFlag)
1240
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1243
/* printk("MS --- MS_LibOverwriteExtra,
1244
PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
1245
result = ene_load_bincode(us, MS_RW_PATTERN);
1246
if (result != USB_STOR_XFER_GOOD)
1247
return USB_STOR_TRANSPORT_ERROR;
1249
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1250
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1251
bcb->DataTransferLength = 0x4;
1255
bcb->CDB[5] = (unsigned char)(PageNum);
1256
bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1257
bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1258
bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1259
bcb->CDB[6] = OverwriteFlag;
1264
result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1265
if (result != USB_STOR_XFER_GOOD)
1266
return USB_STOR_TRANSPORT_ERROR;
1268
return USB_STOR_TRANSPORT_GOOD;
1271
static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1273
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1275
if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1276
return MS_STATUS_ERROR;
1278
ms_lib_setacquired_errorblock(us, phyblk);
1280
if (ms_lib_iswritable(info))
1281
return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1283
return MS_STATUS_SUCCESS;
1286
static int ms_lib_erase_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
log = info->MS_Lib.Phy2LogMap[phyblk];
1296
if (log < info->MS_Lib.NumberOfLogBlock)
1297
info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1299
info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1301
if (ms_lib_iswritable(info)) {
1302
switch (ms_read_eraseblock(us, phyblk)) {
1303
case MS_STATUS_SUCCESS:
1304
info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1305
return MS_STATUS_SUCCESS;
1306
case MS_ERROR_FLASH_ERASE:
1307
case MS_STATUS_INT_ERROR:
1308
ms_lib_error_phyblock(us, phyblk);
1309
return MS_ERROR_FLASH_ERASE;
1310
case MS_STATUS_ERROR:
1312
ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/
1313
ms_lib_setacquired_errorblock(us, phyblk);
1314
return MS_STATUS_ERROR;
1318
ms_lib_setacquired_errorblock(us, phyblk);
1320
return MS_STATUS_SUCCESS;
1323
static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1324
u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1326
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1330
/* printk("MS_LibReadExtra --- PhyBlock = %x, PageNum = %x\n", PhyBlock, PageNum); */
1331
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1332
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1333
bcb->DataTransferLength = 0x4;
1337
bcb->CDB[5] = (unsigned char)(PageNum);
1338
bcb->CDB[4] = (unsigned char)(PhyBlock);
1339
bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1340
bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1343
result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
1344
if (result != USB_STOR_XFER_GOOD)
1345
return USB_STOR_TRANSPORT_ERROR;
1347
ExtraDat->reserved = 0;
1348
ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */
1349
ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */
1350
ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */
1351
ExtraDat->ovrflg = ExtBuf[0];
1352
ExtraDat->mngflg = ExtBuf[1];
1353
ExtraDat->logadr = memstick_logaddr(ExtBuf[2], ExtBuf[3]);
1355
return USB_STOR_TRANSPORT_GOOD;
1358
static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1362
struct ms_lib_type_extdat extdat; /* need check */
1363
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1366
if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1369
for (blk = phyblk + 1; blk != phyblk; blk++) {
1370
if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1371
blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1373
Newblk = info->MS_Lib.Phy2LogMap[blk];
1374
if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1376
} else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1377
switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1378
case MS_STATUS_SUCCESS:
1379
case MS_STATUS_SUCCESS_WITH_ECC:
1381
case MS_NOCARD_ERROR:
1382
return MS_NOCARD_ERROR;
1383
case MS_STATUS_INT_ERROR:
1385
case MS_ERROR_FLASH_READ:
1387
ms_lib_setacquired_errorblock(us, blk);
1391
if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1392
ms_lib_setacquired_errorblock(us, blk);
1396
switch (ms_lib_erase_phyblock(us, blk)) {
1397
case MS_STATUS_SUCCESS:
1399
case MS_STATUS_ERROR:
1401
case MS_ERROR_FLASH_ERASE:
1403
ms_lib_error_phyblock(us, blk);
1411
static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1414
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1416
phyblk = ms_libconv_to_physical(info, logblk);
1417
if (phyblk >= MS_LB_ERROR) {
1418
if (logblk >= info->MS_Lib.NumberOfLogBlock)
1421
phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1422
phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1423
phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1426
return ms_libsearch_block_from_physical(us, phyblk);
1429
static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1431
struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1433
/* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
1434
if (info->MS_Status.Insert && info->MS_Status.Ready) {
1435
return USB_STOR_TRANSPORT_GOOD;
1438
return USB_STOR_TRANSPORT_GOOD;
1441
return USB_STOR_TRANSPORT_GOOD;
1444
static int ms_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
1446
/* pr_info("MS_SCSI_Inquiry\n"); */
1447
unsigned char data_ptr[36] = {
1448
0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
1449
0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
1450
0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20,
1451
0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
1453
usb_stor_set_xfer_buf(data_ptr, 36, srb);
1454
return USB_STOR_TRANSPORT_GOOD;
1457
static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1459
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1460
unsigned char mediaNoWP[12] = {
1461
0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1462
0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1463
unsigned char mediaWP[12] = {
1464
0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1465
0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1467
if (info->MS_Status.WtP)
1468
usb_stor_set_xfer_buf(mediaWP, 12, srb);
1470
usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1472
return USB_STOR_TRANSPORT_GOOD;
1475
static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1479
unsigned int offset = 0;
1480
unsigned char buf[8];
1481
struct scatterlist *sg = NULL;
1482
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1484
US_DEBUGP("ms_scsi_read_capacity\n");
1486
if (info->MS_Status.IsMSPro)
1487
bl_num = info->MSP_TotalBlock - 1;
1489
bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1491
info->bl_num = bl_num;
1492
US_DEBUGP("bl_len = %x\n", bl_len);
1493
US_DEBUGP("bl_num = %x\n", bl_num);
1495
/*srb->request_bufflen = 8; */
1496
buf[0] = (bl_num >> 24) & 0xff;
1497
buf[1] = (bl_num >> 16) & 0xff;
1498
buf[2] = (bl_num >> 8) & 0xff;
1499
buf[3] = (bl_num >> 0) & 0xff;
1500
buf[4] = (bl_len >> 24) & 0xff;
1501
buf[5] = (bl_len >> 16) & 0xff;
1502
buf[6] = (bl_len >> 8) & 0xff;
1503
buf[7] = (bl_len >> 0) & 0xff;
1505
usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1507
return USB_STOR_TRANSPORT_GOOD;
1510
static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1512
PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1515
*LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1516
*LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/
1519
*LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1523
static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1524
u8 PageNum, u8 blen, void *buf)
1526
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1529
/* printk("MS_LibReadExtraBlock --- PhyBlock = %x,
1530
PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen); */
1532
/* Read Extra Data */
1533
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1534
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1535
bcb->DataTransferLength = 0x4 * blen;
1539
bcb->CDB[5] = (unsigned char)(PageNum);
1540
bcb->CDB[4] = (unsigned char)(PhyBlock);
1541
bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1542
bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1545
result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1546
if (result != USB_STOR_XFER_GOOD)
1547
return USB_STOR_TRANSPORT_ERROR;
1549
return USB_STOR_TRANSPORT_GOOD;
1552
static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1554
u16 PhyBlock, newblk, i;
1555
u16 LogStart, LogEnde;
1556
struct ms_lib_type_extdat extdat;
1558
u32 count = 0, index = 0;
1559
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1561
for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1562
ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1564
for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1565
switch (ms_libconv_to_logical(info, PhyBlock)) {
1566
case MS_STATUS_ERROR:
1572
if (count == PhyBlock) {
1573
ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, &buf);
1576
index = (PhyBlock % 0x80) * 4;
1578
extdat.ovrflg = buf[index];
1579
extdat.mngflg = buf[index+1];
1580
extdat.logadr = memstick_logaddr(buf[index+2], buf[index+3]);
1582
if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1583
ms_lib_setacquired_errorblock(us, PhyBlock);
1587
if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1588
ms_lib_erase_phyblock(us, PhyBlock);
1592
if (extdat.logadr != MS_LB_NOT_USED) {
1593
if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1594
ms_lib_erase_phyblock(us, PhyBlock);
1598
newblk = ms_libconv_to_physical(info, extdat.logadr);
1600
if (newblk != MS_LB_NOT_USED) {
1601
if (extdat.logadr == 0) {
1602
ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1603
if (ms_lib_check_disableblock(us, btBlk1st)) {
1604
ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1609
ms_lib_read_extra(us, newblk, 0, &extdat);
1610
if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1611
ms_lib_erase_phyblock(us, PhyBlock);
1614
ms_lib_erase_phyblock(us, newblk);
1618
ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1623
return MS_STATUS_SUCCESS;
1627
static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1630
unsigned char *cdb = srb->cmnd;
1631
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1632
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1634
u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1635
((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1636
u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1637
u32 blenByte = blen * 0x200;
1639
if (bn > info->bl_num)
1640
return USB_STOR_TRANSPORT_ERROR;
1642
if (info->MS_Status.IsMSPro) {
1643
result = ene_load_bincode(us, MSP_RW_PATTERN);
1644
if (result != USB_STOR_XFER_GOOD) {
1645
US_DEBUGP("Load MPS RW pattern Fail !!\n");
1646
return USB_STOR_TRANSPORT_ERROR;
1649
/* set up the command wrapper */
1650
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1651
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1652
bcb->DataTransferLength = blenByte;
1656
bcb->CDB[5] = (unsigned char)(bn);
1657
bcb->CDB[4] = (unsigned char)(bn>>8);
1658
bcb->CDB[3] = (unsigned char)(bn>>16);
1659
bcb->CDB[2] = (unsigned char)(bn>>24);
1661
result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1670
buf = kmalloc(blenByte, GFP_KERNEL);
1672
return USB_STOR_TRANSPORT_ERROR;
1674
result = ene_load_bincode(us, MS_RW_PATTERN);
1675
if (result != USB_STOR_XFER_GOOD) {
1676
pr_info("Load MS RW pattern Fail !!\n");
1677
result = USB_STOR_TRANSPORT_ERROR;
1681
logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1682
PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1685
if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1686
len = info->MS_Lib.PagesPerBlock-PageNum;
1690
phyblk = ms_libconv_to_physical(info, logblk);
1691
blkno = phyblk * 0x20 + PageNum;
1693
/* set up the command wrapper */
1694
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1695
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1696
bcb->DataTransferLength = 0x200 * len;
1700
bcb->CDB[5] = (unsigned char)(blkno);
1701
bcb->CDB[4] = (unsigned char)(blkno>>8);
1702
bcb->CDB[3] = (unsigned char)(blkno>>16);
1703
bcb->CDB[2] = (unsigned char)(blkno>>24);
1705
result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1706
if (result != USB_STOR_XFER_GOOD) {
1707
pr_info("MS_SCSI_Read --- result = %x\n", result);
1708
result = USB_STOR_TRANSPORT_ERROR;
1717
offset += MS_BYTES_PER_PAGE*len;
1719
usb_stor_set_xfer_buf(buf, blenByte, srb);
1726
static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1729
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1730
unsigned char *cdb = srb->cmnd;
1731
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1733
u32 bn = ((cdb[2] << 24) & 0xff000000) |
1734
((cdb[3] << 16) & 0x00ff0000) |
1735
((cdb[4] << 8) & 0x0000ff00) |
1736
((cdb[5] << 0) & 0x000000ff);
1737
u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1738
u32 blenByte = blen * 0x200;
1740
if (bn > info->bl_num)
1741
return USB_STOR_TRANSPORT_ERROR;
1743
if (info->MS_Status.IsMSPro) {
1744
result = ene_load_bincode(us, MSP_RW_PATTERN);
1745
if (result != USB_STOR_XFER_GOOD) {
1746
pr_info("Load MSP RW pattern Fail !!\n");
1747
return USB_STOR_TRANSPORT_ERROR;
1750
/* set up the command wrapper */
1751
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1752
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1753
bcb->DataTransferLength = blenByte;
1757
bcb->CDB[5] = (unsigned char)(bn);
1758
bcb->CDB[4] = (unsigned char)(bn>>8);
1759
bcb->CDB[3] = (unsigned char)(bn>>16);
1760
bcb->CDB[2] = (unsigned char)(bn>>24);
1762
result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1768
u16 len, oldphy, newphy;
1770
buf = kmalloc(blenByte, GFP_KERNEL);
1772
return USB_STOR_TRANSPORT_ERROR;
1773
usb_stor_set_xfer_buf(buf, blenByte, srb);
1775
result = ene_load_bincode(us, MS_RW_PATTERN);
1776
if (result != USB_STOR_XFER_GOOD) {
1777
pr_info("Load MS RW pattern Fail !!\n");
1778
result = USB_STOR_TRANSPORT_ERROR;
1782
PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1783
PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1786
if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1787
len = info->MS_Lib.PagesPerBlock-PageNum;
1791
oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1792
newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1794
result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1796
if (result != USB_STOR_XFER_GOOD) {
1797
pr_info("MS_SCSI_Write --- result = %x\n", result);
1798
result = USB_STOR_TRANSPORT_ERROR;
1802
info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1803
ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1810
offset += MS_BYTES_PER_PAGE*len;
1822
static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1824
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1827
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1828
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1829
bcb->DataTransferLength = 0x01;
1832
bcb->CDB[2] = (unsigned char)(index>>8);
1833
bcb->CDB[3] = (unsigned char)index;
1835
result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1839
static int ene_get_card_status(struct us_data *us, u8 *buf)
1843
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1845
/*US_DEBUGP("transport --- ENE_ReadSDReg\n");*/
1846
reg4b = *(u32 *)&buf[0x18];
1847
info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1849
tmpreg = (u16) reg4b;
1850
reg4b = *(u32 *)(&buf[0x14]);
1851
if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1852
info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1854
info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1855
info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1856
if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1857
info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1859
if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1860
info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1861
info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1863
info->SD_Block_Mult = 1;
1866
return USB_STOR_TRANSPORT_GOOD;
1869
static int ene_load_bincode(struct us_data *us, unsigned char flag)
1872
char *fw_name = NULL;
1873
unsigned char *buf = NULL;
1874
const struct firmware *sd_fw = NULL;
1875
int result = USB_STOR_TRANSPORT_ERROR;
1876
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1877
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1879
if (info->BIN_FLAG == flag)
1880
return USB_STOR_TRANSPORT_GOOD;
1884
case SD_INIT1_PATTERN:
1885
US_DEBUGP("SD_INIT1_PATTERN\n");
1886
fw_name = "ene-ub6250/sd_init1.bin";
1888
case SD_INIT2_PATTERN:
1889
US_DEBUGP("SD_INIT2_PATTERN\n");
1890
fw_name = "ene-ub6250/sd_init2.bin";
1893
US_DEBUGP("SD_RDWR_PATTERN\n");
1894
fw_name = "ene-ub6250/sd_rdwr.bin";
1897
case MS_INIT_PATTERN:
1898
US_DEBUGP("MS_INIT_PATTERN\n");
1899
fw_name = "ene-ub6250/ms_init.bin";
1901
case MSP_RW_PATTERN:
1902
US_DEBUGP("MSP_RW_PATTERN\n");
1903
fw_name = "ene-ub6250/msp_rdwr.bin";
1906
US_DEBUGP("MS_RW_PATTERN\n");
1907
fw_name = "ene-ub6250/ms_rdwr.bin";
1910
US_DEBUGP("----------- Unknown PATTERN ----------\n");
1914
err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1916
US_DEBUGP("load firmware %s failed\n", fw_name);
1919
buf = kmalloc(sd_fw->size, GFP_KERNEL);
1921
US_DEBUGP("Malloc memory for fireware failed!\n");
1924
memcpy(buf, sd_fw->data, sd_fw->size);
1925
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1926
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1927
bcb->DataTransferLength = sd_fw->size;
1931
result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1932
info->BIN_FLAG = flag;
1936
if (sd_fw != NULL) {
1937
release_firmware(sd_fw);
1944
static int ms_card_init(struct us_data *us)
1948
unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1949
struct ms_lib_type_extdat extdat;
1950
u16 btBlk1st, btBlk2nd;
1952
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1954
printk(KERN_INFO "MS_CardInit start\n");
1956
ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1958
/* get two PageBuffer */
1959
PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1960
PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1961
if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1962
result = MS_NO_MEMORY_ERROR;
1966
btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1969
for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1971
switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1972
case MS_STATUS_SUCCESS:
1974
case MS_STATUS_INT_ERROR:
1976
case MS_STATUS_ERROR:
1981
if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1984
if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1985
(be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1986
(be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1987
(((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1990
if (btBlk1st != MS_LB_NOT_USED) {
1991
btBlk2nd = TmpBlock;
1995
btBlk1st = TmpBlock;
1996
memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
1997
if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2001
if (btBlk1st == MS_LB_NOT_USED) {
2002
result = MS_STATUS_ERROR;
2007
if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2008
ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2010
result = MS_STATUS_ERROR;
2011
/* 1st Boot Block */
2012
if (btBlk1stErred == 0)
2013
result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2015
/* 2nd Boot Block */
2016
if (result && (btBlk2nd != MS_LB_NOT_USED))
2017
result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2020
result = MS_STATUS_ERROR;
2024
for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2025
info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2027
info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2029
if (btBlk2nd != MS_LB_NOT_USED) {
2030
for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2031
info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2033
info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2036
result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2040
for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2041
TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2042
TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2043
if (ms_count_freeblock(us, TmpBlock) == 0) {
2044
ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2050
if (ms_lib_alloc_writebuf(us)) {
2051
result = MS_NO_MEMORY_ERROR;
2055
result = MS_STATUS_SUCCESS;
2061
printk(KERN_INFO "MS_CardInit end\n");
2065
static int ene_ms_init(struct us_data *us)
2067
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2070
u16 MSP_BlockSize, MSP_UserAreaBlocks;
2071
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2073
printk(KERN_INFO "transport --- ENE_MSInit\n");
2075
/* the same part to test ENE */
2077
result = ene_load_bincode(us, MS_INIT_PATTERN);
2078
if (result != USB_STOR_XFER_GOOD) {
2079
printk(KERN_ERR "Load MS Init Code Fail !!\n");
2080
return USB_STOR_TRANSPORT_ERROR;
2083
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2084
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2085
bcb->DataTransferLength = 0x200;
2090
result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2091
if (result != USB_STOR_XFER_GOOD) {
2092
printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2093
return USB_STOR_TRANSPORT_ERROR;
2095
/* the same part to test ENE */
2096
info->MS_Status = *(struct MS_STATUS *)&buf[0];
2098
if (info->MS_Status.Insert && info->MS_Status.Ready) {
2099
printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert);
2100
printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready);
2101
printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro);
2102
printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG);
2103
printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2104
if (info->MS_Status.IsMSPro) {
2105
MSP_BlockSize = (buf[6] << 8) | buf[7];
2106
MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
2107
info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2109
ms_card_init(us); /* Card is MS (to ms.c)*/
2111
US_DEBUGP("MS Init Code OK !!\n");
2113
US_DEBUGP("MS Card Not Ready --- %x\n", buf[0]);
2114
return USB_STOR_TRANSPORT_ERROR;
2117
return USB_STOR_TRANSPORT_GOOD;
2120
static int ene_sd_init(struct us_data *us)
2124
struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2125
struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2127
US_DEBUGP("transport --- ENE_SDInit\n");
2128
/* SD Init Part-1 */
2129
result = ene_load_bincode(us, SD_INIT1_PATTERN);
2130
if (result != USB_STOR_XFER_GOOD) {
2131
US_DEBUGP("Load SD Init Code Part-1 Fail !!\n");
2132
return USB_STOR_TRANSPORT_ERROR;
2135
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2136
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2140
result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2141
if (result != USB_STOR_XFER_GOOD) {
2142
US_DEBUGP("Execution SD Init Code Fail !!\n");
2143
return USB_STOR_TRANSPORT_ERROR;
2146
/* SD Init Part-2 */
2147
result = ene_load_bincode(us, SD_INIT2_PATTERN);
2148
if (result != USB_STOR_XFER_GOOD) {
2149
US_DEBUGP("Load SD Init Code Part-2 Fail !!\n");
2150
return USB_STOR_TRANSPORT_ERROR;
2153
memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2154
bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2155
bcb->DataTransferLength = 0x200;
2159
result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2160
if (result != USB_STOR_XFER_GOOD) {
2161
US_DEBUGP("Execution SD Init Code Fail !!\n");
2162
return USB_STOR_TRANSPORT_ERROR;
2165
info->SD_Status = *(struct SD_STATUS *)&buf[0];
2166
if (info->SD_Status.Insert && info->SD_Status.Ready) {
2167
ene_get_card_status(us, (unsigned char *)&buf);
2168
US_DEBUGP("Insert = %x\n", info->SD_Status.Insert);
2169
US_DEBUGP("Ready = %x\n", info->SD_Status.Ready);
2170
US_DEBUGP("IsMMC = %x\n", info->SD_Status.IsMMC);
2171
US_DEBUGP("HiCapacity = %x\n", info->SD_Status.HiCapacity);
2172
US_DEBUGP("HiSpeed = %x\n", info->SD_Status.HiSpeed);
2173
US_DEBUGP("WtP = %x\n", info->SD_Status.WtP);
2175
US_DEBUGP("SD Card Not Ready --- %x\n", buf[0]);
2176
return USB_STOR_TRANSPORT_ERROR;
2178
return USB_STOR_TRANSPORT_GOOD;
2182
static int ene_init(struct us_data *us)
2186
struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2188
result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2189
if (result != USB_STOR_XFER_GOOD)
2190
return USB_STOR_TRANSPORT_ERROR;
2192
if (misc_reg03 & 0x01) {
2193
if (!info->SD_Status.Ready) {
2194
result = ene_sd_init(us);
2195
if (result != USB_STOR_XFER_GOOD)
2196
return USB_STOR_TRANSPORT_ERROR;
2199
if (misc_reg03 & 0x02) {
2200
if (!info->MS_Status.Ready) {
2201
result = ene_ms_init(us);
2202
if (result != USB_STOR_XFER_GOOD)
2203
return USB_STOR_TRANSPORT_ERROR;
2209
/*----- sd_scsi_irp() ---------*/
2210
static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2213
struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2215
info->SrbStatus = SS_SUCCESS;
2216
switch (srb->cmnd[0]) {
2217
case TEST_UNIT_READY:
2218
result = sd_scsi_test_unit_ready(us, srb);
2221
result = sd_scsi_inquiry(us, srb);
2224
result = sd_scsi_mode_sense(us, srb);
2228
result = SD_SCSI_Start_Stop(us, srb);
2232
result = sd_scsi_read_capacity(us, srb);
2235
result = sd_scsi_read(us, srb);
2238
result = sd_scsi_write(us, srb);
2241
info->SrbStatus = SS_ILLEGAL_REQUEST;
2242
result = USB_STOR_TRANSPORT_FAILED;
2251
int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2254
struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2255
info->SrbStatus = SS_SUCCESS;
2256
switch (srb->cmnd[0]) {
2257
case TEST_UNIT_READY:
2258
result = ms_scsi_test_unit_ready(us, srb);
2261
result = ms_scsi_inquiry(us, srb);
2264
result = ms_scsi_mode_sense(us, srb);
2267
result = ms_scsi_read_capacity(us, srb);
2270
result = ms_scsi_read(us, srb);
2273
result = ms_scsi_write(us, srb);
2276
info->SrbStatus = SS_ILLEGAL_REQUEST;
2277
result = USB_STOR_TRANSPORT_FAILED;
2283
static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2286
struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2288
/*US_DEBUG(usb_stor_show_command(srb)); */
2289
scsi_set_resid(srb, 0);
2290
if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) {
2291
result = ene_init(us);
2293
if (info->SD_Status.Ready)
2294
result = sd_scsi_irp(us, srb);
2296
if (info->MS_Status.Ready)
2297
result = ms_scsi_irp(us, srb);
2303
static int ene_ub6250_probe(struct usb_interface *intf,
2304
const struct usb_device_id *id)
2310
result = usb_stor_probe1(&us, intf, id,
2311
(id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list);
2315
/* FIXME: where should the code alloc extra buf ? */
2317
us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2320
us->extra_destructor = ene_ub6250_info_destructor;
2323
us->transport_name = "ene_ub6250";
2324
us->transport = ene_transport;
2327
result = usb_stor_probe2(us);
2331
/* probe card type */
2332
result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03);
2333
if (result != USB_STOR_XFER_GOOD) {
2334
usb_stor_disconnect(intf);
2335
return USB_STOR_TRANSPORT_ERROR;
2338
if (!(misc_reg03 & 0x01)) {
2339
pr_info("ums_eneub6250: The driver only supports SD/MS card. "
2340
"To use SM card, please build driver/staging/keucr\n");
2349
static int ene_ub6250_resume(struct usb_interface *iface)
2352
struct us_data *us = usb_get_intfdata(iface);
2353
struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2355
mutex_lock(&us->dev_mutex);
2357
US_DEBUGP("%s\n", __func__);
2358
if (us->suspend_resume_hook)
2359
(us->suspend_resume_hook)(us, US_RESUME);
2361
mutex_unlock(&us->dev_mutex);
2363
info->Power_IsResum = true;
2364
/*info->SD_Status.Ready = 0; */
2365
info->SD_Status = *(struct SD_STATUS *)&tmp;
2366
info->MS_Status = *(struct MS_STATUS *)&tmp;
2367
info->SM_Status = *(struct SM_STATUS *)&tmp;
2372
static int ene_ub6250_reset_resume(struct usb_interface *iface)
2375
struct us_data *us = usb_get_intfdata(iface);
2376
struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2377
US_DEBUGP("%s\n", __func__);
2378
/* Report the reset to the SCSI core */
2379
usb_stor_reset_resume(iface);
2381
/* FIXME: Notify the subdrivers that they need to reinitialize
2383
info->Power_IsResum = true;
2384
/*info->SD_Status.Ready = 0; */
2385
info->SD_Status = *(struct SD_STATUS *)&tmp;
2386
info->MS_Status = *(struct MS_STATUS *)&tmp;
2387
info->SM_Status = *(struct SM_STATUS *)&tmp;
2394
#define ene_ub6250_resume NULL
2395
#define ene_ub6250_reset_resume NULL
2399
static struct usb_driver ene_ub6250_driver = {
2400
.name = "ums_eneub6250",
2401
.probe = ene_ub6250_probe,
2402
.disconnect = usb_stor_disconnect,
2403
.suspend = usb_stor_suspend,
2404
.resume = ene_ub6250_resume,
2405
.reset_resume = ene_ub6250_reset_resume,
2406
.pre_reset = usb_stor_pre_reset,
2407
.post_reset = usb_stor_post_reset,
2408
.id_table = ene_ub6250_usb_ids,
2412
static int __init ene_ub6250_init(void)
2414
return usb_register(&ene_ub6250_driver);
2417
static void __exit ene_ub6250_exit(void)
2419
usb_deregister(&ene_ub6250_driver);
2422
module_init(ene_ub6250_init);
2423
module_exit(ene_ub6250_exit);