aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb')
-rw-r--r--drivers/usb/storage/Kconfig4
-rw-r--r--drivers/usb/storage/ene_ub6250.c1639
2 files changed, 1632 insertions, 11 deletions
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index 58aabe679c32..bedc4b9f2ac4 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -191,8 +191,8 @@ config USB_STORAGE_ENE_UB6250
191 depends on USB && SCSI 191 depends on USB && SCSI
192 depends on USB_STORAGE 192 depends on USB_STORAGE
193 ---help--- 193 ---help---
194 Say Y here if you wish to control a ENE SD Card reader. 194 Say Y here if you wish to control a ENE SD/MS Card reader.
195 To use SM/MS card, please build driver/staging/keucr/keucr.ko 195 To use SM card, please build driver/staging/keucr/keucr.ko
196 196
197 This option depends on 'SCSI' support being enabled, but you 197 This option depends on 'SCSI' support being enabled, but you
198 probably also need 'SCSI device support: SCSI disk support' 198 probably also need 'SCSI device support: SCSI disk support'
diff --git a/drivers/usb/storage/ene_ub6250.c b/drivers/usb/storage/ene_ub6250.c
index 31645afff5fc..4dca3ef0668c 100644
--- a/drivers/usb/storage/ene_ub6250.c
+++ b/drivers/usb/storage/ene_ub6250.c
@@ -100,6 +100,141 @@ static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = {
100#define FDIR_WRITE 0 100#define FDIR_WRITE 0
101#define FDIR_READ 1 101#define FDIR_READ 1
102 102
103/* For MS Card */
104
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)
115
116/* Overwrite Area */
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)
131
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)
147
148
149#define MS_MAX_PAGES_PER_BLOCK 32
150#define MS_MAX_INITIAL_ERROR_BLOCKS 10
151#define MS_LIB_BITS_PER_BYTE 8
152
153#define MS_SYSINF_FORMAT_FAT 1
154#define MS_SYSINF_USAGE_GENERAL 0
155
156#define MS_SYSINF_MSCLASS_TYPE_1 1
157#define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */
158
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
165
166#define MS_SYSINF_RESERVED1 1
167#define MS_SYSINF_RESERVED2 1
168
169#define MS_SYSENT_TYPE_INVALID_BLOCK 0x01
170#define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */
171
172#define SIZE_OF_KIRO 1024
173#define BYTE_MASK 0xff
174
175/* ms error code */
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
191
192#define MS_REG_MNG_SYSFLG 0x04 /* system flag */
193#define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */
194
195#define MS_BOOT_BLOCK_ID 0x0001
196#define MS_BOOT_BLOCK_FORMAT_VERSION 0x0100
197#define MS_BOOT_BLOCK_DATA_ENTRIES 2
198
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
204
205#define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */
206#define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff
207
208/* overwrite area */
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 */
212
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) */
217
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
222
223#define MS_LIB_CTRL_RDONLY 0
224#define MS_LIB_CTRL_WRPROTECT 1
225
226/*dphy->log table */
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])
229
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)))
233
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))
237
103 238
104struct SD_STATUS { 239struct SD_STATUS {
105 u8 Insert:1; 240 u8 Insert:1;
@@ -132,6 +267,164 @@ struct SM_STATUS {
132 u8 IsMS:1; 267 u8 IsMS:1;
133}; 268};
134 269
270struct 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 */
289} ;
290
291struct 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 */
323};
324
325struct ms_bootblock_sysent_rec {
326 u32 dwStart;
327 u32 dwSize;
328 u8 bType;
329 u8 bReserved[3];
330};
331
332struct ms_bootblock_sysent {
333 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
334};
335
336struct 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 */
344 u8 bSecuritySupport;
345 u8 bAssemblyDate[8];
346 u8 bFactoryArea[4];
347 u8 bAssemblyMakerCode;
348 u8 bAssemblyMachineCode[3];
349 u16 wMemoryMakerCode;
350 u16 wMemoryDeviceCode;
351 u16 wMemorySize;
352 u8 bReserved1;
353 u8 bReserved2;
354 u8 bVCC;
355 u8 bVPP;
356 u16 wControllerChipNumber;
357 u16 wControllerFunction; /* New MS */
358 u8 bReserved3[9]; /* New MS */
359 u8 bParallelSupport; /* New MS */
360 u16 wFormatValue; /* New MS */
361 u8 bFormatType;
362 u8 bUsage;
363 u8 bDeviceType;
364 u8 bReserved4[22];
365 u8 bFUValue3;
366 u8 bFUValue4;
367 u8 bReserved5[15];
368};
369
370struct ms_bootblock_header {
371 u16 wBlockID;
372 u16 wFormatVersion;
373 u8 bReserved1[184];
374 u8 bNumberOfDataEntry;
375 u8 bReserved2[179];
376};
377
378struct ms_bootblock_page0 {
379 struct ms_bootblock_header header;
380 struct ms_bootblock_sysent sysent;
381 struct ms_bootblock_sysinf sysinf;
382};
383
384struct ms_bootblock_cis_idi {
385 union {
386 struct ms_bootblock_cis cis;
387 u8 dmy[256];
388 } cis;
389
390 union {
391 struct ms_bootblock_idi idi;
392 u8 dmy[256];
393 } idi;
394
395};
396
397/* ENE MS Lib struct */
398struct ms_lib_type_extdat {
399 u8 reserved;
400 u8 intr;
401 u8 status0;
402 u8 status1;
403 u8 ovrflg;
404 u8 mngflg;
405 u16 logadr;
406};
407
408struct ms_lib_ctrl {
409 u32 flags;
410 u32 BytesPerSector;
411 u32 NumberOfCylinder;
412 u32 SectorsPerCylinder;
413 u16 cardType; /* R/W, RO, Hybrid */
414 u16 blockSize;
415 u16 PagesPerBlock;
416 u16 NumberOfPhyBlock;
417 u16 NumberOfLogBlock;
418 u16 NumberOfSegment;
419 u16 *Phy2LogMap; /* phy2log table */
420 u16 *Log2PhyMap; /* log2phy table */
421 u16 wrtblk;
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];
426};
427
135 428
136/* SD Block Length */ 429/* SD Block Length */
137/* 2^9 = 512 Bytes, The HW maximum read/write data length */ 430/* 2^9 = 512 Bytes, The HW maximum read/write data length */
@@ -162,7 +455,7 @@ struct ene_ub6250_info {
162 /*----- MS Control Data ---------------- */ 455 /*----- MS Control Data ---------------- */
163 bool MS_SWWP; 456 bool MS_SWWP;
164 u32 MSP_TotalBlock; 457 u32 MSP_TotalBlock;
165 /*MS_LibControl MS_Lib;*/ 458 struct ms_lib_ctrl MS_Lib;
166 bool MS_IsRWPage; 459 bool MS_IsRWPage;
167 u16 MS_Model; 460 u16 MS_Model;
168 461
@@ -180,6 +473,7 @@ struct ene_ub6250_info {
180}; 473};
181 474
182static int ene_sd_init(struct us_data *us); 475static int ene_sd_init(struct us_data *us);
476static int ene_ms_init(struct us_data *us);
183static int ene_load_bincode(struct us_data *us, unsigned char flag); 477static int ene_load_bincode(struct us_data *us, unsigned char flag);
184 478
185static void ene_ub6250_info_destructor(void *extra) 479static void ene_ub6250_info_destructor(void *extra)
@@ -431,6 +725,1101 @@ static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
431 return result; 725 return result;
432} 726}
433 727
728/*
729 * ENE MS Card
730 */
731
732static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
733{
734 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
735
736 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
737 return (u32)-1;
738
739 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
740 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
741
742 return 0;
743}
744
745static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
746{
747 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
748
749 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
750 return (u32)-1;
751
752 info->MS_Lib.Phy2LogMap[phyblk] = mark;
753
754 return 0;
755}
756
757static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk)
758{
759 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR);
760}
761
762static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk)
763{
764 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK);
765}
766
767static int ms_lib_free_logicalmap(struct us_data *us)
768{
769 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
770
771 kfree(info->MS_Lib.Phy2LogMap);
772 info->MS_Lib.Phy2LogMap = NULL;
773
774 kfree(info->MS_Lib.Log2PhyMap);
775 info->MS_Lib.Log2PhyMap = NULL;
776
777 return 0;
778}
779
780int ms_lib_alloc_logicalmap(struct us_data *us)
781{
782 u32 i;
783 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
784
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);
787
788 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
789 ms_lib_free_logicalmap(us);
790 return (u32)-1;
791 }
792
793 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++)
794 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED;
795
796 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++)
797 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED;
798
799 return 0;
800}
801
802static void ms_lib_clear_writebuf(struct us_data *us)
803{
804 int i;
805 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
806
807 info->MS_Lib.wrtblk = (u16)-1;
808 ms_lib_clear_pagemap(info);
809
810 if (info->MS_Lib.blkpag)
811 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector);
812
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;
819 }
820 }
821}
822
823static int ms_count_freeblock(struct us_data *us, u16 PhyBlock)
824{
825 u32 Ende, Count;
826 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
827
828 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT;
829 for (Count = 0; PhyBlock < Ende; PhyBlock++) {
830 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) {
831 case MS_LB_NOT_USED:
832 case MS_LB_NOT_USED_ERASED:
833 Count++;
834 default:
835 break;
836 }
837 }
838
839 return Count;
840}
841
842static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
843 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
844{
845 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
846 int result;
847 u8 ExtBuf[4];
848 u32 bn = PhyBlockAddr * 0x20 + PageNum;
849
850 /* printk(KERN_INFO "MS --- MS_ReaderReadPage,
851 PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */
852
853 result = ene_load_bincode(us, MS_RW_PATTERN);
854 if (result != USB_STOR_XFER_GOOD)
855 return USB_STOR_TRANSPORT_ERROR;
856
857 /* Read Page Data */
858 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
859 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
860 bcb->DataTransferLength = 0x200;
861 bcb->Flags = 0x80;
862 bcb->CDB[0] = 0xF1;
863
864 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
865
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);
870
871 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
872 if (result != USB_STOR_XFER_GOOD)
873 return USB_STOR_TRANSPORT_ERROR;
874
875
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;
880 bcb->Flags = 0x80;
881 bcb->CDB[0] = 0xF1;
882 bcb->CDB[1] = 0x03;
883
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);
888 bcb->CDB[6] = 0x01;
889
890 result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
891 if (result != USB_STOR_XFER_GOOD)
892 return USB_STOR_TRANSPORT_ERROR;
893
894 ExtraDat->reserved = 0;
895 ExtraDat->intr = 0x80; /* Not yet,fireware support */
896 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
897
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]);
902
903 return USB_STOR_TRANSPORT_GOOD;
904}
905
906static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
907{
908 struct ms_bootblock_sysent *SysEntry;
909 struct ms_bootblock_sysinf *SysInfo;
910 u32 i, result;
911 u8 PageNumber;
912 u8 *PageBuffer;
913 struct ms_lib_type_extdat ExtraData;
914 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
915
916 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
917 if (PageBuffer == NULL)
918 return (u32)-1;
919
920 result = (u32)-1;
921
922 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
923
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))
931 goto exit;
932 /* */
933 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
934 case MS_SYSINF_CARDTYPE_RDONLY:
935 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
936 break;
937 case MS_SYSINF_CARDTYPE_RDWR:
938 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
939 break;
940 case MS_SYSINF_CARDTYPE_HYBRID:
941 default:
942 goto exit;
943 }
944
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);
951
952 /*Allocate to all number of logicalblock and physicalblock */
953 if (ms_lib_alloc_logicalmap(us))
954 goto exit;
955
956 /* Mark the book block */
957 ms_lib_set_bootblockmark(us, PhyBlock);
958
959 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
960
961 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
962 u32 EntryOffset, EntrySize;
963
964 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
965
966 if (EntryOffset == 0xffffff)
967 continue;
968 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
969
970 if (EntrySize == 0)
971 continue;
972
973 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
974 continue;
975
976 if (i == 0) {
977 u8 PrevPageNumber = 0;
978 u16 phyblk;
979
980 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
981 goto exit;
982
983 while (EntrySize > 0) {
984
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:
989 break;
990 case MS_STATUS_WRITE_PROTECT:
991 case MS_ERROR_FLASH_READ:
992 case MS_STATUS_ERROR:
993 default:
994 goto exit;
995 }
996
997 PrevPageNumber = PageNumber;
998 }
999
1000 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1001 if (phyblk < 0x0fff)
1002 ms_lib_set_initialerrorblock(us, phyblk);
1003
1004 EntryOffset += 2;
1005 EntrySize -= 2;
1006 }
1007 } else if (i == 1) { /* CIS/IDI */
1008 struct ms_bootblock_idi *idi;
1009
1010 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1011 goto exit;
1012
1013 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1014 case MS_STATUS_SUCCESS:
1015 break;
1016 case MS_STATUS_WRITE_PROTECT:
1017 case MS_ERROR_FLASH_READ:
1018 case MS_STATUS_ERROR:
1019 default:
1020 goto exit;
1021 }
1022
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)
1025 goto exit;
1026
1027 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1028 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1029 goto exit;
1030 }
1031 } /* End for .. */
1032
1033 result = 0;
1034
1035exit:
1036 if (result)
1037 ms_lib_free_logicalmap(us);
1038
1039 kfree(PageBuffer);
1040
1041 result = 0;
1042 return result;
1043}
1044
1045static void ms_lib_free_writebuf(struct us_data *us)
1046{
1047 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1048 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
1049
1050 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
1051
1052 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1053
1054 if (info->MS_Lib.blkpag) {
1055 kfree((u8 *)(info->MS_Lib.blkpag)); /* Arnold test ... */
1056 info->MS_Lib.blkpag = NULL;
1057 }
1058
1059 if (info->MS_Lib.blkext) {
1060 kfree((u8 *)(info->MS_Lib.blkext)); /* Arnold test ... */
1061 info->MS_Lib.blkext = NULL;
1062 }
1063}
1064
1065
1066static void ms_lib_free_allocatedarea(struct us_data *us)
1067{
1068 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1069
1070 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */
1071 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */
1072
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;
1077
1078 info->MS_Lib.cardType = 0;
1079 info->MS_Lib.blockSize = 0;
1080 info->MS_Lib.PagesPerBlock = 0;
1081
1082 info->MS_Lib.NumberOfPhyBlock = 0;
1083 info->MS_Lib.NumberOfLogBlock = 0;
1084}
1085
1086
1087static int ms_lib_alloc_writebuf(struct us_data *us)
1088{
1089 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1090
1091 info->MS_Lib.wrtblk = (u16)-1;
1092
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);
1095
1096 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1097 ms_lib_free_writebuf(us);
1098 return (u32)-1;
1099 }
1100
1101 ms_lib_clear_writebuf(us);
1102
1103return 0;
1104}
1105
1106static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1107{
1108 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1109
1110 if (logblk == MS_LB_NOT_USED)
1111 return 0;
1112
1113 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1114 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1115 return (u32)-1;
1116
1117 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1118 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1119
1120 return 0;
1121}
1122
1123static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1124 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1125{
1126 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1127 int result;
1128
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;
1134
1135 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1136 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1137 bcb->DataTransferLength = 0x200*len;
1138 bcb->Flags = 0x00;
1139 bcb->CDB[0] = 0xF0;
1140 bcb->CDB[1] = 0x08;
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;
1150
1151 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1152 if (result != USB_STOR_XFER_GOOD)
1153 return USB_STOR_TRANSPORT_ERROR;
1154
1155 return USB_STOR_TRANSPORT_GOOD;
1156}
1157
1158static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1159{
1160 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1161 int result;
1162 u32 bn = PhyBlockAddr;
1163
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;
1169
1170 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1171 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1172 bcb->DataTransferLength = 0x200;
1173 bcb->Flags = 0x80;
1174 bcb->CDB[0] = 0xF2;
1175 bcb->CDB[1] = 0x06;
1176 bcb->CDB[4] = (unsigned char)(bn);
1177 bcb->CDB[3] = (unsigned char)(bn>>8);
1178 bcb->CDB[2] = (unsigned char)(bn>>16);
1179
1180 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1181 if (result != USB_STOR_XFER_GOOD)
1182 return USB_STOR_TRANSPORT_ERROR;
1183
1184 return USB_STOR_TRANSPORT_GOOD;
1185}
1186
1187static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1188{
1189 unsigned char *PageBuf = NULL;
1190 u16 result = MS_STATUS_SUCCESS;
1191 u16 blk, index = 0;
1192 struct ms_lib_type_extdat extdat;
1193 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1194
1195 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1196 if (PageBuf == NULL) {
1197 result = MS_NO_MEMORY_ERROR;
1198 goto exit;
1199 }
1200
1201 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1202 do {
1203 blk = be16_to_cpu(PageBuf[index]);
1204 if (blk == MS_LB_NOT_USED)
1205 break;
1206 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1207 result = MS_ERROR_FLASH_READ;
1208 break;
1209 }
1210 index++;
1211 } while (1);
1212
1213exit:
1214 kfree(PageBuf);
1215 return result;
1216}
1217
1218static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1219{
1220 u16 log;
1221 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1222
1223 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1224 return (u32)-1;
1225
1226 log = info->MS_Lib.Phy2LogMap[phyblk];
1227
1228 if (log < info->MS_Lib.NumberOfLogBlock)
1229 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1230
1231 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1232 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1233
1234 return 0;
1235}
1236
1237static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1238 u8 PageNum, u8 OverwriteFlag)
1239{
1240 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1241 int result;
1242
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;
1248
1249 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1250 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1251 bcb->DataTransferLength = 0x4;
1252 bcb->Flags = 0x80;
1253 bcb->CDB[0] = 0xF2;
1254 bcb->CDB[1] = 0x05;
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;
1260 bcb->CDB[7] = 0xFF;
1261 bcb->CDB[8] = 0xFF;
1262 bcb->CDB[9] = 0xFF;
1263
1264 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1265 if (result != USB_STOR_XFER_GOOD)
1266 return USB_STOR_TRANSPORT_ERROR;
1267
1268 return USB_STOR_TRANSPORT_GOOD;
1269}
1270
1271static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1272{
1273 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1274
1275 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1276 return MS_STATUS_ERROR;
1277
1278 ms_lib_setacquired_errorblock(us, phyblk);
1279
1280 if (ms_lib_iswritable(info))
1281 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1282
1283 return MS_STATUS_SUCCESS;
1284}
1285
1286static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1287{
1288 u16 log;
1289 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1290
1291 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1292 return MS_STATUS_ERROR;
1293
1294 log = info->MS_Lib.Phy2LogMap[phyblk];
1295
1296 if (log < info->MS_Lib.NumberOfLogBlock)
1297 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1298
1299 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1300
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:
1311 default:
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;
1315 }
1316 }
1317
1318 ms_lib_setacquired_errorblock(us, phyblk);
1319
1320 return MS_STATUS_SUCCESS;
1321}
1322
1323static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1324 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1325{
1326 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1327 int result;
1328 u8 ExtBuf[4];
1329
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;
1334 bcb->Flags = 0x80;
1335 bcb->CDB[0] = 0xF1;
1336 bcb->CDB[1] = 0x03;
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);
1341 bcb->CDB[6] = 0x01;
1342
1343 result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0);
1344 if (result != USB_STOR_XFER_GOOD)
1345 return USB_STOR_TRANSPORT_ERROR;
1346
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]);
1354
1355 return USB_STOR_TRANSPORT_GOOD;
1356}
1357
1358static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1359{
1360 u16 Newblk;
1361 u16 blk;
1362 struct ms_lib_type_extdat extdat; /* need check */
1363 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1364
1365
1366 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1367 return MS_LB_ERROR;
1368
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;
1372
1373 Newblk = info->MS_Lib.Phy2LogMap[blk];
1374 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1375 return blk;
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:
1380 break;
1381 case MS_NOCARD_ERROR:
1382 return MS_NOCARD_ERROR;
1383 case MS_STATUS_INT_ERROR:
1384 return MS_LB_ERROR;
1385 case MS_ERROR_FLASH_READ:
1386 default:
1387 ms_lib_setacquired_errorblock(us, blk);
1388 continue;
1389 } /* End switch */
1390
1391 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1392 ms_lib_setacquired_errorblock(us, blk);
1393 continue;
1394 }
1395
1396 switch (ms_lib_erase_phyblock(us, blk)) {
1397 case MS_STATUS_SUCCESS:
1398 return blk;
1399 case MS_STATUS_ERROR:
1400 return MS_LB_ERROR;
1401 case MS_ERROR_FLASH_ERASE:
1402 default:
1403 ms_lib_error_phyblock(us, blk);
1404 break;
1405 }
1406 }
1407 } /* End for */
1408
1409 return MS_LB_ERROR;
1410}
1411static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1412{
1413 u16 phyblk;
1414 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1415
1416 phyblk = ms_libconv_to_physical(info, logblk);
1417 if (phyblk >= MS_LB_ERROR) {
1418 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1419 return MS_LB_ERROR;
1420
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;
1424 }
1425
1426 return ms_libsearch_block_from_physical(us, phyblk);
1427}
1428
1429static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1430{
1431 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1432
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;
1436 } else {
1437 ene_ms_init(us);
1438 return USB_STOR_TRANSPORT_GOOD;
1439 }
1440
1441 return USB_STOR_TRANSPORT_GOOD;
1442}
1443
1444static int ms_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
1445{
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};
1452
1453 usb_stor_set_xfer_buf(data_ptr, 36, srb);
1454 return USB_STOR_TRANSPORT_GOOD;
1455}
1456
1457static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1458{
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 };
1466
1467 if (info->MS_Status.WtP)
1468 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1469 else
1470 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1471
1472 return USB_STOR_TRANSPORT_GOOD;
1473}
1474
1475static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1476{
1477 u32 bl_num;
1478 u16 bl_len;
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;
1483
1484 US_DEBUGP("ms_scsi_read_capacity\n");
1485 bl_len = 0x200;
1486 if (info->MS_Status.IsMSPro)
1487 bl_num = info->MSP_TotalBlock - 1;
1488 else
1489 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1490
1491 info->bl_num = bl_num;
1492 US_DEBUGP("bl_len = %x\n", bl_len);
1493 US_DEBUGP("bl_num = %x\n", bl_num);
1494
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;
1504
1505 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1506
1507 return USB_STOR_TRANSPORT_GOOD;
1508}
1509
1510static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1511{
1512 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1513
1514 if (PhyBlock) {
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*/
1517 } else {
1518 *LogStart = 0;
1519 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/
1520 }
1521}
1522
1523static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1524 u8 PageNum, u8 blen, void *buf)
1525{
1526 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1527 int result;
1528
1529 /* printk("MS_LibReadExtraBlock --- PhyBlock = %x,
1530 PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen); */
1531
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;
1536 bcb->Flags = 0x80;
1537 bcb->CDB[0] = 0xF1;
1538 bcb->CDB[1] = 0x03;
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);
1543 bcb->CDB[6] = blen;
1544
1545 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1546 if (result != USB_STOR_XFER_GOOD)
1547 return USB_STOR_TRANSPORT_ERROR;
1548
1549 return USB_STOR_TRANSPORT_GOOD;
1550}
1551
1552static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1553{
1554 u16 PhyBlock, newblk, i;
1555 u16 LogStart, LogEnde;
1556 struct ms_lib_type_extdat extdat;
1557 u8 buf[0x200];
1558 u32 count = 0, index = 0;
1559 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1560
1561 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1562 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1563
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:
1567 continue;
1568 default:
1569 break;
1570 }
1571
1572 if (count == PhyBlock) {
1573 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, &buf);
1574 count += 0x80;
1575 }
1576 index = (PhyBlock % 0x80) * 4;
1577
1578 extdat.ovrflg = buf[index];
1579 extdat.mngflg = buf[index+1];
1580 extdat.logadr = memstick_logaddr(buf[index+2], buf[index+3]);
1581
1582 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1583 ms_lib_setacquired_errorblock(us, PhyBlock);
1584 continue;
1585 }
1586
1587 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1588 ms_lib_erase_phyblock(us, PhyBlock);
1589 continue;
1590 }
1591
1592 if (extdat.logadr != MS_LB_NOT_USED) {
1593 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1594 ms_lib_erase_phyblock(us, PhyBlock);
1595 continue;
1596 }
1597
1598 newblk = ms_libconv_to_physical(info, extdat.logadr);
1599
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);
1605 continue;
1606 }
1607 }
1608
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);
1612 continue;
1613 } else {
1614 ms_lib_erase_phyblock(us, newblk);
1615 }
1616 }
1617
1618 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1619 }
1620 }
1621 } /* End for ... */
1622
1623 return MS_STATUS_SUCCESS;
1624}
1625
1626
1627static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1628{
1629 int result;
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;
1633
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;
1638
1639 if (bn > info->bl_num)
1640 return USB_STOR_TRANSPORT_ERROR;
1641
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;
1647 }
1648
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;
1653 bcb->Flags = 0x80;
1654 bcb->CDB[0] = 0xF1;
1655 bcb->CDB[1] = 0x02;
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);
1660
1661 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1662 } else {
1663 void *buf;
1664 int offset = 0;
1665 u16 phyblk, logblk;
1666 u8 PageNum;
1667 u16 len;
1668 u32 blkno;
1669
1670 buf = kmalloc(blenByte, GFP_KERNEL);
1671 if (buf == NULL)
1672 return USB_STOR_TRANSPORT_ERROR;
1673
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;
1678 goto exit;
1679 }
1680
1681 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1682 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1683
1684 while (1) {
1685 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1686 len = info->MS_Lib.PagesPerBlock-PageNum;
1687 else
1688 len = blen;
1689
1690 phyblk = ms_libconv_to_physical(info, logblk);
1691 blkno = phyblk * 0x20 + PageNum;
1692
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;
1697 bcb->Flags = 0x80;
1698 bcb->CDB[0] = 0xF1;
1699 bcb->CDB[1] = 0x02;
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);
1704
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;
1709 goto exit;
1710 }
1711
1712 blen -= len;
1713 if (blen <= 0)
1714 break;
1715 logblk++;
1716 PageNum = 0;
1717 offset += MS_BYTES_PER_PAGE*len;
1718 }
1719 usb_stor_set_xfer_buf(buf, blenByte, srb);
1720exit:
1721 kfree(buf);
1722 }
1723 return result;
1724}
1725
1726static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1727{
1728 int result;
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;
1732
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;
1739
1740 if (bn > info->bl_num)
1741 return USB_STOR_TRANSPORT_ERROR;
1742
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;
1748 }
1749
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;
1754 bcb->Flags = 0x00;
1755 bcb->CDB[0] = 0xF0;
1756 bcb->CDB[1] = 0x04;
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);
1761
1762 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1763 } else {
1764 void *buf;
1765 int offset;
1766 u16 PhyBlockAddr;
1767 u8 PageNum;
1768 u32 result;
1769 u16 len, oldphy, newphy;
1770
1771 buf = kmalloc(blenByte, GFP_KERNEL);
1772 if (buf == NULL)
1773 return USB_STOR_TRANSPORT_ERROR;
1774 usb_stor_set_xfer_buf(buf, blenByte, srb);
1775
1776 result = ene_load_bincode(us, MS_RW_PATTERN);
1777 if (result != USB_STOR_XFER_GOOD) {
1778 pr_info("Load MS RW pattern Fail !!\n");
1779 result = USB_STOR_TRANSPORT_ERROR;
1780 goto exit;
1781 }
1782
1783 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1784 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1785
1786 while (1) {
1787 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1788 len = info->MS_Lib.PagesPerBlock-PageNum;
1789 else
1790 len = blen;
1791
1792 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */
1793 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1794
1795 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1796
1797 if (result != USB_STOR_XFER_GOOD) {
1798 pr_info("MS_SCSI_Write --- result = %x\n", result);
1799 result = USB_STOR_TRANSPORT_ERROR;
1800 goto exit;
1801 }
1802
1803 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1804 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1805
1806 blen -= len;
1807 if (blen <= 0)
1808 break;
1809 PhyBlockAddr++;
1810 PageNum = 0;
1811 offset += MS_BYTES_PER_PAGE*len;
1812 }
1813exit:
1814 kfree(buf);
1815 }
1816 return result;
1817}
1818
1819/*
1820 * ENE MS Card
1821 */
1822
434static int ene_get_card_type(struct us_data *us, u16 index, void *buf) 1823static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
435{ 1824{
436 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1825 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
@@ -505,6 +1894,19 @@ static int ene_load_bincode(struct us_data *us, unsigned char flag)
505 US_DEBUGP("SD_RDWR_PATTERN\n"); 1894 US_DEBUGP("SD_RDWR_PATTERN\n");
506 fw_name = "ene-ub6250/sd_rdwr.bin"; 1895 fw_name = "ene-ub6250/sd_rdwr.bin";
507 break; 1896 break;
1897 /* For MS */
1898 case MS_INIT_PATTERN:
1899 US_DEBUGP("MS_INIT_PATTERN\n");
1900 fw_name = "ene-ub6250/ms_init.bin";
1901 break;
1902 case MSP_RW_PATTERN:
1903 US_DEBUGP("MSP_RW_PATTERN\n");
1904 fw_name = "ene-ub6250/msp_rdwr.bin";
1905 break;
1906 case MS_RW_PATTERN:
1907 US_DEBUGP("MS_RW_PATTERN\n");
1908 fw_name = "ene-ub6250/ms_rdwr.bin";
1909 break;
508 default: 1910 default:
509 US_DEBUGP("----------- Unknown PATTERN ----------\n"); 1911 US_DEBUGP("----------- Unknown PATTERN ----------\n");
510 goto nofw; 1912 goto nofw;
@@ -540,6 +1942,182 @@ nofw:
540 return result; 1942 return result;
541} 1943}
542 1944
1945static int ms_card_init(struct us_data *us)
1946{
1947 u32 result;
1948 u16 TmpBlock;
1949 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1950 struct ms_lib_type_extdat extdat;
1951 u16 btBlk1st, btBlk2nd;
1952 u32 btBlk1stErred;
1953 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1954
1955 printk(KERN_INFO "MS_CardInit start\n");
1956
1957 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */
1958
1959 /* get two PageBuffer */
1960 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1961 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1962 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1963 result = MS_NO_MEMORY_ERROR;
1964 goto exit;
1965 }
1966
1967 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1968 btBlk1stErred = 0;
1969
1970 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1971
1972 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1973 case MS_STATUS_SUCCESS:
1974 break;
1975 case MS_STATUS_INT_ERROR:
1976 break;
1977 case MS_STATUS_ERROR:
1978 default:
1979 continue;
1980 }
1981
1982 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1983 continue;
1984
1985 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1986 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1987 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1988 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1989 continue;
1990
1991 if (btBlk1st != MS_LB_NOT_USED) {
1992 btBlk2nd = TmpBlock;
1993 break;
1994 }
1995
1996 btBlk1st = TmpBlock;
1997 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
1998 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
1999 btBlk1stErred = 1;
2000 }
2001
2002 if (btBlk1st == MS_LB_NOT_USED) {
2003 result = MS_STATUS_ERROR;
2004 goto exit;
2005 }
2006
2007 /* write protect */
2008 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2009 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2010
2011 result = MS_STATUS_ERROR;
2012 /* 1st Boot Block */
2013 if (btBlk1stErred == 0)
2014 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2015 /* 1st */
2016 /* 2nd Boot Block */
2017 if (result && (btBlk2nd != MS_LB_NOT_USED))
2018 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2019
2020 if (result) {
2021 result = MS_STATUS_ERROR;
2022 goto exit;
2023 }
2024
2025 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2026 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2027
2028 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2029
2030 if (btBlk2nd != MS_LB_NOT_USED) {
2031 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2032 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2033
2034 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2035 }
2036
2037 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2038 if (result)
2039 goto exit;
2040
2041 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2042 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2043 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2044 if (ms_count_freeblock(us, TmpBlock) == 0) {
2045 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2046 break;
2047 }
2048 }
2049
2050 /* write */
2051 if (ms_lib_alloc_writebuf(us)) {
2052 result = MS_NO_MEMORY_ERROR;
2053 goto exit;
2054 }
2055
2056 result = MS_STATUS_SUCCESS;
2057
2058exit:
2059 kfree(PageBuffer1);
2060 kfree(PageBuffer0);
2061
2062 printk(KERN_INFO "MS_CardInit end\n");
2063 return result;
2064}
2065
2066static int ene_ms_init(struct us_data *us)
2067{
2068 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2069 int result;
2070 u8 buf[0x200];
2071 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2072 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2073
2074 printk(KERN_INFO "transport --- ENE_MSInit\n");
2075
2076 /* the same part to test ENE */
2077
2078 result = ene_load_bincode(us, MS_INIT_PATTERN);
2079 if (result != USB_STOR_XFER_GOOD) {
2080 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2081 return USB_STOR_TRANSPORT_ERROR;
2082 }
2083
2084 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2085 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2086 bcb->DataTransferLength = 0x200;
2087 bcb->Flags = 0x80;
2088 bcb->CDB[0] = 0xF1;
2089 bcb->CDB[1] = 0x01;
2090
2091 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0);
2092 if (result != USB_STOR_XFER_GOOD) {
2093 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2094 return USB_STOR_TRANSPORT_ERROR;
2095 }
2096 /* the same part to test ENE */
2097 info->MS_Status = *(struct MS_STATUS *)&buf[0];
2098
2099 if (info->MS_Status.Insert && info->MS_Status.Ready) {
2100 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert);
2101 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready);
2102 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro);
2103 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG);
2104 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2105 if (info->MS_Status.IsMSPro) {
2106 MSP_BlockSize = (buf[6] << 8) | buf[7];
2107 MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
2108 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2109 } else {
2110 ms_card_init(us); /* Card is MS (to ms.c)*/
2111 }
2112 US_DEBUGP("MS Init Code OK !!\n");
2113 } else {
2114 US_DEBUGP("MS Card Not Ready --- %x\n", buf[0]);
2115 return USB_STOR_TRANSPORT_ERROR;
2116 }
2117
2118 return USB_STOR_TRANSPORT_GOOD;
2119}
2120
543static int ene_sd_init(struct us_data *us) 2121static int ene_sd_init(struct us_data *us)
544{ 2122{
545 int result; 2123 int result;
@@ -619,7 +2197,13 @@ static int ene_init(struct us_data *us)
619 return USB_STOR_TRANSPORT_ERROR; 2197 return USB_STOR_TRANSPORT_ERROR;
620 } 2198 }
621 } 2199 }
622 2200 if (misc_reg03 & 0x02) {
2201 if (!info->MS_Status.Ready) {
2202 result = ene_ms_init(us);
2203 if (result != USB_STOR_XFER_GOOD)
2204 return USB_STOR_TRANSPORT_ERROR;
2205 }
2206 }
623 return result; 2207 return result;
624} 2208}
625 2209
@@ -662,6 +2246,41 @@ static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
662 return result; 2246 return result;
663} 2247}
664 2248
2249/*
2250 * ms_scsi_irp()
2251 */
2252int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2253{
2254 int result;
2255 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2256 info->SrbStatus = SS_SUCCESS;
2257 switch (srb->cmnd[0]) {
2258 case TEST_UNIT_READY:
2259 result = ms_scsi_test_unit_ready(us, srb);
2260 break; /* 0x00 */
2261 case INQUIRY:
2262 result = ms_scsi_inquiry(us, srb);
2263 break; /* 0x12 */
2264 case MODE_SENSE:
2265 result = ms_scsi_mode_sense(us, srb);
2266 break; /* 0x1A */
2267 case READ_CAPACITY:
2268 result = ms_scsi_read_capacity(us, srb);
2269 break; /* 0x25 */
2270 case READ_10:
2271 result = ms_scsi_read(us, srb);
2272 break; /* 0x28 */
2273 case WRITE_10:
2274 result = ms_scsi_write(us, srb);
2275 break; /* 0x2A */
2276 default:
2277 info->SrbStatus = SS_ILLEGAL_REQUEST;
2278 result = USB_STOR_TRANSPORT_FAILED;
2279 break;
2280 }
2281 return result;
2282}
2283
665static int ene_transport(struct scsi_cmnd *srb, struct us_data *us) 2284static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
666{ 2285{
667 int result = 0; 2286 int result = 0;
@@ -669,11 +2288,15 @@ static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
669 2288
670 /*US_DEBUG(usb_stor_show_command(srb)); */ 2289 /*US_DEBUG(usb_stor_show_command(srb)); */
671 scsi_set_resid(srb, 0); 2290 scsi_set_resid(srb, 0);
672 if (unlikely(!info->SD_Status.Ready)) 2291 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) {
673 result = ene_init(us); 2292 result = ene_init(us);
674 else 2293 } else {
675 result = sd_scsi_irp(us, srb); 2294 if (info->SD_Status.Ready)
2295 result = sd_scsi_irp(us, srb);
676 2296
2297 if (info->MS_Status.Ready)
2298 result = ms_scsi_irp(us, srb);
2299 }
677 return 0; 2300 return 0;
678} 2301}
679 2302
@@ -714,10 +2337,8 @@ static int ene_ub6250_probe(struct usb_interface *intf,
714 } 2337 }
715 2338
716 if (!(misc_reg03 & 0x01)) { 2339 if (!(misc_reg03 & 0x01)) {
717 result = -ENODEV; 2340 pr_info("ums_eneub6250: The driver only supports SD/MS card. "
718 printk(KERN_NOTICE "ums_eneub6250: The driver only supports SD card. " 2341 "To use SM card, please build driver/staging/keucr\n");
719 "To use SM/MS card, please build driver/staging/keucr\n");
720 usb_stor_disconnect(intf);
721 } 2342 }
722 2343
723 return result; 2344 return result;
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-27 13:40:26 -0500